Class WriteBuffer

include/sonic/writebuffer.h:25–158

namespace sonic_json {

class WriteBuffer {
 public:
  WriteBuffer() : stack_() {}
  WriteBuffer(size_t cap) : stack_(cap) {}
  WriteBuffer(const WriteBuffer&) = delete;
  WriteBuffer(WriteBuffer&& rhs) : stack_(std::move(rhs.stack_)) {}
  ~WriteBuffer() = default;
  WriteBuffer& operator=(const WriteBuffer&) = delete;
  WriteBuffer& operator=(WriteBuffer&& rhs) {
    stack_ = std::move(rhs.stack_);
    return *this;
  }

  /**
   * @brief Return the context in the buffer.
   * @return a null-terminate string.
   * @note a '\0' will be added in the ending, so, this function is not
   * thread-safe.
   */
  sonic_force_inline const char* ToString() const {
    stack_.Grow(1);
    *(stack_.template End<char>()) = '\0';
    return stack_.Begin<char>();
  }

  sonic_force_inline size_t Size() const { return stack_.Size(); }
  sonic_force_inline size_t Capacity() const { return stack_.Capacity(); }
  sonic_force_inline bool Empty() const { return stack_.Empty(); }

  /**
   * @brief Increase the capacity of buffer if new_cap is greater than the
   * current capacity(). Otherwise, do nothing.
   */
  sonic_force_inline void Reserve(size_t new_cap) { stack_.Reserve(new_cap); }

  /**
   * @brief Erases all contexts in the buffer.
   */
  sonic_force_inline void Clear() { stack_.Clear(); }

  /**
   * @brief Push a value into buffer
   * @param v the pushed value, as char, int...
   */
  template <typename T>
  sonic_force_inline void Push(T v) {
    stack_.template Push<T>(v);
  }

  /**
   * @brief Push a string into the buffer.
   * @param s the beginning of string
   * @param n the string size
   */
  sonic_force_inline void Push(const char* s, size_t n) { stack_.Push(s, n); }
  sonic_force_inline void PushUnsafe(const char* s, size_t n) {
    stack_.PushUnsafe(s, n);
  }