Split ByteBuffer into writer/reader objects.
This allows the reader to reference data, thus avoiding unnecessary
allocations and memory copies.
BUG=webrtc:5155,webrtc:5670
Review URL: https://codereview.webrtc.org/1821083002
Cr-Commit-Position: refs/heads/master@{#12160}
diff --git a/webrtc/base/bytebuffer.h b/webrtc/base/bytebuffer.h
index ad2e552..8fd0863 100644
--- a/webrtc/base/bytebuffer.h
+++ b/webrtc/base/bytebuffer.h
@@ -21,29 +21,87 @@
class ByteBuffer {
public:
-
enum ByteOrder {
ORDER_NETWORK = 0, // Default, use network byte order (big endian).
ORDER_HOST, // Use the native order of the host.
};
+ explicit ByteBuffer(ByteOrder byte_order) : byte_order_(byte_order) {}
+
+ ByteOrder Order() const { return byte_order_; }
+
+ private:
+ ByteOrder byte_order_;
+
+ RTC_DISALLOW_COPY_AND_ASSIGN(ByteBuffer);
+};
+
+class ByteBufferWriter : public ByteBuffer {
+ public:
// |byte_order| defines order of bytes in the buffer.
- ByteBuffer();
- explicit ByteBuffer(ByteOrder byte_order);
- ByteBuffer(const char* bytes, size_t len);
- ByteBuffer(const char* bytes, size_t len, ByteOrder byte_order);
+ ByteBufferWriter();
+ explicit ByteBufferWriter(ByteOrder byte_order);
+ ByteBufferWriter(const char* bytes, size_t len);
+ ByteBufferWriter(const char* bytes, size_t len, ByteOrder byte_order);
- // Initializes buffer from a zero-terminated string.
- explicit ByteBuffer(const char* bytes);
-
- explicit ByteBuffer(const Buffer& buf);
-
- ~ByteBuffer();
+ ~ByteBufferWriter();
const char* Data() const { return bytes_ + start_; }
size_t Length() const { return end_ - start_; }
size_t Capacity() const { return size_ - start_; }
- ByteOrder Order() const { return byte_order_; }
+
+ // Write value to the buffer. Resizes the buffer when it is
+ // neccessary.
+ void WriteUInt8(uint8_t val);
+ void WriteUInt16(uint16_t val);
+ void WriteUInt24(uint32_t val);
+ void WriteUInt32(uint32_t val);
+ void WriteUInt64(uint64_t val);
+ void WriteString(const std::string& val);
+ void WriteBytes(const char* val, size_t len);
+
+ // Reserves the given number of bytes and returns a char* that can be written
+ // into. Useful for functions that require a char* buffer and not a
+ // ByteBufferWriter.
+ char* ReserveWriteBuffer(size_t len);
+
+ // Resize the buffer to the specified |size|.
+ void Resize(size_t size);
+
+ // Clears the contents of the buffer. After this, Length() will be 0.
+ void Clear();
+
+ private:
+ void Construct(const char* bytes, size_t size);
+
+ char* bytes_;
+ size_t size_;
+ size_t start_;
+ size_t end_;
+
+ // There are sensible ways to define these, but they aren't needed in our code
+ // base.
+ RTC_DISALLOW_COPY_AND_ASSIGN(ByteBufferWriter);
+};
+
+// The ByteBufferReader references the passed data, i.e. the pointer must be
+// valid during the lifetime of the reader.
+class ByteBufferReader : public ByteBuffer {
+ public:
+ ByteBufferReader(const char* bytes, size_t len);
+ ByteBufferReader(const char* bytes, size_t len, ByteOrder byte_order);
+
+ // Initializes buffer from a zero-terminated string.
+ explicit ByteBufferReader(const char* bytes);
+
+ explicit ByteBufferReader(const Buffer& buf);
+
+ explicit ByteBufferReader(const ByteBufferWriter& buf);
+
+ // Returns start of unprocessed data.
+ const char* Data() const { return bytes_ + start_; }
+ // Returns number of unprocessed bytes.
+ size_t Length() const { return end_ - start_; }
// Read a next value from the buffer. Return false if there isn't
// enough data left for the specified type.
@@ -58,63 +116,21 @@
// if there is less than |len| bytes left.
bool ReadString(std::string* val, size_t len);
- // Write value to the buffer. Resizes the buffer when it is
- // neccessary.
- void WriteUInt8(uint8_t val);
- void WriteUInt16(uint16_t val);
- void WriteUInt24(uint32_t val);
- void WriteUInt32(uint32_t val);
- void WriteUInt64(uint64_t val);
- void WriteString(const std::string& val);
- void WriteBytes(const char* val, size_t len);
-
- // Reserves the given number of bytes and returns a char* that can be written
- // into. Useful for functions that require a char* buffer and not a
- // ByteBuffer.
- char* ReserveWriteBuffer(size_t len);
-
- // Resize the buffer to the specified |size|. This invalidates any remembered
- // seek positions.
- void Resize(size_t size);
-
// Moves current position |size| bytes forward. Returns false if
// there is less than |size| bytes left in the buffer. Consume doesn't
// permanently remove data, so remembered read positions are still valid
// after this call.
bool Consume(size_t size);
- // Clears the contents of the buffer. After this, Length() will be 0.
- void Clear();
-
- // Used with GetReadPosition/SetReadPosition.
- class ReadPosition {
- friend class ByteBuffer;
- ReadPosition(size_t start, int version)
- : start_(start), version_(version) { }
- size_t start_;
- int version_;
- };
-
- // Remembers the current read position for a future SetReadPosition. Any
- // calls to Shift or Resize in the interim will invalidate the position.
- ReadPosition GetReadPosition() const;
-
- // If the given position is still valid, restores that read position.
- bool SetReadPosition(const ReadPosition &position);
-
private:
- void Construct(const char* bytes, size_t size, ByteOrder byte_order);
+ void Construct(const char* bytes, size_t size);
- char* bytes_;
+ const char* bytes_;
size_t size_;
size_t start_;
size_t end_;
- int version_;
- ByteOrder byte_order_;
- // There are sensible ways to define these, but they aren't needed in our code
- // base.
- RTC_DISALLOW_COPY_AND_ASSIGN(ByteBuffer);
+ RTC_DISALLOW_COPY_AND_ASSIGN(ByteBufferReader);
};
} // namespace rtc