Data.hxx

Go to the documentation of this file.

#ifndef RESIP_Data_hxx
#define RESIP_Data_hxx

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <iostream>
#include <string>
#include <bitset>
#include <cassert>

#include "rutil/compat.hxx"
#include "rutil/DataStream.hxx"
#include "rutil/HeapInstanceCounter.hxx"
#include "rutil/HashMap.hxx"

#ifndef RESIP_DATA_LOCAL_SIZE
#define RESIP_DATA_LOCAL_SIZE 16
#endif

class TestData;
namespace resip
{

template <int S>
struct DataLocalSize
{
      explicit DataLocalSize(size_t) {}
};

// .bwc. Pack class Data; has to come before doxygen block though.
#pragma pack(4)

class Data 
{
   public:
      RESIP_HeapCount(Data);

      typedef UInt32 size_type;

      inline Data()
         : mBuf(mPreBuffer),
           mSize(0),
           mCapacity(LocalAlloc),
           mShareEnum(Borrow)
      {
         mBuf[mSize] = 0;
      }

      class PreallocateType
      {
         friend class Data;
         explicit PreallocateType(int);
      };
      static const PreallocateType Preallocate;

      Data(size_type capacity, const PreallocateType&);

//#define DEPRECATED_PREALLOC
#ifdef DEPRECATED_PREALLOC

      Data(size_type capacity, bool foo);
#endif      

      Data(const char* str);

      Data(const char* buffer, size_type length);

      Data(const unsigned char* buffer, size_type length);

      Data(const Data& data);

#ifdef RESIP_HAS_RVALUE_REFS
      Data(Data &&data);
#endif

      explicit Data(const std::string& str);

      explicit Data(int value);

      explicit Data(unsigned long value);

      explicit Data(unsigned int value);

      explicit Data(UInt64 value);

#ifndef RESIP_FIXED_POINT
      enum DoubleDigitPrecision 
      {
         ZeroDigitPrecision = 0, OneDigitPrecision, 
         TwoDigitPrecision, ThreeDigitPrecision, 
         FourDigitPrecision, FiveDigitPrecision,
         SixDigitPrecision, SevenDigitPrecision,
         EightDigitPrecision, NineDigitPrecision,
         TenDigitPrecision, MaxDigitPrecision
      };
      explicit Data(double value, 
                    Data::DoubleDigitPrecision precision = FourDigitPrecision);
#endif

      explicit Data(bool value);

      explicit Data(char c);

      enum ShareEnum 
      {
        Borrow=0,

        Share=1,

        Take=2
      };

      Data(ShareEnum, const char* buffer, size_type length);

      Data(ShareEnum, const char* buffer);

      Data(ShareEnum, const Data& staticData); // Cannot call with 'Take'

      inline ~Data()
      {
         if (mShareEnum == Take)
         {
            delete[] mBuf;
         }
      }

      Data& setBuf(ShareEnum se, const char *buf, size_type length);

      Data& setBuf(ShareEnum se, const char *str)
      {
         return setBuf(se, str, (size_type)strlen(str));
      };


      Data& takeBuf(Data& other);

      Data& copy(const char *buf, size_type length);

      char* getBuf(size_type length);

      template<class T>
      static Data from(const T& x)
      {
         Data d;
         {
            DataStream s(d);
            s << x;
         }
         return d;
      }

      friend bool operator==(const Data& lhs, const Data& rhs);
      friend bool operator==(const Data& lhs, const char* rhs);

      friend bool operator<(const Data& lhs, const Data& rhs);
      friend bool operator<(const Data& lhs, const char* rhs);
      friend bool operator<(const char* lhs, const Data& rhs);

      Data& operator=(const Data& data)
      {
         if (&data==this)
             return *this;
         return copy(data.mBuf,data.mSize);
      }

#ifdef RESIP_HAS_RVALUE_REFS
      Data& operator=(Data &&data);
#endif

      Data& operator=(const char* str)
      {
         return copy(str, (size_type)strlen(str));
      }

      Data operator+(const Data& rhs) const;

      Data operator+(const char* str) const;

      Data operator+(char c) const;

      inline Data& operator+=(const Data& rhs)
      {
         return append(rhs.data(), rhs.size());
      }

      inline Data& operator+=(const char* str)
      {
         assert(str);
         return append(str, (size_type)strlen(str));
      }


      inline Data& operator+=(char c)
      {
         return append(&c, 1);
      }


      Data& operator^=(const Data& rhs);

      inline char& operator[](size_type p)
      {
         assert(p < mSize);
         own();
         return mBuf[p];
      }

      inline char operator[](size_type p) const
      {
         assert(p < mSize);
         return mBuf[p];
      }

      char& at(size_type p);

      void reserve(size_type capacity);

      Data& append(const char* str, size_type len);

      size_type truncate(size_type len);

      Data& truncate2(size_type len);

      bool empty() const { return mSize == 0; }

      size_type size() const { return mSize; }

      inline const char* data() const
      {
         return mBuf;
      }

      const char* c_str() const;

      inline const char* begin() const
      {
         return mBuf;
      }

      inline const char* end() const
      {
         return mBuf + mSize;
      }

      typedef enum
      {
         BINARY,
         BASE64,
         HEX
      } EncodingType;

      Data md5(EncodingType type=HEX) const;

      Data& lowercase();

      Data& uppercase();

      Data& schemeLowercase();

      Data hex() const;

      Data escaped() const;

      Data charEncoded() const;

      Data charUnencoded() const;

      Data urlEncoded() const;

      Data urlDecoded() const;

      EncodeStream& urlEncode(EncodeStream& s) const;

      EncodeStream& urlDecode(EncodeStream& s) const;

      Data xmlCharDataEncode() const;

      Data xmlCharDataDecode() const;

      EncodeStream& xmlCharDataEncode(EncodeStream& s) const;

      EncodeStream& xmlCharDataDecode(EncodeStream& s) const;

      Data trunc(size_type trunc) const;

      Data& clear() { return truncate2(0); };

      int convertInt() const;
      unsigned long convertUnsignedLong() const;

      size_t convertSize() const;

#ifndef RESIP_FIXED_POINT

      double convertDouble() const;
#endif

      UInt64 convertUInt64() const;

      bool prefix(const Data& pre) const;

      bool postfix(const Data& post) const;

      Data substr(size_type first, size_type count = Data::npos) const;

      size_type find(const Data& match, size_type start = 0) const;

      int replace(const Data& match, const Data& target, int max=INT_MAX);
      
      static const Data Empty;

      static const size_type npos;

      static bool init(DataLocalSize<RESIP_DATA_LOCAL_SIZE> arg);

      Data base64decode() const;

      Data base64encode(bool useUrlSafe=false) const;

      static size_t rawHash(const unsigned char* c, size_t size);

      size_t hash() const;

      static size_t rawCaseInsensitiveHash(const unsigned char* c, size_t size);

      static size_t rawCaseInsensitiveTokenHash(const unsigned char* c, size_t size);

      size_t caseInsensitivehash() const;

      size_t caseInsensitiveTokenHash() const;

      inline bool caseInsensitiveTokenCompare(const Data& rhs) const
      {
         if(mSize==rhs.mSize)
         {
            return sizeEqualCaseInsensitiveTokenCompare(rhs);
         }
         return false;
      }

      bool sizeEqualCaseInsensitiveTokenCompare(const Data& rhs) const;

      static std::bitset<256> toBitset(const resip::Data& chars);

      template<class Predicate> EncodeStream& 
          escapeToStream(EncodeStream& str, 
                         Predicate shouldEscape) const;

      std::ostream& escapeToStream(std::ostream& str, 
                                   const std::bitset<256>& shouldEscape) const;

   private:
      Data(const char* buffer, size_type length, bool);

      void own() const;

      void resize(size_type newSize, bool copy);

      static bool isHex(unsigned char c);      

      enum {LocalAlloc = RESIP_DATA_LOCAL_SIZE };

      char* mBuf;
      size_type mSize;
      size_type mCapacity;
      char mPreBuffer[LocalAlloc];
      // Null terminator for mPreBuffer when mSize==LocalAlloc lands here; this
      // is ok, because Borrow==0.
      // Note: we could use a char here, and expand mPreBuffer by 3 bytes, but 
      // this imposes a performance penalty since it requires operating on a 
      // memory location smaller than a word (requires masking and such).
      size_type mShareEnum;

      friend std::ostream& operator<<(std::ostream& strm, const Data& d);
#ifndef RESIP_USE_STL_STREAMS
      friend EncodeStream& operator<<(EncodeStream& strm, const Data& d);
#endif
      friend class ParseBuffer;
      friend class DataBuffer;
      friend class DataStream;
      friend class oDataStream;
      friend class ::TestData;
      friend class MD5Buffer;
};
// reset alignment to default
#pragma pack()


class DataHelper {
   public:
      static const bool isCharHex[256];
};

static bool invokeDataInit = Data::init(DataLocalSize<RESIP_DATA_LOCAL_SIZE>(0));

inline bool Data::isHex(unsigned char c)
{
   return DataHelper::isCharHex[c];
}

inline bool isEqualNoCase(const Data& left, const Data& right)
{
   return ( (left.size() == right.size()) &&
            (strncasecmp(left.data(), right.data(), left.size()) == 0) );
}

inline bool isTokenEqualNoCase(const Data& left, const Data& right)
{
   return left.caseInsensitiveTokenCompare(right);
}

inline bool isLessThanNoCase(const Data& left, const Data& right)
{
   size_t minsize = resipMin( left.size(), right.size() );
   int res = strncasecmp(left.data(), right.data(), minsize);

   if (res < 0)
   {
      return true;
   }
   else if (res > 0)
   {
      return false;
   }
   else
   {
      return left.size() < right.size();
   }
}

template<class Predicate> EncodeStream& 
Data::escapeToStream(EncodeStream& str, Predicate shouldEscape) const
{
   static char hex[] = "0123456789ABCDEF";

   if (empty())
   {
      return str;
   }
   
   const unsigned char* p = (unsigned char*)mBuf;
   const unsigned char* e = (unsigned char*)mBuf + mSize;

   while (p < e)
   {
      // ?abr? Why is this special cased? Removing this code
      // does not change the behavior of this method.
      if (*p == '%' 
          && e - p > 2 
          && isHex(*(p+1)) 
          && isHex(*(p+2)))
      {
         str.write((char*)p, 3);
         p+=3;
      }
      else if (shouldEscape[*p])
      {
         int hi = (*p & 0xF0)>>4;
         int low = (*p & 0x0F);

         str << '%' << hex[hi] << hex[low];
         p++;
      }
      else
      {
         str.put(*p++);
      }
   }
   return str;
}

inline bool operator!=(const Data& lhs, const Data& rhs) { return !(lhs == rhs); }
inline bool operator>(const Data& lhs, const Data& rhs) { return rhs < lhs; }
inline bool operator<=(const Data& lhs, const Data& rhs) { return !(rhs < lhs); }
inline bool operator>=(const Data& lhs, const Data& rhs) { return !(lhs < rhs); }
inline bool operator!=(const Data& lhs, const char* rhs) { return !(lhs == rhs); }
inline bool operator>(const Data& lhs, const char* rhs) { return rhs < lhs; }
inline bool operator<=(const Data& lhs, const char* rhs) { return !(rhs < lhs); }
inline bool operator>=(const Data& lhs, const char* rhs) { return !(lhs < rhs); }
inline bool operator==(const char* lhs, const Data& rhs) { return rhs == lhs; }
inline bool operator!=(const char* lhs, const Data& rhs) { return !(rhs == lhs); }
inline bool operator>(const char* lhs, const Data& rhs) { return rhs < lhs; }
inline bool operator<=(const char* lhs, const Data& rhs) { return !(rhs < lhs); }
inline bool operator>=(const char* lhs, const Data& rhs) { return !(lhs < rhs); }
#ifndef  RESIP_USE_STL_STREAMS
EncodeStream& operator<<(EncodeStream& strm, const Data& d);
#endif
inline std::ostream& operator<<(std::ostream& strm, const Data& d)
{
   return strm.write(d.mBuf, d.mSize);
}


inline Data
operator+(const char* c, const Data& d)
{
   return Data(c) + d;
}

}

HashValue(resip::Data);

#endif

/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * 3. The names "VOCAL", "Vovida Open Communication Application Library",
 *    and "Vovida Open Communication Application Library (VOCAL)" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact vocal@vovida.org.
 *
 * 4. Products derived from this software may not be called "VOCAL", nor
 *    may "VOCAL" appear in their name, without prior written
 *    permission of Vovida Networks, Inc.
 * 
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
 * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 * 
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by Vovida
 * Networks, Inc. and many individuals on behalf of Vovida Networks,
 * Inc.  For more information on Vovida Networks, Inc., please see
 * <http://www.vovida.org/>.
 *
 * vi: set shiftwidth=3 expandtab:
 */