#pragma once

#ifndef GEODE_GFCPP_DATAOUTPUT_H_
#define GEODE_GFCPP_DATAOUTPUT_H_

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "gfcpp_globals.hpp"
#include "ExceptionTypes.hpp"
#include "Log.hpp"
#include "Serializable.hpp"
#include "CacheableString.hpp"

extern "C" {
#include <string.h>
#include <stdlib.h>
}

/**
 * @file
 */

namespace apache {
namespace geode {
namespace client {

/**
 * C style memory allocation that throws OutOfMemoryException
 * if it fails
 */
#define GF_ALLOC(v, t, s)                                                  \
  {                                                                        \
    v = (t*)malloc((s) * sizeof(t));                                       \
    if ((v) == NULL) {                                                     \
      throw OutOfMemoryException(                                          \
          "Out of Memory while allocating buffer for " #t " of size " #s); \
    }                                                                      \
  }

/**
 * C style memory re-allocation that throws OutOfMemoryException
 * if it fails
 */
#define GF_RESIZE(v, t, s)                                \
  {                                                       \
    v = (t*)realloc(v, (s) * sizeof(t));                  \
    if ((v) == NULL) {                                    \
      throw OutOfMemoryException(                         \
          "Out of Memory while resizing buffer for " #t); \
    }                                                     \
  }

#define GF_FREE(v) free(v)

/**
 * Provide operations for writing primitive data values, byte arrays,
 * strings, <code>Serializable</code> objects to a byte stream.
 * This class is intentionally not thread safe.
 */
class CPPCACHE_EXPORT DataOutput {
 public:
  /**
   * Construct a new DataOutput.
   */
  DataOutput();

  /**
   * Write an unsigned byte to the <code>DataOutput</code>.
   *
   * @param value the unsigned byte to be written
   */
  inline void write(uint8_t value) {
    ensureCapacity(1);
    writeNoCheck(value);
  }

  /**
   * Write a signed byte to the <code>DataOutput</code>.
   *
   * @param value the signed byte to be written
   */
  inline void write(int8_t value) { write(static_cast<uint8_t>(value)); }

  /**
   * Write a boolean value to the <code>DataOutput</code>.
   *
   * @param value the boolean value to be written
   */
  inline void writeBoolean(bool value) { write(static_cast<uint8_t>(value)); }

  /**
   * Write an array of unsigned bytes to the <code>DataOutput</code>.
   *
   * @param value the array of unsigned bytes to be written
   * @param len the number of bytes from the start of array to be written
   */
  inline void writeBytes(const uint8_t* bytes, int32_t len) {
    if (len >= 0) {
      ensureCapacity(len + 5);
      writeArrayLen(bytes == NULL ? 0 : len);  // length of bytes...
      if (len > 0 && bytes != NULL) {
        memcpy(m_buf, bytes, len);
        m_buf += len;
      }
    } else {
      write(static_cast<int8_t>(-1));
    }
  }

  /**
   * Write an array of signed bytes to the <code>DataOutput</code>.
   *
   * @param value the array of signed bytes to be written
   * @param len the number of bytes from the start of array to be written
   */
  inline void writeBytes(const int8_t* bytes, int32_t len) {
    writeBytes(reinterpret_cast<const uint8_t*>(bytes), len);
  }

  /**
   * Write an array of unsigned bytes without its length to the
   * <code>DataOutput</code>.
   * @remarks The difference between this and <code>writeBytes</code> is that
   *   this does write the length of bytes so the corresponding
   *   <code>DataInput::readBytesOnly</code> (unlike
   *   <code>DataInput::readBytes</code>) needs the length argument explicitly.
   *
   * @param value the array of unsigned bytes to be written
   * @param len the number of bytes from the start of array to be written
   */
  inline void writeBytesOnly(const uint8_t* bytes, uint32_t len) {
    ensureCapacity(len);
    memcpy(m_buf, bytes, len);
    m_buf += len;
  }

  /**
   * Write an array of signed bytes without its length to the
   * <code>DataOutput</code>.
   * @remarks The difference between this and <code>writeBytes</code> is that
   *   this does write the length of bytes so the corresponding
   *   <code>DataInput::readBytesOnly</code> (unlike
   *   <code>DataInput::readBytes</code>) needs the length argument explicitly.
   *
   * @param value the array of signed bytes to be written
   * @param len the number of bytes from the start of array to be written
   */
  inline void writeBytesOnly(const int8_t* bytes, uint32_t len) {
    writeBytesOnly(reinterpret_cast<const uint8_t*>(bytes), len);
  }

  /**
   * Write a 16-bit unsigned integer value to the <code>DataOutput</code>.
   *
   * @param value the 16-bit unsigned integer value to be written
   */
  inline void writeInt(uint16_t value) {
    ensureCapacity(2);
    *(m_buf++) = static_cast<uint8_t>(value >> 8);
    *(m_buf++) = static_cast<uint8_t>(value);
  }

  /**
   * Write a 16-bit Char (wchar_t) value to the <code>DataOutput</code>.
   *
   * @param value the 16-bit wchar_t value to be written
   */
  inline void writeChar(uint16_t value) {
    ensureCapacity(2);
    *(m_buf++) = static_cast<uint8_t>(value >> 8);
    *(m_buf++) = static_cast<uint8_t>(value);
  }

  /**
   * Write a 32-bit unsigned integer value to the <code>DataOutput</code>.
   *
   * @param value the 32-bit unsigned integer value to be written
   */
  inline void writeInt(uint32_t value) {
    ensureCapacity(4);
    *(m_buf++) = static_cast<uint8_t>(value >> 24);
    *(m_buf++) = static_cast<uint8_t>(value >> 16);
    *(m_buf++) = static_cast<uint8_t>(value >> 8);
    *(m_buf++) = static_cast<uint8_t>(value);
  }

  /**
   * Write a 64-bit unsigned integer value to the <code>DataOutput</code>.
   *
   * @param value the 64-bit unsigned integer value to be written
   */
  inline void writeInt(uint64_t value) {
    ensureCapacity(8);
    // the defines are not reliable and can be changed by compiler options.
    // Hence using sizeof() test instead.
    //#if defined(_LP64) || ( defined(__WORDSIZE) && __WORDSIZE == 64 ) ||
    //( defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 64 )
    if (sizeof(long) == 8) {
      *(m_buf++) = static_cast<uint8_t>(value >> 56);
      *(m_buf++) = static_cast<uint8_t>(value >> 48);
      *(m_buf++) = static_cast<uint8_t>(value >> 40);
      *(m_buf++) = static_cast<uint8_t>(value >> 32);
      *(m_buf++) = static_cast<uint8_t>(value >> 24);
      *(m_buf++) = static_cast<uint8_t>(value >> 16);
      *(m_buf++) = static_cast<uint8_t>(value >> 8);
      *(m_buf++) = static_cast<uint8_t>(value);
    } else {
      uint32_t hword = static_cast<uint32_t>(value >> 32);
      *(m_buf++) = static_cast<uint8_t>(hword >> 24);
      *(m_buf++) = static_cast<uint8_t>(hword >> 16);
      *(m_buf++) = static_cast<uint8_t>(hword >> 8);
      *(m_buf++) = static_cast<uint8_t>(hword);

      hword = static_cast<uint32_t>(value);
      *(m_buf++) = static_cast<uint8_t>(hword >> 24);
      *(m_buf++) = static_cast<uint8_t>(hword >> 16);
      *(m_buf++) = static_cast<uint8_t>(hword >> 8);
      *(m_buf++) = static_cast<uint8_t>(hword);
    }
  }

  /**
   * Write a 16-bit signed integer value to the <code>DataOutput</code>.
   *
   * @param value the 16-bit signed integer value to be written
   */
  inline void writeInt(int16_t value) {
    writeInt(static_cast<uint16_t>(value));
  }

  /**
   * Write a 32-bit signed integer value to the <code>DataOutput</code>.
   *
   * @param value the 32-bit signed integer value to be written
   */
  inline void writeInt(int32_t value) {
    writeInt(static_cast<uint32_t>(value));
  }

  /**
   * Write a 64-bit signed integer value to the <code>DataOutput</code>.
   *
   * @param value the 64-bit signed integer value to be written
   */
  inline void writeInt(int64_t value) {
    writeInt(static_cast<uint64_t>(value));
  }

  /**
   * Write a 32-bit signed integer array length value to the
   * <code>DataOutput</code> in a manner compatible with java server's
   * <code>DataSerializer.writeArrayLength</code>.
   *
   * @param value the 32-bit signed integer array length to be written
   */
  inline void writeArrayLen(int32_t len) {
    if (len == -1) {
      write(static_cast<int8_t>(-1));
    } else if (len <= 252) {  // 252 is java's ((byte)-4 && 0xFF)
      write(static_cast<uint8_t>(len));
    } else if (len <= 0xFFFF) {
      write(static_cast<int8_t>(-2));
      writeInt(static_cast<uint16_t>(len));
    } else {
      write(static_cast<int8_t>(-3));
      writeInt(len);
    }
  }

  /**
   * Write a float value to the <code>DataOutput</code>.
   *
   * @param value the float value to be written
   */
  inline void writeFloat(float value) {
    union float_uint32_t {
      float f;
      uint32_t u;
    } v;
    v.f = value;
    writeInt(v.u);
  }

  /**
   * Write a double precision real number to the <code>DataOutput</code>.
   *
   * @param value the double precision real number to be written
   */
  inline void writeDouble(double value) {
    union double_uint64_t {
      double d;
      uint64_t ll;
    } v;
    v.d = value;
    writeInt(v.ll);
  }

  /**
   * Writes the given ASCII string supporting maximum length of 64K
   * (i.e. unsigned 16-bit integer).
   * @remarks The string will be truncated if greater than the maximum
   *   permissible length of 64K. Use <code>writeBytes</code> or
   *   <code>writeASCIIHuge</code> to write ASCII strings of length larger
   *   than this.
   *
   * @param value the C string to be written
   * @param length the number of characters from start of string to be
   *   written; the default value of 0 implies the complete string
   */
  inline void writeASCII(const char* value, uint32_t length = 0) {
    if (value != NULL) {
      if (length == 0) {
        length = static_cast<uint32_t>(strlen(value));
      }
      uint16_t len = static_cast<uint16_t>(length > 0xFFFF ? 0xFFFF : length);
      writeInt(len);
      writeBytesOnly((int8_t*)value, len);  // K64
    } else {
      writeInt(static_cast<uint16_t>(0));
    }
  }

  inline void writeNativeString(const char* value) {
    // create cacheable string
    // write typeid id.
    // call todata
    CacheableStringPtr csPtr = CacheableString::create(value);
    write(csPtr->typeId());
    csPtr->toData(*this);
  }

  /**
   * Writes the given ASCII string supporting upto maximum 32-bit
   * integer value.
   * @remarks Use this to write large ASCII strings. The other
   *   <code>writeASCII</code> method will truncate strings greater than
   *   64K in size.
   *
   * @param value the wide-character string to be written
   * @param length the number of characters from start of string to be
   *   written; the default value of 0 implies the complete string
   */
  inline void writeASCIIHuge(const char* value, uint32_t length = 0) {
    if (value != NULL) {
      if (length == 0) {
        length = static_cast<uint32_t>(strlen(value));
      }
      writeInt(length);
      writeBytesOnly((int8_t*)value, length);
    } else {
      writeInt(static_cast<uint32_t>(0));
    }
  }

  /**
     * Writes the given given string using java modified UTF-8 encoding
     * supporting maximum encoded length of 64K (i.e. unsigned 16-bit integer).
     * @remarks The string will be truncated if greater than the maximum
     *   permissible length of 64K. Use <code>writeUTFHuge</code> to write
     *   strings of length larger than this.
     *
     * @param value the C string to be written
     *
     */
  inline void writeFullUTF(const char* value, uint32_t length = 0) {
    if (value != NULL) {
      int32_t len = getEncodedLength(value, length);
      uint16_t encodedLen = static_cast<uint16_t>(len > 0xFFFF ? 0xFFFF : len);
      writeInt(static_cast<int32_t>(encodedLen));
      ensureCapacity(encodedLen);
      write(static_cast<int8_t>(0));  // isObject = 0 BYTE_CODE
      uint8_t* end = m_buf + encodedLen;
      while (m_buf < end) {
        encodeChar(*value++);
      }
      if (m_buf > end) m_buf = end;
    } else {
      writeInt(static_cast<uint16_t>(0));
    }
  }

  /**
   * Writes the given given string using java modified UTF-8 encoding
   * supporting maximum encoded length of 64K (i.e. unsigned 16-bit integer).
   * @remarks The string will be truncated if greater than the maximum
   *   permissible length of 64K. Use <code>writeUTFHuge</code> to write
   *   strings of length larger than this.
   *
   * @param value the C string to be written
   * @param length the number of characters from start of string to be
   *   written; the default value of 0 implies the complete string
   */
  inline void writeUTF(const char* value, uint32_t length = 0) {
    if (value != NULL) {
      int32_t len = getEncodedLength(value, length);
      uint16_t encodedLen = static_cast<uint16_t>(len > 0xFFFF ? 0xFFFF : len);
      writeInt(encodedLen);
      ensureCapacity(encodedLen);
      uint8_t* end = m_buf + encodedLen;
      while (m_buf < end) {
        encodeChar(*value++);
      }
      if (m_buf > end) m_buf = end;
    } else {
      writeInt(static_cast<uint16_t>(0));
    }
  }

  /**
   * Writes the given string using java modified UTF-8 encoding.
   * @remarks Use this to write large strings. The other
   *   <code>writeUTF</code> method will truncate strings greater than
   *   64K in size.
   *
   * @param value the C string to be written
   * @param length the number of characters from start of string to be
   *   written; the default value of 0 implies the complete string
   *   assuming a null terminated string; do not use this unless sure
   *   that the UTF string does not contain any null characters
   */
  inline void writeUTFHuge(const char* value, uint32_t length = 0) {
    if (value != NULL) {
      if (length == 0) {
        length = static_cast<uint32_t>(strlen(value));
      }
      writeInt(length);
      ensureCapacity(length * 2);
      for (uint32_t pos = 0; pos < length; pos++) {
        writeNoCheck(static_cast<int8_t>(0));
        writeNoCheck(static_cast<int8_t>(value[pos]));
      }
    } else {
      writeInt(static_cast<uint32_t>(0));
    }
  }

  /**
   * Writes the given given string using java modified UTF-8 encoding
   * supporting maximum encoded length of 64K (i.e. unsigned 16-bit integer).
   * @remarks The string will be truncated if greater than the maximum
   *   permissible length of 64K. Use <code>writeUTFHuge</code> to write
   *   strings of length larger than this.
   *
   * @param value the wide-character string to be written
   * @param length the number of characters from start of string to be
   *   written; the default value of 0 implies the complete string
   */
  inline void writeUTF(const wchar_t* value, uint32_t length = 0) {
    if (value != NULL) {
      int32_t len = getEncodedLength(value, length);
      uint16_t encodedLen = static_cast<uint16_t>(len > 0xFFFF ? 0xFFFF : len);
      writeInt(encodedLen);
      ensureCapacity(encodedLen);
      uint8_t* end = m_buf + encodedLen;
      while (m_buf < end) {
        encodeChar(*value++);
      }
      if (m_buf > end) m_buf = end;
    } else {
      writeInt(static_cast<uint16_t>(0));
    }
  }

  /**
   * Writes the given string using java modified UTF-8 encoding.
   * @remarks Use this to write large strings. The other
   *   <code>writeUTF</code> method will truncate strings greater than
   *   64K in size.
   *
   * @param value the wide-character string to be written
   * @param length the number of characters from start of string to be
   *   written; the default value of 0 implies the complete string
   */
  inline void writeUTFHuge(const wchar_t* value, uint32_t length = 0) {
    if (value != NULL) {
      if (length == 0) {
        length = static_cast<uint32_t>(wcslen(value));
      }
      writeInt(length);
      ensureCapacity(length * 2);
      for (uint32_t pos = 0; pos < length; pos++) {
        uint16_t item = static_cast<uint16_t>(value[pos]);
        writeNoCheck(static_cast<uint8_t>((item & 0xFF00) >> 8));
        writeNoCheck(static_cast<uint8_t>(item & 0xFF));
      }
    } else {
      writeInt(static_cast<uint32_t>(0));
    }
  }

  /**
   * Get the length required to represent a given wide-character string in
   * java modified UTF-8 format.
   *
   * @param value The C string.
   * @param length The length of the string; or zero to use the full string.
   * @return The length required for representation in java modified
   *         UTF-8 format.
   * @see DataInput::getDecodedLength
   */
  inline static int32_t getEncodedLength(const char* value, int32_t length = 0,
                                         uint32_t* valLength = NULL) {
    if (value == NULL) return 0;
    char currentChar;
    int32_t encodedLen = 0;
    const char* start = value;
    if (length == 0) {
      while ((currentChar = *value) != '\0') {
        getEncodedLength(currentChar, encodedLen);
        value++;
      }
    } else {
      const char* end = value + length;
      while (value < end) {
        currentChar = *value;
        getEncodedLength(currentChar, encodedLen);
        value++;
      }
    }
    if (valLength != NULL) {
      *valLength = static_cast<uint32_t>(value - start);
    }
    return encodedLen;
  }

  /**
   * Get the length required to represent a given wide-character string in
   * java modified UTF-8 format.
   *
   * @param value The wide-character string.
   * @param length The length of the string.
   * @return The length required for representation in java modified
   *         UTF-8 format.
   * @see DataInput::getDecodedLength
   */
  inline static int32_t getEncodedLength(const wchar_t* value,
                                         int32_t length = 0,
                                         uint32_t* valLength = NULL) {
    if (value == NULL) return 0;
    wchar_t currentChar;
    int32_t encodedLen = 0;
    const wchar_t* start = value;
    if (length == 0) {
      while ((currentChar = *value) != 0) {
        getEncodedLength(currentChar, encodedLen);
        value++;
      }
    } else {
      const wchar_t* end = value + length;
      while (value < end) {
        currentChar = *value;
        getEncodedLength(currentChar, encodedLen);
        value++;
      }
    }
    if (valLength != NULL) {
      *valLength = static_cast<uint32_t>(value - start);
    }
    return encodedLen;
  }

  /**
   * Write a <code>Serializable</code> object to the <code>DataOutput</code>.
   *
   * @param objptr smart pointer to the <code>Serializable</code> object
   *   to be written
   */
  template <class PTR>
  void writeObject(const SharedPtr<PTR>& objptr, bool isDelta = false) {
    writeObjectInternal(objptr.ptr(), isDelta);
  }

  /**
   * Write a <code>Serializable</code> object to the <code>DataOutput</code>.
   *
   * @param objptr pointer to the <code>Serializable</code> object
   *   to be written
   */
  void writeObject(const Serializable* objptr) { writeObjectInternal(objptr); }

  /**
   * Get an internal pointer to the current location in the
   * <code>DataOutput</code> byte array.
   */
  const uint8_t* getCursor() { return m_buf; }

  /**
   * Advance the buffer cursor by the given offset.
   *
   * @param offset the offset by which to advance the cursor
   */
  void advanceCursor(uint32_t offset) {
    ensureCapacity(offset);
    m_buf += offset;
  }

  /**
   * Rewind the buffer cursor by the given offset.
   *
   * @param offset the offset by which to rewind the cursor
   */
  void rewindCursor(uint32_t offset) { m_buf -= offset; }

  void updateValueAtPos(uint32_t offset, uint8_t value) {
    m_bytes[offset] = value;
  }

  uint8_t getValueAtPos(uint32_t offset) { return m_bytes[offset]; }
  /** Destruct a DataOutput, including releasing the created buffer. */
  ~DataOutput() {
    reset();
    DataOutput::checkinBuffer(m_bytes, m_size);
  }

  /**
   * Get a pointer to the internal buffer of <code>DataOutput</code>.
   */
  inline const uint8_t* getBuffer() const {
    // GF_R_ASSERT(!((uint32_t)(m_bytes) % 4));
    return m_bytes;
  }

  /**
   * Get a pointer to the internal buffer of <code>DataOutput</code>.
   */
  inline uint32_t getRemainingBufferLength() const {
    // GF_R_ASSERT(!((uint32_t)(m_bytes) % 4));
    return m_size - getBufferLength();
  }

  /**
   * Get a pointer to the internal buffer of <code>DataOutput</code>.
   *
   * @param rsize the size of buffer is filled in this output parameter;
   *   should not be NULL
   */
  inline const uint8_t* getBuffer(uint32_t* rsize) const {
    *rsize = static_cast<uint32_t>(m_buf - m_bytes);
    // GF_R_ASSERT(!((uint32_t)(m_bytes) % 4));
    return m_bytes;
  }

  inline uint8_t* getBufferCopy() {
    uint32_t size = static_cast<uint32_t>(m_buf - m_bytes);
    uint8_t* result;
    GF_ALLOC(result, uint8_t, size);
    memcpy(result, m_bytes, size);
    return result;
  }

  /**
   * Get the length of current data in the internal buffer of
   * <code>DataOutput</code>.
   */
  inline uint32_t getBufferLength() const {
    return static_cast<uint32_t>(m_buf - m_bytes);
  }

  /**
   * Reset the internal cursor to the start of the buffer.
   */
  inline void reset() {
    if (m_haveBigBuffer) {
      // free existing buffer
      GF_FREE(m_bytes);
      // create smaller buffer
      GF_ALLOC(m_bytes, uint8_t, m_lowWaterMark);
      m_size = m_lowWaterMark;
      // reset the flag
      m_haveBigBuffer = false;
      // release the lock
      releaseLock();
    }
    m_buf = m_bytes;
  }

  // make sure there is room left for the requested size item.
  inline void ensureCapacity(uint32_t size) {
    uint32_t offset = static_cast<uint32_t>(m_buf - m_bytes);
    if ((m_size - offset) < size) {
      uint32_t newSize = m_size * 2 + (8192 * (size / 8192));
      if (newSize >= m_highWaterMark && !m_haveBigBuffer) {
        // acquire the lock
        acquireLock();
        // set flag
        m_haveBigBuffer = true;
      }
      m_size = newSize;
      GF_RESIZE(m_bytes, uint8_t, m_size);
      m_buf = m_bytes + offset;
    }
  }

  /*
  * This is for internal use
  */
  const char* getPoolName() { return m_poolName; }

  /*
   * This is for internal use
   */
  void setPoolName(const char* poolName) { m_poolName = poolName; }

  uint8_t* getBufferCopyFrom(const uint8_t* from, uint32_t length) {
    uint8_t* result;
    GF_NEW(result, uint8_t[length]);
    memcpy(result, from, length);

    return result;
  }

  static void safeDelete(uint8_t* src) { GF_SAFE_DELETE(src); }

  static DataOutput* getDataOutput() { return new DataOutput(); }
  static void releaseDataOutput(DataOutput* dataOutput) {
    GF_SAFE_DELETE(dataOutput);
  }

 private:
  void writeObjectInternal(const Serializable* ptr, bool isDelta = false);

  static void acquireLock();
  static void releaseLock();

  const char* m_poolName;
  // memory m_buffer to encode to.
  uint8_t* m_bytes;
  // cursor.
  uint8_t* m_buf;
  // size of m_bytes.
  uint32_t m_size;
  // high and low water marks for buffer size
  static uint32_t m_lowWaterMark;
  static uint32_t m_highWaterMark;
  // flag to indicate we have a big buffer
  volatile bool m_haveBigBuffer;

  inline static void getEncodedLength(const char val, int32_t& encodedLen) {
    if ((val == 0) || (val & 0x80)) {
      // two byte.
      encodedLen += 2;
    } else {
      // one byte.
      encodedLen++;
    }
  }

  inline static void getEncodedLength(const wchar_t val, int32_t& encodedLen) {
    if (val == 0) {
      encodedLen += 2;
    } else if (val < 0x80)  // ASCII character
    {
      encodedLen++;
    } else if (val < 0x800) {
      encodedLen += 2;
    } else {
      encodedLen += 3;
    }
  }

  inline void encodeChar(const char value) {
    uint8_t tmp = static_cast<uint8_t>(value);
    if ((tmp == 0) || (tmp & 0x80)) {
      // two byte.
      *(m_buf++) = static_cast<uint8_t>(0xc0 | ((tmp & 0xc0) >> 6));
      *(m_buf++) = static_cast<uint8_t>(0x80 | (tmp & 0x3f));
    } else {
      // one byte.
      *(m_buf++) = tmp;
    }
  }

  // this will lose the character set encoding.
  inline void encodeChar(const wchar_t value) {
    uint16_t c = static_cast<uint16_t>(value);
    if (c == 0) {
      *(m_buf++) = 0xc0;
      *(m_buf++) = 0x80;
    } else if (c < 0x80) {  // ASCII character
      *(m_buf++) = static_cast<uint8_t>(c);
    } else if (c < 0x800) {
      *(m_buf++) = static_cast<uint8_t>(0xC0 | c >> 6);
      *(m_buf++) = static_cast<uint8_t>(0x80 | (c & 0x3F));
    } else {
      *(m_buf++) = static_cast<uint8_t>(0xE0 | c >> 12);
      *(m_buf++) = static_cast<uint8_t>(0x80 | ((c >> 6) & 0x3F));
      *(m_buf++) = static_cast<uint8_t>(0x80 | (c & 0x3F));
    }
  }

  inline void writeNoCheck(uint8_t value) { *(m_buf++) = value; }

  inline void writeNoCheck(int8_t value) {
    writeNoCheck(static_cast<uint8_t>(value));
  }

  static uint8_t* checkoutBuffer(uint32_t* size);
  static void checkinBuffer(uint8_t* buffer, uint32_t size);

  // disable copy constructor and assignment
  DataOutput(const DataOutput&);
  DataOutput& operator=(const DataOutput&);
};
}  // namespace client
}  // namespace geode
}  // namespace apache

#endif // GEODE_GFCPP_DATAOUTPUT_H_