allocvector.h

Go to the documentation of this file.

#ifndef ION_BASE_STLALLOC_ALLOCVECTOR_H_
#define ION_BASE_STLALLOC_ALLOCVECTOR_H_

#include <vector>

#include "ion/base/allocatable.h"
#include "ion/base/allocationmanager.h"
#include "ion/base/stlalloc/stlallocator.h"

namespace ion {
namespace base {


template <typename T>
class AllocVector : public std::vector<T, StlAllocator<T> > {
 public:
  typedef StlAllocator<T> AllocType;
  typedef std::vector<T, AllocType> VectorType;
  explicit AllocVector(const AllocatorPtr& alloc)
      : VectorType(AllocType(AllocationManager::GetNonNullAllocator(alloc))) {}
  explicit AllocVector(const Allocatable& owner)
      : VectorType(AllocType(owner.GetNonNullAllocator())) {}

  AllocVector(const AllocatorPtr& alloc, size_t n, const T& val)
      : VectorType(n, val,
                   AllocType(AllocationManager::GetNonNullAllocator(alloc))) {}
  AllocVector(const Allocatable& owner, size_t n, const T& val)
      : VectorType(n, val, AllocType(owner.GetNonNullAllocator())) {}

  template <class IteratorT>
  AllocVector(const AllocatorPtr& alloc, IteratorT first, IteratorT last)
      : VectorType(first, last,
                   AllocType(AllocationManager::GetNonNullAllocator(alloc))) {}
  template <class IteratorT>
  AllocVector(const Allocatable& owner, IteratorT first, IteratorT last)
      : VectorType(first, last,
                   AllocType(owner.GetNonNullAllocator())) {}

  template <typename ContainerT>
  AllocVector(const AllocatorPtr& alloc, const ContainerT& from)
      : VectorType(from.begin(), from.end(),
                   AllocType(AllocationManager::GetNonNullAllocator(alloc))) {}
  template <typename ContainerT>
  AllocVector(const Allocatable& owner, const ContainerT& from)
      : VectorType(from.begin(), from.end(),
                   AllocType(owner.GetNonNullAllocator())) {}

  AllocVector(const AllocatorPtr& alloc, std::initializer_list<T> init)
      : VectorType(init,
                   AllocType(AllocationManager::GetNonNullAllocator(alloc))) {}
  AllocVector(const Allocatable& owner, std::initializer_list<T> init)
      : VectorType(init,
                   AllocType(owner.GetNonNullAllocator())) {}
};

template <typename T, int N>
class InlinedAllocVector : public std::vector<T, StlInlinedAllocator<T, N> > {
 public:
  typedef StlInlinedAllocator<T, N> AllocType;
  typedef std::vector<T, AllocType> VectorType;
  explicit InlinedAllocVector(const AllocatorPtr& alloc)
      : VectorType(AllocType(AllocationManager::GetNonNullAllocator(alloc))) {}
  explicit InlinedAllocVector(const Allocatable& owner)
      : VectorType(AllocType(owner.GetNonNullAllocator())) {}

  InlinedAllocVector(const AllocatorPtr& alloc, size_t n, const T& val)
      : VectorType(n, val,
                   AllocType(AllocationManager::GetNonNullAllocator(alloc))) {}
  InlinedAllocVector(const Allocatable& owner, size_t n, const T& val)
      : VectorType(n, val, AllocType(owner.GetNonNullAllocator())) {}

  template <class IteratorT>
  InlinedAllocVector(const AllocatorPtr& alloc, IteratorT first, IteratorT last)
      : VectorType(first, last,
                   AllocType(AllocationManager::GetNonNullAllocator(alloc))) {}
  template <class IteratorT>
  InlinedAllocVector(const Allocatable& owner, IteratorT first, IteratorT last)
      : VectorType(first, last,
                   AllocType(owner.GetNonNullAllocator())) {}

  template <typename ContainerT>
  InlinedAllocVector(const AllocatorPtr& alloc, const ContainerT& from)
      : VectorType(from.begin(), from.end(),
                   AllocType(AllocationManager::GetNonNullAllocator(alloc))) {}
  template <typename ContainerT>
  InlinedAllocVector(const Allocatable& owner, const ContainerT& from)
      : VectorType(from.begin(), from.end(),
                   AllocType(owner.GetNonNullAllocator())) {}
};

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_STLALLOC_ALLOCVECTOR_H_