Class Buffer

cpp/fory/util/buffer.h:45–1447

A buffer class for storing raw bytes with various methods for reading and writing the bytes.

// A buffer class for storing raw bytes with various methods for reading and
// writing the bytes.
class Buffer {
public:
  Buffer();

  Buffer(uint8_t *data, uint32_t size, bool own_data = true)
      : data_(data), size_(size), own_data_(own_data), wrapped_vector_(nullptr),
        input_stream_(nullptr), output_stream_(nullptr) {
    writer_index_ = 0;
    reader_index_ = 0;
  }

  /// Wrap an existing vector for zero-copy serialization.
  /// The buffer will append to the vector starting from its current size.
  /// After serialization, the vector is resized to writer_index().
  ///
  /// @param vec The vector to wrap (must outlive this Buffer).
  explicit Buffer(std::vector<uint8_t> &vec)
      : data_(vec.data()), size_(static_cast<uint32_t>(vec.size())),
        own_data_(false), writer_index_(static_cast<uint32_t>(vec.size())),
        reader_index_(0), wrapped_vector_(&vec), input_stream_(nullptr),
        output_stream_(nullptr) {}

  explicit Buffer(InputStream &input_stream)
      : data_(nullptr), size_(0), own_data_(false), writer_index_(0),
        reader_index_(0), wrapped_vector_(nullptr),
        input_stream_(&input_stream), output_stream_(nullptr) {
    input_stream_->bind_buffer(this);
    input_stream_owner_ = input_stream_->weak_from_this().lock();
    FORY_CHECK(&input_stream_->get_buffer() == this)
        << "InputStream must hold and return the same Buffer instance";
  }

  Buffer(Buffer &&buffer) noexcept;

  Buffer &operator=(Buffer &&buffer) noexcept;

  virtual ~Buffer();

  FORY_ALWAYS_INLINE void swap(Buffer &other) noexcept {
    if (this == &other) {
      return;
    }
    FORY_CHECK(output_stream_ == nullptr && other.output_stream_ == nullptr)
        << "Cannot swap stream-writer-owned Buffer";
    using std::swap;
    swap(data_, other.data_);
    swap(size_, other.size_);
    swap(own_data_, other.own_data_);
    swap(writer_index_, other.writer_index_);
    swap(reader_index_, other.reader_index_);
    swap(wrapped_vector_, other.wrapped_vector_);
    swap(input_stream_, other.input_stream_);
    swap(input_stream_owner_, other.input_stream_owner_);
    swap(output_stream_, other.output_stream_);
    rebind_input_stream_to_this();
    other.rebind_input_stream_to_this();
  }