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>
#if RESIP_HAVE_STRING_VIEW
#include <string_view>
#endif
#include "rutil/ResipAssert.h"
 
#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) noexcept {}
};
 
// .bwc. Pack class Data; has to come before doxygen block though.
#pragma pack(push, 4)
 
class Data 
{
   public:
      RESIP_HeapCount(Data);
 
      typedef size_t 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);
 
      Data(Data &&data) noexcept;
      Data(const std::string& str);
 
#if RESIP_HAVE_STRING_VIEW
      Data(const std::string_view sv);
#endif
 
      explicit Data(int32_t value);
 
      explicit Data(uint32_t value);
 
      explicit Data(uint64_t 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, size_type length, size_type capacity);
 
      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) noexcept;
 
      Data& duplicate(const 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 std::string& rhs) noexcept;
#if RESIP_HAVE_STRING_VIEW
      friend bool operator==(const Data& lhs, const std::string_view rhs) noexcept;
#endif
 
      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);
      friend bool operator<(const Data& lhs, const std::string& rhs) noexcept;
      friend bool operator<(const std::string& lhs, const Data& rhs) noexcept;
#if RESIP_HAVE_STRING_VIEW
      friend bool operator<(const Data& lhs, const std::string_view rhs) noexcept;
      friend bool operator<(const std::string_view lhs, const Data& rhs) noexcept;
#endif
 
      Data& operator=(const Data& data)
      {
         if (&data==this)
             return *this;
         return copy(data.mBuf,data.mSize);
      }
 
      Data& operator=(Data &&data) noexcept;
 
      operator std::string() const 
      {
         return std::string(c_str(), size());
      }
 
      Data& operator=(const char* str)
      {
         return copy(str, (size_type)strlen(str));
      }
 
 
      Data& operator=(const std::string& str)
      {
         return copy(str.c_str(), static_cast<size_type>(str.size()));
      }
 
#if RESIP_HAVE_STRING_VIEW
 
      operator std::string_view() const 
      {
         return std::string_view(c_str(), size());
      }
 
      Data& operator=(const std::string_view sv)
      {
         return copy(sv.data(), static_cast<size_type>(sv.size()));
      }
#endif
 
      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)
      {
         resip_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)
      {
         resip_assert(p < mSize);
         own();
         return mBuf[p];
      }
 
      inline char operator[](size_type p) const
      {
         resip_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 noexcept { return mSize == 0; }
 
      size_type size() const noexcept { return mSize; }
 
      const char* data() const noexcept
      {
         return mBuf;
      }
 
      const char* c_str() const;
 
      std::string toString() const;
 
#if RESIP_HAVE_STRING_VIEW
      std::string_view toStringView() const;
#endif
 
      const char* begin() const noexcept
      {
         return mBuf;
      }
 
      const char* end() const noexcept
      {
         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 fromHex() 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_t convertUInt64() const;
 
      bool prefix(const Data& pre) const noexcept;
      bool prefixNoCase(const Data& pre) const noexcept;
 
      bool postfix(const Data& post) const noexcept;
      bool postfixNoCase(const Data& post) const noexcept;
 
      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;
 
      static size_t rawKeyedHash(const unsigned char* c, size_t size);
 
      static size_t rawKeyedCaseInsensitiveHash(const unsigned char* c, size_t size);
 
      size_t keyedHash() const;
 
      size_t keyedCaseInsensitiveHash() 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;
 
      static Data fromFile(const Data& filename);
 
   private:
      Data(const char* buffer, size_type length, bool);
 
      inline void initFromString(const char* str, size_type len);
 
      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 previous value
#pragma pack(pop)
 
 
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)
{
   // Shut up the warning about invokeDataInit defined, but not used
   if(0){(void) invokeDataInit;}
 
   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
{
   constexpr 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); }
 
inline bool operator!=(const Data& lhs, const std::string& rhs) noexcept { return !(lhs == rhs); }
inline bool operator>(const Data& lhs, const std::string& rhs) { return rhs < lhs; }
inline bool operator<=(const Data& lhs, const std::string& rhs) { return !(rhs < lhs); }
inline bool operator>=(const Data& lhs, const std::string& rhs) { return !(lhs < rhs); }
 
inline bool operator==(const std::string& lhs, const Data& rhs) noexcept { return rhs == lhs; }
inline bool operator!=(const std::string& lhs, const Data& rhs) noexcept { return !(rhs == lhs); }
inline bool operator>(const std::string& lhs, const Data& rhs) { return rhs < lhs; }
inline bool operator<=(const std::string& lhs, const Data& rhs) { return !(rhs < lhs); }
inline bool operator>=(const std::string& lhs, const Data& rhs) { return !(lhs < rhs); }
 
#if RESIP_HAVE_STRING_VIEW
inline bool operator!=(const Data& lhs, const std::string_view rhs) noexcept { return !(lhs == rhs); }
inline bool operator>(const Data& lhs, const std::string_view rhs) { return rhs < lhs; }
inline bool operator<=(const Data& lhs, const std::string_view rhs) { return !(rhs < lhs); }
inline bool operator>=(const Data& lhs, const std::string_view rhs) { return !(lhs < rhs); }
 
inline bool operator==(const std::string_view lhs, const Data& rhs) noexcept { return rhs == lhs; }
inline bool operator!=(const std::string_view lhs, const Data& rhs) noexcept { return !(rhs == lhs); }
inline bool operator>(const std::string_view lhs, const Data& rhs) { return rhs < lhs; }
inline bool operator<=(const std::string_view lhs, const Data& rhs) { return !(rhs < lhs); }
inline bool operator>=(const std::string_view lhs, const Data& rhs) { return !(lhs < rhs); }
#endif
 
#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;
}
 
bool operator==(const Data& lhs, const Data& rhs);
bool operator==(const Data& lhs, const char* rhs);
bool operator==(const Data& lhs, const std::string& rhs) noexcept;
#if RESIP_HAVE_STRING_VIEW
bool operator==(const Data& lhs, const std::string_view rhs) noexcept;
#endif
 
bool operator<(const Data& lhs, const Data& rhs);
bool operator<(const Data& lhs, const char* rhs);
bool operator<(const char* lhs, const Data& rhs);
bool operator<(const Data& lhs, const std::string& rhs) noexcept;
bool operator<(const std::string& lhs, const Data& rhs) noexcept;
#if RESIP_HAVE_STRING_VIEW
bool operator<(const Data& lhs, const std::string_view rhs) noexcept;
bool operator<(const std::string_view lhs, const Data& rhs) noexcept;
#endif
 
struct KeyedDataHash
{
   size_t operator()(const Data& data) const { return data.keyedHash(); }
};
 
inline size_t hashCombine(size_t seed, size_t hash)
{
   return seed ^ (hash + (size_t)0x9e3779b97f4a7c15ULL + (seed << 6) + (seed >> 2));
}
}
 
HashValue(resip::Data);
 
#endif
 
/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * Copyright (c) 2026 SIP Spectrum, Inc. https://www.sipspectrum.com
 * 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:
 */