Changeset 2544 for branches/blt4/src/core/RpSimpleBuffer.h

Timestamp:

Sep 21, 2011 2:28:26 PM (13 years ago)

Author:

gah

Message:

update from trunk

File:

• branches/blt4/src/core/RpSimpleBuffer.h (modified) (32 diffs)

branches/blt4/src/core/RpSimpleBuffer.h

@@ +1 @@
+
 /*
  * ======================================================================
@@ -69 +70 @@
 #include <cstdarg>
 
+/* 
+ * Note: I think I would redo this class to deal only with unsigned byte 
+ *       arrays, instead of arrays of <T>.  I would create other classes
+ *       that arrays of <T> that used the lower level byte array.
+ *
+ *       It would make it cleaner if the class only dealt with bytes
+ *       instead of elements (of various sizes).  
+ *
+ *       Specific implementations of <T> could perform data alignment on
+ *       word/double word/quad word boundaries.  This is an optimization
+ *       that should could done for double arrays.
+ *
+ * Note: The signed int argument on append() should be replaced with a 
+ *       size_t.  This limits the length of strings to appended.  It 
+ *       silently truncates bigger sizes to the lower 32-bits.  
+ */
 namespace Rappture {
 
@@ -74 +91 @@
 class SimpleBuffer {
 public:
-    SimpleBuffer();
+    /**
+     * Construct an empty SimpleBuffer.
+     */
+    SimpleBuffer() {
+        Initialize();
+    }
+    /**
+     * Construct a SimpleBuffer loaded with initial data.
+     *
+     * @param bytes pointer to bytes being stored.
+     * @param nbytes number of bytes being stored.
+     */
+    SimpleBuffer(const T* bytes, int numElems=-1) {
+        Initialize();
+        append(bytes, numElems);
+    }
     SimpleBuffer(size_t nmemb);
-    SimpleBuffer(const T* bytes, int nmemb=-1);
+    
+    /**
+     * Copy constructor
+     * @param SimpleBuffer object to copy
+     */
     SimpleBuffer(const SimpleBuffer& b);
+    
     SimpleBuffer<T>& operator=(const SimpleBuffer<T>& b);
     SimpleBuffer     operator+(const SimpleBuffer& b) const;
     SimpleBuffer<T>& operator+=(const SimpleBuffer<T>& b);
     T operator[](size_t offset);
-    virtual ~SimpleBuffer();
-
-    const T* bytes() const;
-    size_t size() const;
-    size_t nmemb() const;
-
-    SimpleBuffer<T>& clear();
+    
+    /**
+     * Destructor
+     */
+    virtual ~SimpleBuffer() {
+        Release();
+    }
+    
+    /**
+     * Get the bytes currently stored in the buffer.  These bytes can
+     * be stored, and used later to construct another Buffer to
+     * decode the information.
+     *
+     * @return Pointer to the bytes in the buffer.
+     */
+    const T* bytes() const {
+        return _buf;
+    }
+    /**
+     * Get the number of bytes currently stored in the buffer.
+     * @return Number of the bytes used in the buffer.
+     */
+    size_t size() const {
+        return _numElemsUsed * sizeof(T);
+    }
+    /**
+     * Get the number of members currently stored in the buffer.
+     * @return Number of the members used in the buffer.
+     */
+    size_t nmemb() const {
+        return _numElemsUsed;
+    }
+    /**
+     * Get the number of members currently stored in the buffer.
+     * @return Number of the members used in the buffer.
+     */
+    size_t count() const {
+        return _numElemsUsed;
+    }
+    /**
+     * Set the number of members currently stored in the buffer.
+     * @return Number of the members used in the buffer.
+     */
+    size_t count(size_t newCount) {
+        _numElemsUsed = newCount;
+        return _numElemsUsed;
+    }
+    /**
+     * Clear the buffer, making it empty.
+     * @return Reference to this buffer.
+     */
+    SimpleBuffer<T>& clear() {
+        Release();
+        return *this;
+    }
+    size_t extend(size_t extraElems);
     int append(const T* bytes, int nmemb=-1);
     int appendf(const char *format, ...);
@@ -98 +184 @@
     SimpleBuffer<T>& rewind();
     SimpleBuffer<T>& show();
-
+    
     bool good() const;
     bool bad() const;
     bool eof() const;
-
+    
     SimpleBuffer<T>& move(SimpleBuffer<T>& b);
-
+    
 protected:
-
-    void bufferInit();
-    void bufferFree();
-
+    
+    void Initialize();
+    void Release();
+    
 private:
-
+    
     /// Pointer to the memory that holds our buffer's data
     T* _buf;
-
+    
     /// Position offset within the buffer's memory
     size_t _pos;
-
+    
     /// Number of members stored in the buffer
-    size_t _nMembStored;
-
+    size_t _numElemsUsed;
+    
     /// Total number of members available in the buffer
-    size_t _nMembAvl;
-
+    size_t _numElemsAllocated;
+    
     /// State of the last file like operation.
     bool _fileState;
-
+    
     /// Minimum number of members is set to the number you can fit in 256 bytes
-    const static int _minMembCnt=(256/sizeof(T));
-
+    const static size_t _minNumElems = (256/sizeof(T));
+    
     size_t __guesslen(const T* bytes);
-
+    
 };
-
+    
 typedef SimpleBuffer<char>   SimpleCharBuffer;
 typedef SimpleBuffer<float>  SimpleFloatBuffer;
@@ -139 +225 @@
 
 /**
- * Construct an empty SimpleBuffer.
- */
-template<class T>
-SimpleBuffer<T>::SimpleBuffer()
-{
-    bufferInit();
-}
-
-
-/**
  * Construct an empty SimpleBuffer of specified size.
  */
 template<class T>
-SimpleBuffer<T>::SimpleBuffer(size_t nmemb)
-{
-    bufferInit();
-
-    if (nmemb == 0) {
+SimpleBuffer<T>::SimpleBuffer(size_t numElems)
+{
+    Initialize();
+
+    if (numElems == 0) {
         // ignore requests for sizes equal to zero
         return;
@@ -162 +238 @@
 
     // buffer sizes less than min_size are set to min_size
-    if (nmemb < (size_t) _minMembCnt) {
-        nmemb = _minMembCnt;
-    }
-
-    if (set(nmemb) != nmemb) {
+    if (numElems < (size_t) _minNumElems) {
+        numElems = _minNumElems;
+    }
+
+    if (set(numElems) != numElems) {
         return;
     }
-    _nMembStored = nmemb;
-}
-
-
-/**
- * Construct a SimpleBuffer loaded with initial data.
- *
- * @param bytes pointer to bytes being stored.
- * @param nbytes number of bytes being stored.
- */
-template<class T>
-SimpleBuffer<T>::SimpleBuffer(const T* bytes, int nmemb)
-{
-    bufferInit();
-    append(bytes,nmemb);
+    _numElemsUsed = numElems;
 }
 
@@ -194 +256 @@
 SimpleBuffer<T>::SimpleBuffer(const SimpleBuffer<T>& b)
 {
-    bufferInit();
-    append(b.bytes(),b.nmemb());
+    Initialize();
+    append(b.bytes(), b.nmemb());
 }
 
@@ -207 +269 @@
 SimpleBuffer<T>::operator=(const SimpleBuffer<T>& b)
 {
-    bufferFree();
-    bufferInit();
+    Release();
     append(b.bytes(),b.nmemb());
     return *this;
@@ -247 +308 @@
 template<class T>
 T
-SimpleBuffer<T>::operator[](size_t idx)
-{
-    return (_buf+idx);
-}
-
-
-/**
- * Destructor
- */
-template<class T>
-SimpleBuffer<T>::~SimpleBuffer()
-{
-    bufferFree();
-}
-
-
-/**
- * Get the bytes currently stored in the buffer.  These bytes can
- * be stored, and used later to construct another Buffer to
- * decode the information.
- *
- * @return Pointer to the bytes in the buffer.
- */
-template<class T>
-const T*
-SimpleBuffer<T>::bytes() const
-{
-    return _buf;
-}
-
-
-/**
- * Get the number of bytes currently stored in the buffer.
- * @return Number of the bytes used in the buffer.
- */
-template<class T>
-size_t
-SimpleBuffer<T>::size() const
-{
-    return _nMembStored*sizeof(T);
-}
-
-
-/**
- * Get the number of members currently stored in the buffer.
- * @return Number of the members used in the buffer.
- */
-template<class T>
-size_t
-SimpleBuffer<T>::nmemb() const
-{
-    return _nMembStored;
-}
-
-
-/**
- * Clear the buffer, making it empty.
- * @return Reference to this buffer.
- */
-template<class T>
-SimpleBuffer<T>&
-SimpleBuffer<T>::clear()
-{
-    bufferFree();
-    bufferInit();
-
-    return *this;
-}
+SimpleBuffer<T>::operator[](size_t index)
+{
+    return (_buf + index);              // Rely on pointer arithmetic
+}
+
+
 
 /**
@@ -327 +326 @@
     return strlen(bytes);
 }
+
+/* FIXME:       Change the signed int to size_t.  Move the -1 copy string
+ *              up to the SimpleCharBuffer class.   There needs to be both
+ *              a heavy duty class that can take a string bigger than 
+ *              2^31-1 in length, and a convenient class that doesn't make
+ *              you add call strlen(s).
+ *              
+ */
 
 /**
@@ -348 +355 @@
 template<class T>
 int
-SimpleBuffer<T>::append(const T* bytes, int nmemb)
-{
-    size_t newMembCnt = 0;
-    size_t nbytes = 0;
-
-    void* dest = NULL;
-    void const* src  = NULL;
-    size_t size = 0;
+SimpleBuffer<T>::append(const T* bytes, int numElems)
+{
 
     // User specified NULL buffer to append
-    if ( (bytes == NULL) && (nmemb < 1) ) {
-        return 0;
+    if (bytes == NULL) {
+        return 0;                       // Should not give append a NULL
+                                        // buffer pointer.
     }
 
@@ -367 +369 @@
     // bytes in *bytes.
 
-    if (nmemb == -1) {
-        // user signaled null terminated string
-        // or that we should make an educated guess
-        // at the length of the object.
-        nbytes = __guesslen(bytes);
-        nmemb = nbytes/sizeof(T);
-    }
-
-    if (nmemb <= 0) {
+    size_t numBytes = 0;
+    if (numElems == -1) {
+        /* This should be moved into the SimpleCharBuffer.  It doesn't make
+         * sense to look for a NUL byte unless it's a string buffer. We
+         * can then change numElems to be size_t. */
+        numBytes = __guesslen(bytes);
+        numElems = numBytes / sizeof(T);
+    }
+    if (numElems <= 0) {
+        return numElems;
+    }
+
+    size_t newSize;
+    newSize = _numElemsUsed + numElems;
+    if (newSize > _numElemsAllocated) {
+
+        // buffer sizes less than min_size are set to min_size
+        if (newSize < _minNumElems) {
+            newSize = _minNumElems;
+        }
+
+        /*
+         * Allocate a larger buffer for the string if the current one isn't
+         * large enough. Allocate extra space in the new buffer so that there
+         * will be room to grow before we have to allocate again.
+         */
+        size_t size;
+        size = (_numElemsAllocated > 0) ? _numElemsAllocated : _minNumElems;
+        while (newSize > size) {
+            size += size;
+        }
+
+        /*
+         * reallocate to a larger buffer
+         */
+        if (set(size) != size) {
+            return 0;
+        }
+    }
+    memcpy(_buf + _numElemsUsed, bytes, numElems * sizeof(T));
+    _numElemsUsed += numElems;
+    return numElems;
+}
+
+/**
+ * Append bytes to the end of this buffer
+ * @param pointer to bytes to be added
+ * @param number of bytes to be added
+ * @return number of bytes appended.
+ */
+template<class T>
+size_t
+SimpleBuffer<T>::extend(size_t numExtraElems)
+{
+    size_t newSize;
+
+    newSize = _numElemsUsed + numExtraElems;
+    if (newSize > _numElemsAllocated) {
+
+        /* Enforce a minimum buffer size. */
+        if (newSize < (size_t) _minNumElems) {
+            newSize = (size_t) _minNumElems;
+        }
+
+        size_t size;
+        size = (_numElemsAllocated > 0) ? _numElemsAllocated : _minNumElems;
+
+        /* Keep doubling the size of the buffer until we have enough space to
+         * hold the extra elements. */
+        while (newSize > size) {
+            size += size;
+        }
+        /* Reallocate to a larger buffer. */
+        if (set(size) != size) {
+            return 0;
+        }
+    }
+    return _numElemsAllocated;
+}
+
+/**
+ * Append formatted bytes to the end of this buffer
+ * @param pointer to bytes to be added
+ * @param number of bytes to be added
+ * @return number of bytes appended.
+ */
+template<class T>
+int
+SimpleBuffer<T>::appendf(const char *format, ...)
+{
+    size_t newMembCnt = 0;
+    size_t nbytes = 0;
+    int nmemb = 0;
+
+    char* dest = NULL;
+    size_t size = 0;
+    size_t bytesAdded = 0;
+    va_list arg;
+
+    // User specified NULL format
+    if (format == NULL) {
+        return 0;
+    }
+
+    // FIXME: i think this needs to be division,
+    // need to create test case with array of ints
+    // i'm not sure we can even guess the number
+    // bytes in *bytes.
+
+
+    // add one for terminating null character
+    nbytes = strlen(format) + 1;
+
+    if (nbytes <= 0) {
         // no data written, invalid option
-        return nmemb;
-    }
-
-    newMembCnt = (size_t)(_nMembStored + nmemb);
-
-    if (newMembCnt > _nMembAvl) {
+        return nbytes;
+    }
+
+    // FIXME: we need ceil of nbytes/sizeof(T), instead we add 1 for safety
+
+    nmemb = nbytes/sizeof(T);
+    if (nmemb == 0) {
+        nmemb++;
+    }
+
+    newMembCnt = (size_t)(_numElemsUsed + nmemb);
+
+    if (newMembCnt > _numElemsAllocated) {
 
         // buffer sizes less than min_size are set to min_size
-        if (newMembCnt < (size_t) _minMembCnt) {
-            newMembCnt = (size_t) _minMembCnt;
+        if (newMembCnt < (size_t) _minNumElems) {
+            newMembCnt = (size_t) _minNumElems;
         }
 
@@ -395 +509 @@
          */
         size_t membAvl;
-        membAvl = (_nMembAvl > 0) ? _nMembAvl : _minMembCnt;
+        membAvl = (_numElemsAllocated > 0) ? _numElemsAllocated : _minNumElems;
         while (newMembCnt > membAvl) {
             membAvl += membAvl;
@@ -408 +522 @@
     }
 
-    dest = (void*) (_buf + _nMembStored);
-    src  = (void const*) bytes;
-    size = (size_t) (nmemb*sizeof(T));
-    memcpy(dest,src,size);
-
-    _nMembStored += nmemb;
-
-    return nmemb;
-}
-
-/**
- * Append formatted bytes to the end of this buffer
- * @param pointer to bytes to be added
- * @param number of bytes to be added
- * @return number of bytes appended.
- */
-template<class T>
-int
-SimpleBuffer<T>::appendf(const char *format, ...)
-{
-    size_t newMembCnt = 0;
-    size_t nbytes = 0;
-    int nmemb = 0;
-
-    char* dest = NULL;
-    size_t size = 0;
-    size_t bytesAdded = 0;
-    va_list arg;
-
-    // User specified NULL format
-    if (format == NULL) {
-        return 0;
-    }
-
-    // FIXME: i think this needs to be division,
-    // need to create test case with array of ints
-    // i'm not sure we can even guess the number
-    // bytes in *bytes.
-
-
-    // add one for terminating null character
-    nbytes = strlen(format) + 1;
-
-    if (nbytes <= 0) {
-        // no data written, invalid option
-        return nbytes;
-    }
-
-    // FIXME: we need ceil of nbytes/sizeof(T), instead we add 1 for safety
-
-    nmemb = nbytes/sizeof(T);
-    if (nmemb == 0) {
-        nmemb++;
-    }
-
-    newMembCnt = (size_t)(_nMembStored + nmemb);
-
-    if (newMembCnt > _nMembAvl) {
-
-        // buffer sizes less than min_size are set to min_size
-        if (newMembCnt < (size_t) _minMembCnt) {
-            newMembCnt = (size_t) _minMembCnt;
-        }
-
-        /*
-         * Allocate a larger buffer for the string if the current one isn't
-         * large enough. Allocate extra space in the new buffer so that there
-         * will be room to grow before we have to allocate again.
-         */
-        size_t membAvl;
-        membAvl = (_nMembAvl > 0) ? _nMembAvl : _minMembCnt;
-        while (newMembCnt > membAvl) {
-            membAvl += membAvl;
-        }
-
-        /*
-         * reallocate to a larger buffer
-         */
-        if (set(membAvl) != membAvl) {
-            return 0;
-        }
-    }
-
-    dest = (char*) (_buf + _nMembStored);
-    size = (_nMembAvl-_nMembStored)*sizeof(T);
+    dest = (char*) (_buf + _numElemsUsed);
+    size = (_numElemsAllocated-_numElemsUsed)*sizeof(T);
 
     va_start(arg,format);
@@ -511 +542 @@
 
         // FIXME: round the new size up to the nearest multiple of 256?
-        set(_nMembStored+nmemb);
+        set(_numElemsUsed+nmemb);
 
         // reset dest because it may have moved during reallocation
-        dest = (char*) (_buf + _nMembStored);
+        dest = (char*) (_buf + _numElemsUsed);
         size = bytesAdded;
 
@@ -528 +559 @@
     }
 
-    _nMembStored += nmemb;
+    _numElemsUsed += nmemb;
 
     // remove the null character added by vsnprintf()
@@ -549 +580 @@
 SimpleBuffer<T>::remove(int nmemb)
 {
-    if ((_nMembStored - nmemb) < 0){
-        _nMembStored = 0;
+    if ((_numElemsUsed - nmemb) < 0){
+        _numElemsUsed = 0;
         _pos = 0;
     } else {
-        _nMembStored -= nmemb;
-        if (_pos >= _nMembStored) {
+        _numElemsUsed -= nmemb;
+        if (_pos >= _numElemsUsed) {
             // move _pos back to the new end of the buffer.
-            _pos = _nMembStored-1;
+            _pos = _numElemsUsed-1;
         }
     }
@@ -563 +594 @@
     return nmemb;
 }
-
 
 template<class T>
@@ -585 +615 @@
     }
     _buf = buf;
-    _nMembAvl = nmemb;
-    return _nMembAvl;
-}
-
+    _numElemsAllocated = nmemb;
+    return _numElemsAllocated;
+}
 
 template<> inline
@@ -596 +625 @@
     size_t curMemb = 0;
 
-    while (curMemb != _nMembStored) {
+    while (curMemb != _numElemsUsed) {
         fprintf(stdout,"_buf[%lu] = :%c:\n", (long unsigned int)curMemb,
                 _buf[curMemb]);
         curMemb += 1;
     }
-    fprintf(stdout,"_nMembAvl = :%lu:\n", (long unsigned int)_nMembAvl);
+    fprintf(stdout,"_numElemsAllocated = :%lu:\n", 
+            (long unsigned int)_numElemsAllocated);
 
     return *this;
@@ -613 +643 @@
     size_t curMemb = 0;
 
-    while (curMemb != _nMembStored) {
+    while (curMemb != _numElemsUsed) {
         fprintf(stdout,"_buf[%lu] = :%#x:\n", (long unsigned int)curMemb,
                 (unsigned long)_buf[curMemb]);
         curMemb += 1;
     }
-    fprintf(stdout,"_nMembAvl = :%lu:\n", (long unsigned int)_nMembAvl);
+    fprintf(stdout,"_numElemsAllocated = :%lu:\n", (long unsigned int)_numElemsAllocated);
 
     return *this;
@@ -651 +681 @@
 
     // make sure we don't read off the end of our buffer
-    if ( (_pos + nmemb) > _nMembStored ) {
-        nMembRead = _nMembStored - _pos;
+    if ( (_pos + nmemb) > _numElemsUsed ) {
+        nMembRead = _numElemsUsed - _pos;
     }
     else {
@@ -694 +724 @@
             _pos = 0;
         }
-        else if (offset >= (long)_nMembStored) {
+        else if (offset >= (long)_numElemsUsed) {
             /* dont go off the end of data */
-            _pos = _nMembStored - 1;
+            _pos = _numElemsUsed - 1;
         }
         else {
@@ -707 +737 @@
             _pos = 0;
         }
-        else if ((_pos + offset) >= _nMembStored) {
+        else if ((_pos + offset) >= _numElemsUsed) {
             /* dont go off the end of data */
-            _pos = _nMembStored - 1;
+            _pos = _numElemsUsed - 1;
         }
         else {
@@ -716 +746 @@
     }
     else if (whence == SEEK_END) {
-        if (offset <= (long)(-1*_nMembStored)) {
+        if (offset <= (long)(-1*_numElemsUsed)) {
             /* dont go off the beginning of data */
             _pos = 0;
@@ -722 +752 @@
         else if (offset >= 0) {
             /* dont go off the end of data */
-            _pos = _nMembStored - 1;
+            _pos = _numElemsUsed - 1;
         }
         else {
-            _pos = (size_t)((_nMembStored - 1) + offset);
+            _pos = (size_t)((_numElemsUsed - 1) + offset);
         }
     }
@@ -794 +824 @@
 SimpleBuffer<T>::eof() const
 {
-    return (_pos >= _nMembStored);
+    return (_pos >= _numElemsUsed);
 }
 
@@ -801 +831 @@
  * Move the data from this SimpleBuffer to the SimpleBuffer provided by
  * the caller. All data except the _pos is moved and this SimpleBuffer is
- * re-initialized with bufferInit().
+ * re-initialized with Initialize().
  * @param SimpleBuffer to move the information to
  * @return reference to this SimpleBuffer object.
@@ -809 +839 @@
 SimpleBuffer<T>::move(SimpleBuffer<T>& b)
 {
-    bufferFree();
+    Release();
 
     _buf = b._buf;
     _pos = b._pos;
     _fileState = b._fileState;
-    _nMembStored = b._nMembStored;
-    _nMembAvl = b._nMembAvl;
-
-    b.bufferInit();
+    _numElemsUsed = b._numElemsUsed;
+    _numElemsAllocated = b._numElemsAllocated;
+
+    b.Initialize();
 
     return *this;
@@ -825 +855 @@
  /**
   *  Initializes a dynamic buffer, discarding any previous contents
-  *  of the buffer. bufferFree() should have been called already
+  *  of the buffer. Release() should have been called already
   *  if the dynamic buffer was previously in use.
   */
 template<class T>
 void
-SimpleBuffer<T>::bufferInit()
+SimpleBuffer<T>::Initialize()
 {
     _buf = NULL;
     _pos = 0;
     _fileState = true;
-    _nMembStored = 0;
-    _nMembAvl = 0;
+    _numElemsUsed = 0;
+    _numElemsAllocated = 0;
 }
 
@@ -846 +876 @@
 template<class T>
 void
-SimpleBuffer<T>::bufferFree()
+SimpleBuffer<T>::Release()
 {
     if (_buf != NULL) {
@@ -852 +882 @@
         _buf = NULL;
     }
-    bufferInit();
+    Initialize();
 }