common/DBuffer.cpp

   1
   2 #include <stdlib.h>
   3 #include <stdint.h>
   4 #include <string.h>
   5
   6 #include "DBuffer.h"
   7 #include "DBuffer.fdh"
   8
   9
  10 DBuffer::DBuffer()
  11 {
  12         fData = &fBuiltInData[0];
  13         fAllocSize = DBUFFER_BUILTIN_SIZE;
  14         fAllocdExternal = false;
  15         fLength = 0;
  16 }
  17
  18 DBuffer::~DBuffer()
  19 {
  20         if (fAllocdExternal)
  21                 free(fData);
  22 }
  23
  24 /*
  25 void c------------------------------() {}
  26 */
  27
  28 // append data to the end of the buffer
  29 void DBuffer::AppendData(const uint8_t *data, int length)
  30 {
  31         if (length <= 0) return;
  32         EnsureAlloc(fLength + length);
  33
  34         memcpy(&fData[fLength], data, length);
  35         fLength += length;
  36 }
  37
  38 // append a string, along with it's null-terminator.
  39 void DBuffer::AppendString(const char *str)
  40 {
  41         AppendData((uint8_t *)str, strlen(str) + 1);
  42 }
  43
  44 // append a string, without it's null-terminator.
  45 void DBuffer::AppendStringNoNull(const char *str)
  46 {
  47         AppendData((uint8_t *)str, strlen(str));
  48 }
  49
  50
  51 void DBuffer::AppendBool(bool value)
  52 {
  53 uint8_t ch = (uint8_t)value;
  54         AppendData((uchar *)&ch, 1);
  55 }
  56
  57 void DBuffer::Append16(uint16_t value)
  58 {
  59         AppendData((uchar *)&value, 2);
  60 }
  61
  62 void DBuffer::Append32(uint32_t value)
  63 {
  64         AppendData((uchar *)&value, 4);
  65 }
  66
  67 void DBuffer::Append24(uint32_t value)
  68 {
  69         Append16(value);
  70         Append8(value >> 16);
  71 }
  72
  73 /*
  74 void c------------------------------() {}
  75 */
  76
  77 // real SetTo code is in DBuffer.h
  78
  79 void DBuffer::SetTo(const char *string)
  80 {
  81         SetTo((const uint8_t *)string, strlen(string) + 1);
  82 }
  83
  84 void DBuffer::SetTo(DBuffer *other)
  85 {
  86         SetTo(other->Data(), other->Length());
  87 }
  88
  89 void DBuffer::SetTo(DBuffer &other)
  90 {
  91         SetTo(other.Data(), other.Length());
  92 }
  93
  94 /*
  95 void c------------------------------() {}
  96 */
  97
  98 void DBuffer::ReplaceUnprintableChars()
  99 {
 100 char *data = (char *)fData;
 101 int length = fLength;
 102 int i;
 103
 104         for(i=0;i<length;i++)
 105         {
 106                 if (data[i] == '\n' || data[i] == '\r')
 107                 {
 108                         data[i] = '+';
 109                 }
 110                 else if (((uchar)data[i] < 32 || (uchar)data[i] > 127) && data[i] != 0)
 111                 {
 112                         data[i] = '`';
 113                 }
 114         }
 115 }
 116
 117 /*
 118 void c------------------------------() {}
 119 */
 120
 121 DBuffer& DBuffer::operator= (const DBuffer &other)
 122 {
 123         SetTo((DBuffer *)&other);
 124         return *this;
 125 }
 126
 127 // return the data contained in the buffer
 128 uint8_t *DBuffer::Data()
 129 {
 130         return (uint8_t *)fData;
 131 }
 132
 133 // return the data contained in the buffer, and "steal" the pointer from the DBuffer
 134 // so that the caller obtains ownership of it and the DBuffer contents are lost.
 135 // the contents of the DBuffer are undefined after this function returns.
 136 // It is intended for quickly returning C-style pointers to data from functions which use
 137 // DBuffer internally to build the data.
 138 uint8_t *DBuffer::TakeData()
 139 {
 140         if (!fAllocdExternal)
 141         {       // we can't give them ownership of the data, because it's still small enough
 142                 // that it's located within our own object. So give them a copy instead.
 143                 uint8_t *copy = (uint8_t *)malloc(fLength);
 144                 memcpy(copy, fData, fLength);
 145                 return copy;
 146         }
 147
 148         uint8_t *data = fData;                  // save our pointer
 149         fData = NULL;                                   // now forget it, so it's not freed in the destructor
 150         fAllocdExternal = false;                // revert to internal data buffer
 151
 152         return data;
 153 }
 154
 155 // return the data, along with a trailing null-terminator
 156 char *DBuffer::String()
 157 {
 158         // ensure the data returned is null-terminated
 159         if (fLength == 0 || fData[fLength - 1] != 0)
 160         {
 161                 EnsureAlloc(fLength + 1);
 162                 fData[fLength] = '\0';
 163         }
 164
 165         return (char *)fData;
 166 }
 167
 168 // return the length of the buffer. note that this will include
 169 // any null-terminators.
 170 int DBuffer::Length()
 171 {
 172         return fLength;
 173 }
 174