CommBuf.h

Go to the documentation of this file.

/* -*- c++ -*-
 * Copyright (C) 2007-2015 Hypertable, Inc.
 *
 * This file is part of Hypertable.
 *
 * Hypertable is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or any later version.
 *
 * Hypertable is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#ifndef AsyncComm_CommBuf_h
#define AsyncComm_CommBuf_h

#include "CommHeader.h"

#include <Common/ByteString.h>
#include <Common/InetAddr.h>
#include <Common/Logger.h>
#include <Common/Serialization.h>
#include <Common/StaticBuffer.h>

#include <boost/shared_array.hpp>

#include <memory>
#include <string>

namespace Hypertable {

  class CommBuf {
  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 || data_ptr == data.base);
      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 std::shared_ptr<CommBuf> CommBufPtr;
} // namespace Hypertable


#endif // AsyncComm_CommBuf_h