stlallocator.h

Go to the documentation of this file.

#ifndef ION_BASE_STLALLOC_STLALLOCATOR_H_
#define ION_BASE_STLALLOC_STLALLOCATOR_H_

#include <memory>
#include <type_traits>

#include "ion/base/allocatable.h"
#include "ion/base/allocator.h"
#include "ion/base/type_structs.h"
#include "ion/port/align.h"

namespace ion {
namespace base {

template <typename T> class StlAllocator : public std::allocator<T> {
 public:
  typedef typename std::allocator<T>::pointer Pointer;
  typedef typename std::allocator<T>::const_pointer ConstPointer;
  typedef typename std::allocator<T>::size_type SizeType;

  typedef std::true_type propagate_on_container_move_assignment;
  typedef std::true_type propagate_on_container_swap;

  explicit StlAllocator(const AllocatorPtr& allocator)
      : allocator_(allocator) {}
  template <typename U> StlAllocator(const StlAllocator<U>& a)
      : allocator_(a.allocator_) {}
  const AllocatorPtr& GetAllocator() const { return allocator_; }

  Pointer allocate(SizeType n, ConstPointer hint = 0) {
    DCHECK(allocator_.Get());
    void* p = allocator_->AllocateMemory(n * sizeof(T));
    return reinterpret_cast<Pointer>(p);
  }
  void deallocate(Pointer p, SizeType n) {
    allocator_->DeallocateMemory(p);
  }

  void construct(Pointer p, const T& val) {
    typedef typename std::conditional<HasTrivialDestructor<T>::value, void,
                                      T>::type VoidOrT;
    const VoidOrT* select_overload = NULL;
    construct_impl(select_overload, p, val);
  }
  template <typename... Args>
  void construct(Pointer p, Args&&... args) {  // NOLINT
    typedef typename std::conditional<HasTrivialDestructor<T>::value, void,
                                      T>::type VoidOrT;
    const VoidOrT* select_overload = NULL;
    construct_impl(select_overload, p, std::forward<Args>(args)...);  // NOLINT
  }
  template <class U, class... Args>
  void construct(U* p, Args&&... args) {  // NOLINT
    typedef typename std::conditional<HasTrivialDestructor<U>::value, void,
                                      U>::type VoidOrU;
    const VoidOrU* select_overload = NULL;
    construct_impl(select_overload, p, std::forward<Args>(args)...);  // NOLINT
  }

  template <typename U>
  struct rebind {
    typedef StlAllocator<U> other;
  };

 private:
  StlAllocator();  // Not default constructible.

  void construct_impl(const void* dummy, Pointer p, const T& val) {
    std::allocator<T>::construct(p, val);
  }
  template <typename... Args>
  void construct_impl(const void* dummy, Pointer p,
                      Args&&... args) {  // NOLINT
    std::allocator<T>::construct(p, std::forward<Args>(args)...);  // NOLINT
  }
  template <class U, class... Args>
  void construct_impl(const void* dummy, U* p, Args&&... args) {  // NOLINT
    std::allocator<T>::construct(p, std::forward<Args>(args)...);  // NOLINT
  }

  void construct_impl(const T* dummy, Pointer p, const T& val) {
    Allocatable::SetPlacementAllocator(allocator_.Get());
    std::allocator<T>::construct(p, val);
    Allocatable::SetPlacementAllocator(NULL);
  }
  template <typename... Args>
  void construct_impl(const T* dummy, Pointer p, Args&&... args) {  // NOLINT
    Allocatable::SetPlacementAllocator(allocator_.Get());
    std::allocator<T>::construct(p, std::forward<Args>(args)...);  // NOLINT
    Allocatable::SetPlacementAllocator(NULL);
  }
  template <class U, class... Args>
  void construct_impl(const U* dummy, U* p, Args&&... args) {  // NOLINT
    Allocatable::SetPlacementAllocator(allocator_.Get());
    std::allocator<T>::construct(p, std::forward<Args>(args)...);  // NOLINT
    Allocatable::SetPlacementAllocator(NULL);
  }

  AllocatorPtr allocator_;
  template <typename U> friend class StlAllocator;
};

template <typename T, int N>
class StlInlinedAllocator : public StlAllocator<T> {
 public:
  typedef typename StlAllocator<T>::Pointer Pointer;
  typedef typename StlAllocator<T>::ConstPointer ConstPointer;
  typedef typename StlAllocator<T>::SizeType SizeType;
  explicit StlInlinedAllocator(const AllocatorPtr& allocator)
      : StlAllocator<T>(allocator), current_(NULL), inlined_(true) {}
  explicit StlInlinedAllocator(const StlInlinedAllocator<T, N>& a)
      : StlAllocator<T>(a.GetAllocator()),
        current_(NULL),
        inlined_(a.inlined_) {}
  template <typename U>
  StlInlinedAllocator(const StlInlinedAllocator<U, N>& a)
      : StlAllocator<T>(a.GetAllocator()),
        current_(NULL),
        inlined_(a.inlined_) {}
  Pointer allocate(SizeType n, ConstPointer hint = 0) {
    if (n <= N && inlined_) {
      if (current_ == reinterpret_cast<T*>(&storage_[0]))
        current_ = reinterpret_cast<T*>(&storage_[sizeof(T) * N]);
      else
        current_ = reinterpret_cast<T*>(&storage_[0]);
      return reinterpret_cast<Pointer>(current_);
    } else {
      inlined_ = false;
      return this->StlAllocator<T>::allocate(n, hint);
    }
  }
  void deallocate(Pointer p, SizeType n) {
    if (p != reinterpret_cast<Pointer>(&storage_) &&
        p != reinterpret_cast<Pointer>(&storage_[sizeof(T) * N])) {
      inlined_ = true;
      this->StlAllocator<T>::deallocate(p, n);
    }
  }

  template <typename U, typename V>
  struct RebindHelper {
    typedef typename StlAllocator<V>::template rebind<U>::other other;
  };
  template <typename U>
  struct RebindHelper<U, U> {
    typedef StlInlinedAllocator<U, N> other;
  };
  template <typename U> struct rebind {
    typedef typename RebindHelper<U, T>::other other;
  };

 private:
  ION_ALIGN(16) char storage_[sizeof(T) * N * 2];
  T* current_;
  bool inlined_;
  template <typename U, int M> friend class StlInlinedAllocator;
};

template <class T1, class T2>
bool operator==(const StlAllocator<T1>& lhs, const StlAllocator<T2>& rhs) {
  return false;
}

template <class T1, class T2>
bool operator!=(const StlAllocator<T1>& lhs, const StlAllocator<T2>& rhs) {
  return true;
}

template <class T>
bool operator==(const StlAllocator<T>& lhs, const StlAllocator<T>& rhs) {
  return lhs.GetAllocator() == rhs.GetAllocator();
}

template <class T>
bool operator!=(const StlAllocator<T>& lhs, const StlAllocator<T>& rhs) {
  return lhs.GetAllocator() != rhs.GetAllocator();
}

template <class T1, class T2, int N1, int N2>
bool operator==(const StlInlinedAllocator<T1, N1>& lhs,
                const StlInlinedAllocator<T2, N2>& rhs) {
  return &lhs == &rhs;
}

template <class T1, class T2, int N1, int N2>
bool operator!=(const StlInlinedAllocator<T1, N1>& lhs,
                const StlInlinedAllocator<T2, N2>& rhs) {
  return &lhs != &rhs;
}

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_STLALLOC_STLALLOCATOR_H_