scopedallocation.h

Go to the documentation of this file.

#ifndef ION_BASE_SCOPEDALLOCATION_H_
#define ION_BASE_SCOPEDALLOCATION_H_

#include <functional>

#include "base/macros.h"
#include "ion/base/allocationmanager.h"
#include "ion/base/allocator.h"
#include "ion/base/datacontainer.h"

namespace ion {
namespace base {

template <typename T> class ION_API ScopedAllocation {
 public:
  explicit ScopedAllocation(const AllocatorPtr& allocator) {
    Init(allocator, 1U);
  }

  explicit ScopedAllocation(AllocationLifetime lifetime) {
    Init(AllocationManager::GetDefaultAllocatorForLifetime(lifetime), 1U);
  }

  ScopedAllocation(const AllocatorPtr& allocator, size_t count) {
    Init(allocator, count);
  }

  ScopedAllocation(AllocationLifetime lifetime, size_t count) {
    Init(AllocationManager::GetDefaultAllocatorForLifetime(lifetime), count);
  }

  ~ScopedAllocation() {
    DeleteData(instance_ptr_, count_, allocator_, memory_ptr_);
  }

  T* Get() const { return instance_ptr_; }

  DataContainerPtr TransferToDataContainer(bool is_wipeable) {
    return DataContainer::Create<T>(
        Release(),
        std::bind(&ScopedAllocation<T>::Deleter, std::placeholders::_1, count_,
                  allocator_, memory_ptr_),
        is_wipeable, allocator_);
  }

 private:
  void Init(const AllocatorPtr& allocator, size_t count) {
    allocator_ = AllocationManager::GetNonNullAllocator(allocator);
    count_ = count;
    if (count_) {
      memory_ptr_ =
          allocator_->AllocateMemory(sizeof(size_t) + count_ * sizeof(T));
      instance_ptr_ = new(memory_ptr_) T[count_];
    } else {
      memory_ptr_ = NULL;
      instance_ptr_ = NULL;
    }
  }

  T* Release() {
    T* ptr = instance_ptr_;
    instance_ptr_ = NULL;
    return ptr;
  }

  static void Deleter(void* data, size_t count, AllocatorPtr allocator,
                      void* memory_ptr) {
    DeleteData(reinterpret_cast<T*>(data), count, allocator, memory_ptr);
  }

  static void DeleteData(T* data, size_t count, const AllocatorPtr& allocator,
                         void* memory_ptr) {
    if (data) {
      for (size_t i = 0; i < count; ++i)
        data[i].~T();
      if (allocator.Get())
        allocator->DeallocateMemory(memory_ptr);
    }
  }

  AllocatorPtr allocator_;
  void* memory_ptr_;
  T* instance_ptr_;
  size_t count_;

  DISALLOW_COPY_AND_ASSIGN(ScopedAllocation);
};

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_SCOPEDALLOCATION_H_