BufferArray(size_t size)

: RefCounted<BufferArray>(1)

, data_(new char[size]) {}

virtual ~BufferArray() {

delete[] data_;

}

const char* data() const { return data_; }

char* data() { return data_; }

char* data_;

Buffer()

: size_(IS_EMPTY) {}

Buffer(const char* data, size_t size)

: size_(size) {

if (size > static_cast<size_t>(FIXED_BUFFER_SIZE)) {

BufferArray* array = new BufferArray(size);

memcpy(array->data(), data, size);

data_.ref.array = array;

} else {

memcpy(data_.fixed, data, size);

}

}

explicit

Buffer(size_t size)

: size_(size) {

if (size > static_cast<size_t>(FIXED_BUFFER_SIZE)) {

data_.ref.array = new BufferArray(size);

}

}

Buffer(const BufferCollection* collection);

Buffer(const Buffer& buf)

: size_(IS_EMPTY) {

copy(buf);

}

Buffer& operator=(const Buffer& buf) {

copy(buf);

return *this;

}

~Buffer();

size_t encode_byte(size_t offset, uint8_t value) {

assert(is_buffer() && offset + sizeof(uint8_t) <= static_cast<size_t>(size_));

cass::encode_byte(buffer() + offset, value);

return offset + sizeof(uint8_t);

}

size_t encode_uint16(size_t offset, uint16_t value) {

assert(is_buffer() && offset + sizeof(int16_t) <= static_cast<size_t>(size_));

cass::encode_uint16(buffer() + offset, value);

return offset + sizeof(int16_t);

}

size_t encode_int32(size_t offset, int32_t value) {

assert(is_buffer() && offset + sizeof(int32_t) <= static_cast<size_t>(size_));

cass::encode_int32(buffer() + offset, value);

return offset + sizeof(int32_t);

}

size_t encode_int64(size_t offset, int64_t value) {

assert(is_buffer() && offset + sizeof(int64_t) <= static_cast<size_t>(size_));

cass::encode_int64(buffer() + offset, value);

return offset + sizeof(int64_t);

}

size_t encode_float(size_t offset, float value) {

assert(is_buffer() && offset + sizeof(float) <= static_cast<size_t>(size_));

cass::encode_float(buffer() + offset, value);

return offset + sizeof(float);

}

size_t encode_double(size_t offset, double value) {

assert(is_buffer() && offset + sizeof(double) <= static_cast<size_t>(size_));

cass::encode_double(buffer() + offset, value);

return offset + sizeof(double);

}

size_t encode_bool(size_t offset, bool value) {

return encode_byte(offset, value);

}

size_t encode_long_string(size_t offset, const char* value, int32_t size) {

size_t pos = encode_int32(offset, size);

return copy(pos, value, size);

}

size_t encode_bytes(size_t offset, const char* value, int32_t size) {

size_t pos = encode_int32(offset, size);

if (size > 0) {

return copy(pos, value, size);

}

return pos;

}

size_t encode_string(size_t offset, const char* value, uint16_t size) {

size_t pos = encode_uint16(offset, size);

return copy(pos, value, size);

}

size_t encode_string_map(size_t offset, const std::map<std::string, std::string>& value) {

size_t pos = encode_uint16(offset, value.size());

for (std::map<std::string, std::string>::const_iterator it = value.begin();

it != value.end(); ++it) {

pos = encode_string(pos, it->first.c_str(), it->first.size());

pos = encode_string(pos, it->second.c_str(), it->second.size());

}

return pos;

}

size_t copy(size_t offset, const char* value, size_t size) {

assert(is_buffer() && offset + size <= static_cast<size_t>(size_));

memcpy(buffer() + offset, value, size);

return offset + size;

}

size_t copy(size_t offset, const uint8_t* source, size_t size) {

return copy(offset, reinterpret_cast<const char*>(source), size);

}

const char* data() const {

assert(is_buffer());

return size_ > FIXED_BUFFER_SIZE ? static_cast<BufferArray*>(data_.ref.array)->data() : data_.fixed;

}

int size() const { return size_; }

bool is_buffer() const { return size_ >= 0; }

bool is_empty() const { return size_ == IS_EMPTY; }

bool is_collection() const { return size_ == IS_COLLECTION; }

const BufferCollection* collection() const;

enum {

IS_EMPTY = -1,

IS_COLLECTION = -2

};

char* buffer() {

assert(is_buffer());

return size_ > FIXED_BUFFER_SIZE ? static_cast<BufferArray*>(data_.ref.array)->data() : data_.fixed;

}

static const int FIXED_BUFFER_SIZE = 32;

void copy(const Buffer& buffer);

union BufferRef {

BufferArray* array;

const BufferCollection* collection;

};

union {

char fixed[FIXED_BUFFER_SIZE];

BufferRef ref;

} data_;

int size_;