datacontainer.h

Go to the documentation of this file.

#ifndef ION_BASE_DATACONTAINER_H_
#define ION_BASE_DATACONTAINER_H_

#include <cstring>
#include <functional>

#if ION_DEBUG
#include <set>
#endif

#include "base/integral_types.h"
#include "base/macros.h"
#include "ion/base/logging.h"
#include "ion/base/notifier.h"
#include "ion/port/nullptr.h"  // For kNullFunction.

namespace ion {
namespace base {

class DataContainer;
typedef base::ReferentPtr<DataContainer>::Type DataContainerPtr;
typedef base::WeakReferentPtr<DataContainer> DataContainerWeakPtr;

class ION_API DataContainer : public base::Notifier {
 public:
  typedef std::function<void(void* data_to_delete)> Deleter;

  template <typename T>
  static void ArrayDeleter(void* data_to_delete) {
    T* data = reinterpret_cast<T*>(data_to_delete);
    delete [] data;
  }
  template <typename T>
  static void PointerDeleter(void* data_to_delete) {
    T* data = reinterpret_cast<T*>(data_to_delete);
    delete data;
  }
  static void AllocatorDeleter(AllocatorPtr allocator, void* data_to_delete) {
    DCHECK(allocator.Get());
    allocator->DeallocateMemory(data_to_delete);
  }

  bool IsWipeable() const { return is_wipeable_; }

  template <typename T>
  const T* GetData() const {
    return reinterpret_cast<const T*>(GetDataPtr());
  }

  const void* GetData() const {
    return reinterpret_cast<const void*>(GetDataPtr());
  }

  template <typename T>
  T* GetMutableData() const {
    T* data = reinterpret_cast<T*>(GetDataPtr());
    if (data)
      this->Notify();
    else
      LOG(ERROR) << "GetMutableData() called on NULL (or wiped) DataContainer. "
                    "The contents of the original buffer will not be returned "
                    "and any data in GPU memory will likely be cleared. This "
                    "is probably not what you want.";
    return data;
  }

  template <typename T>
  static DataContainerPtr Create(
      T* data, const Deleter& data_deleter, bool is_wipeable,
      const AllocatorPtr& container_allocator) {
    if (data_deleter && !AddOrRemoveDataFromCheck(data, true))
      return DataContainerPtr(NULL);
    DataContainer* container =
        Allocate(0, data_deleter, is_wipeable, container_allocator);
    container->data_ = data;
    return DataContainerPtr(container);
  }

  template <typename T>
  static DataContainerPtr CreateAndCopy(
      const T* data, size_t count, bool is_wipeable,
      const AllocatorPtr& container_and_data_allocator) {
    DataContainer* container =
        Allocate(0, kNullFunction, is_wipeable, container_and_data_allocator);
    if (is_wipeable) {
      container->data_allocator_ =
          container->GetAllocator().Get()
              ? container->GetAllocator()->GetAllocatorForLifetime(kShortTerm)
              : AllocationManager::GetDefaultAllocatorForLifetime(kShortTerm);
    } else {
      container->data_allocator_ = container->GetAllocator();
    }
    container->deleter_ =
        std::bind(DataContainer::AllocatorDeleter, container->data_allocator_,
                  std::placeholders::_1);
    container->data_ =
        container->data_allocator_->AllocateMemory(sizeof(T) * count);
    if (data)
      memcpy(container->data_, data, sizeof(T) * count);
    return DataContainerPtr(container);
  }

  template <typename T>
  static DataContainerPtr CreateOverAllocated(
      size_t count, const T* data, const AllocatorPtr& container_allocator) {
    DataContainer* container = Allocate(sizeof(T) * count + 16, kNullFunction,
                                        false, container_allocator);
    uint8* ptr = reinterpret_cast<uint8*>(container) + sizeof(DataContainer);
    container->data_ = ptr + 16 - (reinterpret_cast<size_t>(ptr) % 16);
    if (data)
      memcpy(container->data_, data, sizeof(T) * count);
    return DataContainerPtr(container);
  }

  void WipeData();

 protected:
  ~DataContainer() override;

  DataContainer(const Deleter& deleter, bool is_wipeable);

 private:
  static DataContainer* Allocate(size_t extra_bytes, const Deleter& deleter,
                                 bool is_wipeable,
                                 const AllocatorPtr& allocator);

  static bool AddOrRemoveDataFromCheck(void* data, bool is_add);

  virtual void InternalWipeData();

  virtual void* GetDataPtr() const { return data_; }

  void* data_;
  bool is_wipeable_;
  Deleter deleter_;

  base::AllocatorPtr data_allocator_;

  DISALLOW_IMPLICIT_CONSTRUCTORS(DataContainer);
};

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_DATACONTAINER_H_