CommBuf.h

Go to the documentation of this file.

#ifndef HYPERTABLE_COMMBUF_H
#define HYPERTABLE_COMMBUF_H

#include <string>

#include <boost/shared_array.hpp>

#include "Common/ByteString.h"
#include "Common/InetAddr.h"
#include "Common/Logger.h"
#include "Common/ReferenceCount.h"
#include "Common/Serialization.h"
#include "Common/StaticBuffer.h"

#include "CommHeader.h"

namespace Hypertable {

  class CommBuf : public ReferenceCount {
  public:

    CommBuf(CommHeader &hdr, uint32_t len=0) : header(hdr), ext_ptr(0) {
      len += header.encoded_length();
      data.set(new uint8_t [len], len, true);
      data_ptr = data.base + header.encoded_length();
      header.set_total_length(len);
    }

    CommBuf(CommHeader &hdr, uint32_t len, StaticBuffer &buffer)
      : ext(buffer), header(hdr) {
      len += header.encoded_length();
      data.set(new uint8_t [len], len, true);
      data_ptr = data.base + header.encoded_length();
      header.set_total_length(len+buffer.size);
      ext_ptr = ext.base;
    }


    CommBuf(CommHeader &hdr, uint32_t len,
            boost::shared_array<uint8_t> &ext_buffer, uint32_t ext_len) :
      header(hdr), ext_shared_array(ext_buffer) {
      len += header.encoded_length();
      data.set(new uint8_t [len], len, true);
      data_ptr = data.base + header.encoded_length();
      ext.base = ext_shared_array.get();
      ext.size = ext_len;
      ext.own = false;
      header.set_total_length(len+ext_len);
      ext_ptr = ext.base;
    }

    void write_header_and_reset() {
      uint8_t *buf = data.base;
      HT_ASSERT((data_ptr - data.base) == (int)data.size);
      header.encode(&buf);
      data_ptr = data.base;
      ext_ptr = ext.base;
    }

    void *get_data_ptr() { return data_ptr; }

    uint8_t **get_data_ptr_address() { return &data_ptr; }

    void *advance_data_ptr(size_t len) { data_ptr += len; return data_ptr; }

    void append_bool(bool bval) { Serialization::encode_bool(&data_ptr, bval); }

    void append_byte(uint8_t bval) { *data_ptr++ = bval; }

    void append_bytes(const uint8_t *bytes, uint32_t len) {
      memcpy(data_ptr, bytes, len);
      data_ptr += len;
    }

    void append_str16(const char *str) {
      Serialization::encode_str16(&data_ptr, str);
    }

    void append_str16(const String &str) {
      Serialization::encode_str16(&data_ptr, str);
    }

    void append_i16(uint16_t sval) {
      Serialization::encode_i16(&data_ptr, sval);
    }

    void append_i32(uint32_t ival) {
      Serialization::encode_i32(&data_ptr, ival);
    }

    void append_i64(uint64_t lval) {
      Serialization::encode_i64(&data_ptr, lval);
    }

    void append_vstr(const char *str) {
      Serialization::encode_vstr(&data_ptr, str);
    }

    void append_vstr(const String &str) {
      Serialization::encode_vstr(&data_ptr, str);
    }

    void append_vstr(const void *str, uint32_t len) {
      Serialization::encode_vstr(&data_ptr, str, len);
    }

    void append_inet_addr(const InetAddr &addr) {
      Serialization::encode_inet_addr(&data_ptr, addr);
    }

    friend class IOHandlerData;
    friend class IOHandlerDatagram;

    StaticBuffer data;
    StaticBuffer ext;
    CommHeader header;

  protected:
    uint8_t *data_ptr;
    const uint8_t *ext_ptr;
    boost::shared_array<uint8_t> ext_shared_array;
  };

  typedef intrusive_ptr<CommBuf> CommBufPtr;

} // namespace Hypertable


#endif // HYPERTABLE_COMMBUF_H