buffer.h

Go to the documentation of this file.

#ifndef CVMFS_UTIL_BUFFER_H_
#define CVMFS_UTIL_BUFFER_H_

#include <cassert>
#include <cstddef>
#include <memory>


#ifdef CVMFS_NAMESPACE_GUARD
namespace CVMFS_NAMESPACE_GUARD {
#endif


template<typename T, class A = std::allocator<T> >
class Buffer {
 public:
  typedef typename A::pointer pointer_t;

  Buffer() : used_(0), size_(0), buffer_(NULL), initialized_(false) { }

  explicit Buffer(const size_t size)
      : used_(0), size_(0), buffer_(NULL), initialized_(false) {
    Allocate(size);
  }

  virtual ~Buffer() { Deallocate(); }

  void Allocate(const size_t size) {
    assert(!IsInitialized());
    size_ = size;
    buffer_ = allocator_.allocate(size_bytes());
    initialized_ = true;
  }

  bool IsInitialized() const { return initialized_; }

  typename A::pointer ptr() {
    assert(IsInitialized());
    return buffer_;
  }
  const typename A::pointer ptr() const {
    assert(IsInitialized());
    return buffer_;
  }

  typename A::pointer free_space_ptr() {
    assert(IsInitialized());
    return buffer_ + used();
  }

  const typename A::pointer free_space_ptr() const {
    assert(IsInitialized());
    return buffer_ + used();
  }

  void SetUsed(const size_t items) {
    assert(items <= size());
    used_ = items;
  }

  void SetUsedBytes(const size_t bytes) {
    assert(bytes <= size_bytes());
    assert(bytes % sizeof(T) == 0);
    used_ = bytes / sizeof(T);
  }

  size_t size() const { return size_; }
  size_t size_bytes() const { return size_ * sizeof(T); }
  size_t used() const { return used_; }
  size_t used_bytes() const { return used_ * sizeof(T); }
  size_t free() const { return size_ - used_; }
  size_t free_bytes() const { return free() * sizeof(T); }

 private:
  Buffer(const Buffer &other) { assert(false); }  // no copy!
  Buffer &operator=(const Buffer &other) { assert(false); }

  void Deallocate() {
    if (size_ == 0) {
      return;
    }
    allocator_.deallocate(buffer_, size_bytes());
    buffer_ = NULL;
    size_ = 0;
    used_ = 0;
    initialized_ = false;
  }

 private:
  A allocator_;
  size_t used_;
  size_t size_;
  typename A::pointer buffer_;
  bool initialized_;
};

#ifdef CVMFS_NAMESPACE_GUARD
}  // namespace CVMFS_NAMESPACE_GUARD
#endif

#endif  // CVMFS_UTIL_BUFFER_H_