StaticBuffer.h

Go to the documentation of this file.

/*
 * 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 Common_StaticBuffer_h
#define Common_StaticBuffer_h

#include "DynamicBuffer.h"
#include "Logger.h"

#include <cstdlib>
#include <memory>

namespace Hypertable {


  class StaticBuffer {
  public:
    StaticBuffer()
      : base(0), alignment(0), size(0), own(true) {
    }

    explicit StaticBuffer(size_t len, size_t alignment=0)
      : alignment(alignment), size(len), own(true) {
      if (alignment > 0) {
        void *vptr = 0;
        size_t aligned_len = (len % alignment) == 0 ? len :
          ((len / alignment)+1)*alignment;
        HT_ASSERT(posix_memalign(&vptr, alignment, aligned_len) == 0);
        base = (uint8_t *)vptr;
      }
      else
        base = new uint8_t[len];
    }

    StaticBuffer(void *data, uint32_t len, bool take_ownership = true)
      : base((uint8_t *)data), alignment(0), size(len), own(take_ownership) {
    }

    StaticBuffer(DynamicBuffer &dbuf) {
      base = dbuf.base;
      size = dbuf.fill();
      own = dbuf.own;
      alignment = 0;
      if (own) {
        dbuf.base = dbuf.ptr = 0;
        dbuf.size = 0;
      }
    }

    ~StaticBuffer() {
      free();
    }

    StaticBuffer(StaticBuffer& other) {
      base = other.base;
      size = other.size;
      own = other.own;
      alignment = other.alignment;
      if (own) {
        other.own = false;
        other.base = 0;
      }
    }

    StaticBuffer &operator=(StaticBuffer &other) {
      base = other.base;
      size = other.size;
      own = other.own;
      alignment = other.alignment;
      if (own) {
        other.own = false;
        other.base = 0;
      }
      return *this;
    }

    StaticBuffer &operator=(DynamicBuffer &dbuf) {
      base = dbuf.base;
      size = dbuf.fill();
      own = dbuf.own;
      alignment = 0;
      if (own) {
        dbuf.base = dbuf.ptr = 0;
        dbuf.size = 0;
      }
      return *this;
    }

    void set(uint8_t *data, uint32_t len, bool take_ownership = true) {
      free();
      base = data;
      size = len;
      own = take_ownership;
      alignment = 0;
    }

    void free() {
      if (own && base) {
        if (alignment > 0)
          ::free(base);
        else
          delete [] base;
      }
      base = 0;
      size = 0;
    }

    size_t aligned_size() {
      if (alignment == 0 || (size % alignment) == 0)
        return size;
      return ((size / alignment)+1) * alignment;
    }

    uint8_t *base;
    size_t alignment;
    uint32_t size;
    bool own;
  };

  inline bool operator<(const StaticBuffer& sb1, const StaticBuffer& sb2) {
    size_t len = (sb1.size < sb2.size) ? sb1.size : sb2.size;
    int cmp = memcmp(sb1.base, sb2.base, len);
    return (cmp==0) ? sb1.size < sb2.size : cmp < 0;
  }

  inline bool operator==(const StaticBuffer& sb1, const StaticBuffer& sb2) {
    if (sb1.size != sb2.size)
      return false;
    size_t len = (sb1.size < sb2.size) ? sb1.size : sb2.size;
    int equal = memcmp(sb1.base, sb2.base, len);
    if (equal == 0 )
      return true;
    return false;
  }

  inline bool operator!=(const StaticBuffer& sb1, const StaticBuffer& sb2) {
    return !(sb1 == sb2);
  }

  typedef std::shared_ptr<StaticBuffer> StaticBufferPtr;


} // namespace Hypertable

#endif // Common_StaticBuffer_h