diff --git a/src/common/classes/ClumpletReader.cpp b/src/common/classes/ClumpletReader.cpp index 2c8523a486..28f940f099 100644 --- a/src/common/classes/ClumpletReader.cpp +++ b/src/common/classes/ClumpletReader.cpp @@ -40,7 +40,7 @@ void ClumpletReader::moveNext() { } size_t length = clumplet[1]; - current_pos += length + 1; + cur_offset += length + 1; } // Methods which work with currently selected clumplet @@ -51,7 +51,7 @@ UCHAR ClumpletReader::getClumpTag() { // Check for EOF if (clumplet >= buffer_end) { read_past_eof(); - return; + return 0; } return clumplet[0]; @@ -64,7 +64,7 @@ size_t ClumpletReader::getClumpLength() { // Check for EOF if (clumplet >= buffer_end) { read_past_eof(); - return; + return 0; } // See if we have length byte available @@ -79,6 +79,8 @@ size_t ClumpletReader::getClumpLength() { invalid_structure(); return buffer_end - clumplet - 1; } + + return length; } SLONG ClumpletReader::getInt() { @@ -124,7 +126,7 @@ SINT64 ClumpletReader::getBigInt() { string& ClumpletReader::getString(string& str) { UCHAR* clumplet = getBuffer() + cur_offset; size_t length = getClumpLength(); - str.assign(clumplet + 2, length); + str.assign(reinterpret_cast(clumplet + 2), length); return str; } diff --git a/src/common/classes/ClumpletReader.h b/src/common/classes/ClumpletReader.h index da7b152df5..86aa8b7153 100644 --- a/src/common/classes/ClumpletReader.h +++ b/src/common/classes/ClumpletReader.h @@ -24,12 +24,12 @@ * Contributor(s): ______________________________________. * * - * $Id: ClumpletReader.h,v 1.1 2004-10-22 06:24:40 skidder Exp $ + * $Id: ClumpletReader.h,v 1.2 2004-10-23 01:21:11 skidder Exp $ * */ -#ifndef CLUMPLET_BUFFER_H -#define CLUMPLET_BUFFER_H +#ifndef CLUMPLETREADER_H +#define CLUMPLETREADER_H #include "../common/classes/alloc.h" #include "../common/classes/array.h" @@ -46,7 +46,7 @@ public: static_buffer_end(buffer + buffLen) { }; // Navigation in clumplet buffer - bool isEof() { return current_pos >= getBufferLength(); } + bool isEof() { return cur_offset >= getBufferLength(); } void moveNext(); // Methods which work with currently selected clumplet @@ -56,11 +56,13 @@ public: SLONG getInt(); SINT64 getBigInt(); string& getString(string& str); - const char* getBytes() { return clumplet + 2; } + const UCHAR* getBytes() { return getBuffer() + cur_offset + 2; } // Return the tag for buffer (usually structure version) UCHAR getBufferTag(); size_t getBufferLength() { return getBufferEnd() - getBuffer(); } + size_t getCurOffset() { return cur_offset; } + size_t setCurOffset(size_t newOffset) { cur_offset = newOffset; } protected: size_t cur_offset; @@ -80,7 +82,7 @@ private: const UCHAR* static_buffer; const UCHAR* static_buffer_end; -} +}; } // namespace Firebird diff --git a/src/common/classes/ClumpletWriter.cpp b/src/common/classes/ClumpletWriter.cpp index 5e234b8d37..44781bbba9 100644 --- a/src/common/classes/ClumpletWriter.cpp +++ b/src/common/classes/ClumpletWriter.cpp @@ -24,7 +24,7 @@ * Contributor(s): ______________________________________. * * - * $Id: ClumpletWriter.cpp,v 1.1 2004-10-22 06:24:40 skidder Exp $ + * $Id: ClumpletWriter.cpp,v 1.2 2004-10-23 01:21:11 skidder Exp $ * */ @@ -35,18 +35,37 @@ namespace Firebird { -ClumpletWriter(UCHAR tag, size_t limit) : - ClumpletReader(NULL, 0), sizeLimit(limit), dynamic_buffer(getPool(), 128) -{ - dynamic_buffer.add(tag); -} - -ClumpletWriter(const UCHAR* buffer, size_t buffLen, size_t limit) : - ClumpletReader(NULL, 0), sizeLimit(limit), dynamic_buffer(getPool(), buffer, buffLen) +ClumpletWriter::ClumpletWriter(size_t limit) : + ClumpletReader(NULL, 0), sizeLimit(limit), dynamic_buffer(getPool()) { } -virtual void ClumpletWriter::size_overflow() { + +ClumpletWriter::ClumpletWriter(UCHAR tag, size_t limit) : + ClumpletReader(NULL, 0), sizeLimit(limit), dynamic_buffer(getPool()) +{ + dynamic_buffer += static_cast(tag); +} + +ClumpletWriter::ClumpletWriter(const UCHAR* buffer, size_t buffLen, size_t limit) : + ClumpletReader(NULL, 0), sizeLimit(limit), + dynamic_buffer(getPool(), reinterpret_cast(buffer), buffLen) +{ +} + +void ClumpletWriter::reset(UCHAR tag) { + cur_offset = 1; + dynamic_buffer.resize(1); + dynamic_buffer[0] = static_cast(tag); +} + +void ClumpletWriter::reset(const UCHAR* buffer, size_t buffLen) { + cur_offset = 1; + dynamic_buffer.assign(reinterpret_cast(buffer), buffLen); +} + + +void ClumpletWriter::size_overflow() { fatal_exception::raise("Clumplet buffer size limit reached"); } @@ -60,7 +79,7 @@ void ClumpletWriter::insertInt(UCHAR tag, SLONG value) { bytes[3] = ptr[0]; insertBytes(tag, bytes, sizeof(bytes)); #else - insertBytes(tag, static_cast(&value), sizeof(value)); + insertBytes(tag, reinterpret_cast(&value), sizeof(value)); #endif } @@ -78,16 +97,16 @@ void ClumpletWriter::insertBigInt(UCHAR tag, SINT64 value) { bytes[7] = ptr[0]; insertBytes(tag, bytes, sizeof(bytes)); #else - insertBytes(tag, static_cast(&value), sizeof(value)); + insertBytes(tag, reinterpret_cast(&value), sizeof(value)); #endif } void ClumpletWriter::insertString(UCHAR tag, const string& str) { if (str.length() > 255) { size_overflow(); - insertBytes(str.c_str(), 255); + insertBytes(tag, reinterpret_cast(str.c_str()), 255); } else - insertBytes(str.c_str(), str.length()); + insertBytes(tag, reinterpret_cast(str.c_str()), str.length()); } void ClumpletWriter::insertBytes(UCHAR tag, const UCHAR* bytes, UCHAR len) { @@ -106,7 +125,7 @@ void ClumpletWriter::insertBytes(UCHAR tag, const UCHAR* bytes, UCHAR len) { // Insert the data dynamic_buffer.insert(cur_offset, static_cast(tag)); dynamic_buffer.insert(cur_offset + 1, static_cast(len)); - dynamic_buffer.insert(cur_offset + 2, static_cast(bytes)); + dynamic_buffer.insert(cur_offset + 2, reinterpret_cast(bytes)); cur_offset += len + 2; } @@ -119,11 +138,11 @@ void ClumpletWriter::insertEndMarker(UCHAR tag) { } // Check that resulting data doesn't overflow size limit - if (current_offset + 1 > sizeLimit) { + if (cur_offset + 1 > sizeLimit) { size_overflow(); } - dynamic_buffer.erase(cur_offset, npos); + dynamic_buffer.erase(cur_offset, string::npos); dynamic_buffer += static_cast(tag); cur_offset += 2; // Go past EOF to indicate we set the marker @@ -141,7 +160,7 @@ void ClumpletWriter::deleteClumplet() { if (buffer_end - clumplet < 2) { // It appears we're erasing EOF marker - dynamic_buffer.erase(cur_offset, npos); + dynamic_buffer.erase(cur_offset, string::npos); } else { size_t length = clumplet[1]; dynamic_buffer.erase(cur_offset, length + 2); diff --git a/src/common/classes/ClumpletWriter.h b/src/common/classes/ClumpletWriter.h index 6230a02eae..8a5532838c 100644 --- a/src/common/classes/ClumpletWriter.h +++ b/src/common/classes/ClumpletWriter.h @@ -24,12 +24,12 @@ * Contributor(s): ______________________________________. * * - * $Id: ClumpletWriter.h,v 1.1 2004-10-22 06:24:40 skidder Exp $ + * $Id: ClumpletWriter.h,v 1.2 2004-10-23 01:21:11 skidder Exp $ * */ -#ifndef CLUMPLET_BUFFER_H -#define CLUMPLET_BUFFER_H +#ifndef CLUMPLETWRITER_H +#define CLUMPLETWRITER_H #include "../common/classes/ClumpletReader.h" @@ -38,13 +38,17 @@ namespace Firebird { // At the moment you can only declare it on stack, permanent objects are not allowed class ClumpletWriter : public ClumpletReader { public: - // Create new clumplet buffer - ClumpletWriter(UCHAR tag, size_t limit) : - ClumpletReader(NULL, 0), sizeLimit(limit), dynamic_buffer(getPool()) { } + // Create empty clumplet writer (unusable before you call one of reset methods) + ClumpletWriter(size_t limit); + + // Create empty, initialized writer + ClumpletWriter(UCHAR tag, size_t limit); - // Open existing clumplet buffer (taking a copy of it) - ClumpletWriter(const UCHAR* buffer, size_t buffLen, size_t limit) : - ClumpletReader(NULL, 0), sizeLimit(limit), dynamic_buffer(getPool(), buffer, buffLen) { } + // Create writer from a given buffer + ClumpletWriter(const UCHAR* buffer, size_t buffLen, size_t limit); + + void reset(UCHAR tag); + void reset(const UCHAR* buffer, size_t buffLen); // Methods to create new clumplet at current position void insertInt(UCHAR tag, SLONG value); @@ -56,9 +60,13 @@ public: // Delete currently selected clumplet from buffer void deleteClumplet(); - virtual UCHAR* getBuffer() { return dynamic_buffer.begin(); } + virtual UCHAR* getBuffer() { + return reinterpret_cast(dynamic_buffer.begin()); + } protected: - virtual UCHAR* getBufferEnd() { return dynamic_buffer.end(); } + virtual UCHAR* getBufferEnd() { + return reinterpret_cast(dynamic_buffer.end()); + } virtual void size_overflow(); private: size_t sizeLimit;