region.hpp

Go to the documentation of this file.

#ifndef NDNPH_CORE_REGION_HPP
#define NDNPH_CORE_REGION_HPP
 
#include "common.hpp"
 
namespace ndnph {
 
class Region {
public:
  enum {
    ALIGNMENT = sizeof(void*),
  };
 
  template<typename T>
  static constexpr T sizeofAligned(T size) {
    return size % ALIGNMENT == 0 ? size : (size | (ALIGNMENT - 1)) + 1;
  }
  static constexpr T sizeofAligned(T size) {…}
 
  explicit Region(uint8_t* buf, size_t cap)
    : m_begin(buf)
    , m_end(buf + cap) {
    reset();
  }
  explicit Region(uint8_t* buf, size_t cap) {…}
 
  uint8_t* alloc(size_t size) {
    if (available() < size) {
      return nullptr;
    }
    m_right -= size;
    return m_right;
  }
  uint8_t* alloc(size_t size) {…}
 
  uint8_t* allocA(size_t size) {
    uint8_t* room = alignUp(m_left);
    if (m_right - room < static_cast<ssize_t>(size)) {
      return nullptr;
    }
    m_left = room + size;
    return room;
  }
  uint8_t* allocA(size_t size) {…}
 
  bool free(const uint8_t* first, const uint8_t* last) {
    if (first == m_right && last <= m_end) {
      m_right = const_cast<uint8_t*>(last);
      return true;
    }
    if (last == m_left && first >= m_begin) {
      m_left = const_cast<uint8_t*>(first);
      return true;
    }
    return false;
  }
  bool free(const uint8_t* first, const uint8_t* last) {…}
 
  bool free(const uint8_t* ptr, size_t size) {
    return free(ptr, ptr + size);
  }
  bool free(const uint8_t* ptr, size_t size) {…}
 
  template<typename T, typename... Arg>
  T* make(Arg&&... arg) {
    // Region allocator would not `delete` created objects, so it's safe to
    // create trivially destructible objects only.
    static_assert(std::is_trivially_destructible<T>::value, "");
 
    uint8_t* ptr = this->allocA(sizeof(T));
    if (ptr == nullptr) {
      return nullptr;
    }
    return new (ptr) T(std::forward<Arg>(arg)...);
  }
  T* make(Arg&&... arg) {…}
 
  template<typename RefType, typename... Arg>
  RefType create(Arg&&... arg) {
    using ObjType = typename RefType::ObjType;
    auto obj = make<ObjType>(*this, std::forward<Arg>(arg)...);
    return obj == nullptr ? RefType() : RefType(obj);
  }
  RefType create(Arg&&... arg) {…}
 
  void reset() {
    m_left = m_begin;
    m_right = m_end;
  }
  void reset() {…}
 
  size_t available() const {
    return m_right - m_left;
  }
  size_t available() const  {…}
 
  size_t availableA() const {
    return std::max<ssize_t>(0, m_right - alignUp(m_left));
  }
  size_t availableA() const  {…}
 
  size_t size() const {
    return m_end - m_begin - available();
  }
  size_t size() const  {…}
 
protected:
  uint8_t* getArray() {
    return m_begin;
  }
  uint8_t* getArray() {…}
 
private:
  static uint8_t* alignUp(uint8_t* ptr) {
    return reinterpret_cast<uint8_t*>(
      sizeofAligned(reinterpret_cast<uintptr_t>(reinterpret_cast<void*>(ptr))));
  }
 
private:
  uint8_t* const m_begin;
  uint8_t* const m_end;
  uint8_t* m_left;  
  uint8_t* m_right; 
};
class Region {…};
 
template<int C>
class StaticRegion : public Region {
public:
  StaticRegion()
    : Region(m_array, sizeof(m_array)) {}
  StaticRegion() {…}
 
  ~StaticRegion() = default;
 
private:
  uint8_t m_array[C];
};
class StaticRegion : public Region {…};
 
class DynamicRegion : public Region {
public:
  DynamicRegion(size_t capacity)
    : Region(new uint8_t[capacity], capacity) {}
  DynamicRegion(size_t capacity) {…}
 
  ~DynamicRegion() {
    delete[] getArray();
  }
  ~DynamicRegion() {…}
};
class DynamicRegion : public Region {…};
 
constexpr size_t
sizeofSubRegions(size_t capacity, size_t count = 1) {
  return count * (Region::sizeofAligned(capacity) + Region::sizeofAligned(sizeof(Region)));
}
sizeofSubRegions(size_t capacity, size_t count = 1) {…}
 
inline Region*
makeSubRegion(Region& parent, size_t capacity) {
  uint8_t* room = parent.allocA(capacity);
  if (room == nullptr) {
    return nullptr;
  }
  return parent.make<Region>(room, capacity);
}
makeSubRegion(Region& parent, size_t capacity) {…}
 
class WithRegion {
public:
  WithRegion(WithRegion&&) = default;
 
protected:
  explicit WithRegion(Region& region)
    : region(region) {}
  explicit WithRegion(Region& region) {…}
 
  WithRegion(const WithRegion&) = delete;
  WithRegion& operator=(const WithRegion&) = delete;
 
protected:
  Region& region;
 
  friend Region& regionOf(const WithRegion* obj) {
    return obj->region;
  }
  friend Region& regionOf(const WithRegion* obj) {…};
};
class WithRegion {…};
 
class InRegion : public WithRegion {
protected:
  explicit InRegion(Region& region)
    : WithRegion(region) {}
  explicit InRegion(Region& region) {…}
};
class InRegion : public WithRegion {…};
 
template<typename Obj>
class RefRegion {
public:
  using ObjType = Obj;
  static_assert(std::is_base_of<InRegion, ObjType>::value, "");
 
  explicit RefRegion(ObjType* obj = nullptr)
    : obj(obj) {}
  explicit RefRegion(ObjType* obj = nullptr) {…}
 
  explicit operator bool() const {
    return obj != nullptr;
  }
  explicit operator bool() const  {…}
 
protected:
  ~RefRegion() = default;
 
protected:
  ObjType* obj = nullptr;
 
  friend Region& regionOf(const RefRegion<Obj>& ref) {
    return regionOf(ref.obj);
  }
  friend Region& regionOf(const RefRegion<Obj>& ref) {…};
};
class RefRegion {…};
 
} // namespace ndnph
 
#endif // NDNPH_CORE_REGION_HPP