allocatable.h

Go to the documentation of this file.

#ifndef ION_BASE_ALLOCATABLE_H_
#define ION_BASE_ALLOCATABLE_H_

#include "base/macros.h"
#include "ion/base/allocationmanager.h"
#include "ion/base/allocator.h"
#include "ion/base/logging.h"
#include "ion/external/gtest/gunit_prod.h"  // For FRIEND_TEST().

namespace ion {
namespace base {

class ION_API Allocatable {
 public:
  virtual ~Allocatable();

  const AllocatorPtr& GetAllocator() const { return allocator_; }

  const AllocatorPtr& GetNonNullAllocator() const {
    return AllocationManager::GetNonNullAllocator(allocator_);
  }

  const AllocatorPtr& GetAllocatorForLifetime(
      AllocationLifetime lifetime) const {
    return GetAllocator()->GetAllocatorForLifetime(lifetime);
  }

  void* operator new(size_t size) { return New(size, GetDefaultAllocator()); }

  void* operator new(size_t size, AllocationLifetime lifetime) {
    return New(size, GetDefaultAllocatorForLifetime(lifetime));
  }

  void* operator new(size_t size, const AllocatorPtr& allocator) {
    return New(size, allocator);
  }

  void* operator new(size_t size, const AllocatorPtr& allocator, void* ptr) {
    return PlacementNew(size, allocator, ptr);
  }

  void* operator new(size_t size, void* ptr) { return ptr; }

  void operator delete(void* ptr) { Delete(ptr); }

  void operator delete(void* ptr, AllocationLifetime lifetime) { Delete(ptr); }
  void operator delete(void* ptr, const AllocatorPtr& allocator) {
    Delete(ptr);
  }

  void operator delete(void* ptr, void* ptr2) {}

 protected:
  Allocatable();

  Allocatable(const Allocatable& other);

  void operator=(const Allocatable& other) {}

  explicit Allocatable(const AllocatorPtr& allocator);

 private:
  template <typename T> friend class StlAllocator;

  class Helper;

  void* operator new[](size_t size);
  void* operator new[](size_t size, AllocationLifetime lifetime);
  void* operator new[](size_t size, const AllocatorPtr& allocator);
  void* operator new[](size_t size, void* ptr);
  void operator delete[](void* ptr);
  void operator delete[](void* ptr, AllocationLifetime lifetime);
  void operator delete[](void* ptr, const AllocatorPtr& allocator);
  void operator delete[](void* ptr, void* ptr2);

  void Construct();

  static const AllocatorPtr& GetDefaultAllocator() {
    return AllocationManager::GetDefaultAllocator();
  }
  static const AllocatorPtr& GetDefaultAllocatorForLifetime(
      AllocationLifetime lifetime) {
    return AllocationManager::GetDefaultAllocatorForLifetime(lifetime);
  }

  static void* New(size_t size, const AllocatorPtr& allocator);
  static void Delete(void* mem_ptr);
  static void* PlacementNew(size_t size, const AllocatorPtr& allocator,
                            void* ptr);

  static void SetPlacementAllocator(Allocator* allocator);

  static Allocator* GetPlacementAllocator();

  static Helper* GetHelper();

  AllocatorPtr allocator_;

  const void* memory_ptr_;

  FRIEND_TEST(AllocatableTest, TrivialType);
};

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_ALLOCATABLE_H_