PhxBuffer.h

Go to the documentation of this file.

#ifndef PHX_BUFFER_H
#define PHX_BUFFER_H

#include <vector>
#include <Phx/Util/PhxPtr.h>
#include <Phx/Util/PhxPtrInterface.h>

namespace Phx {

  template <typename T>
    class Buffer : public LockedPtrInterface<Buffer<T> > {
  public:

    Buffer(const T* data, uint32_t size) : mBuffer(0), mSize(0) {
      buffer(data, size);
    }

    Buffer(const std::vector<T>& array) : mBuffer(0), mSize(0) {
      buffer(0, array.size());
      uint32_t i = 0;
      for (typename std::vector<T>::const_iterator itr = array.begin();
           itr != array.end(); ++itr) {
        mBuffer[i++] = *itr;
      }
    }

    Buffer(uint32_t size = 0) : mBuffer(0), mSize(0) {
      buffer(0, size);
    }

    uint32_t size() const { return mSize; }

    void size(uint32_t len) { resize(len, true); }

    T* buffer() { return mBuffer; }
    const T* buffer() const { return mBuffer; }

    void buffer(const T* buffer, uint32_t len) {
      resize(len, false);
      if (buffer) {
        for (uint32_t i = 0; i < len; i++) {
          mBuffer[i] = buffer[i];
        }
      }
    }
    
  private:
    void resize(uint32_t size, bool copyOld) {
      if (size == 0) {
        delete[] mBuffer;
        mBuffer = 0;
        mSize = 0;
      } else if (size != mSize) {
        // Allocate new buffer and copy old data
        T* newBuffer = new T[size];

        if (copyOld && mBuffer) {
          try {
            for (uint32_t i = 0; i < size && i < mSize; i++) {
              newBuffer[i] = mBuffer[i];
            }
          } catch(...) {
            delete[] newBuffer;
            throw ;
          }
        }

        // reallocation successful -- throw away old buffer and set params.
        delete[] mBuffer; // should not throw (destructors).
        mBuffer = newBuffer; // doesn't throw.
        mSize = size;
      }
    }


    // --- private data ---
    T* mBuffer;
    uint32_t mSize;
  };
  
}; // namespace Phx

#endif /* PHX_BUFFER_H */

---