Line data    Source code

       1             : 
       2             : /* Copyright (c) 2015, Human Brain Project
       3             :  *                     Stefan.Eilemann@epfl.ch
       4             :  *                     grigori.chevtchenko@epfl.ch
       5             :  */
       6             : 
       7             : #include "NonMovingSubAllocator.h"
       8             : #include <zerobuf/version.h>
       9             : 
      10             : #include <cstring>
      11             : 
      12             : namespace zerobuf
      13             : {
      14             : namespace
      15             : {
      16             : template <class A>
      17          39 : void _initializeAllocation(A& alloc, const size_t index, const size_t size)
      18             : {
      19          39 :     if (alloc.getDynamicOffset(index) == 0)
      20          33 :         alloc.updateAllocation(index, false /*no copy*/, size);
      21          39 : }
      22             : 
      23             : template <>
      24           0 : void _initializeAllocation(const Allocator&, const size_t, const size_t)
      25             : {
      26           0 : }
      27             : }
      28             : 
      29             : template <class A>
      30          39 : NonMovingSubAllocatorBase<A>::NonMovingSubAllocatorBase(A& parent,
      31             :                                                         const size_t index,
      32             :                                                         const size_t numDynamic,
      33             :                                                         const size_t staticSize)
      34             :     : NonMovingBaseAllocator(staticSize, numDynamic)
      35             :     , _parent(parent)
      36          39 :     , _index(index)
      37             : {
      38          39 :     _initializeAllocation(parent, index, staticSize);
      39          39 : }
      40             : 
      41             : template <class A>
      42          78 : NonMovingSubAllocatorBase<A>::~NonMovingSubAllocatorBase()
      43             : {
      44          78 : }
      45             : 
      46             : template <class A>
      47         210 : uint8_t* NonMovingSubAllocatorBase<A>::getData()
      48             : {
      49         210 :     return _parent.getData() + _parent.getDynamicOffset(_index);
      50             : }
      51             : 
      52             : template <>
      53           0 : uint8_t* NonMovingSubAllocatorBase<const Allocator>::getData()
      54             : {
      55           0 :     throw std::runtime_error("Non-const access on const allocator");
      56             : }
      57             : 
      58             : template <class A>
      59         446 : const uint8_t* NonMovingSubAllocatorBase<A>::getData() const
      60             : {
      61         892 :     return const_cast<const A&>(_parent).getData() +
      62         892 :            _parent.getDynamicOffset(_index);
      63             : }
      64             : 
      65             : template <class A>
      66         205 : size_t NonMovingSubAllocatorBase<A>::getSize() const
      67             : {
      68         205 :     return _parent.getDynamicSize(_index);
      69             : }
      70             : 
      71             : template <class A>
      72           0 : void NonMovingSubAllocatorBase<A>::copyBuffer(const void* data,
      73             :                                               const size_t size)
      74             : {
      75           0 :     void* to = _parent.updateAllocation(_index, false /*no copy*/, size);
      76           0 :     ::memcpy(to, data, size);
      77           0 : }
      78             : 
      79             : template <>
      80           0 : void NonMovingSubAllocatorBase<const Allocator>::copyBuffer(const void*,
      81             :                                                             const size_t)
      82             : {
      83           0 :     throw std::runtime_error("Non-const access on const allocator");
      84             : }
      85             : 
      86             : template <class A>
      87          19 : void NonMovingSubAllocatorBase<A>::_resize(const size_t newSize)
      88             : {
      89          19 :     _parent.updateAllocation(_index, true /*copy*/, newSize);
      90          19 : }
      91             : 
      92             : template <>
      93           0 : void NonMovingSubAllocatorBase<const Allocator>::_resize(const size_t)
      94             : {
      95           0 :     throw std::runtime_error("Non-const access on const allocator");
      96             : }
      97             : 
      98             : template class NonMovingSubAllocatorBase<Allocator>;
      99             : template class NonMovingSubAllocatorBase<const Allocator>;
     100             : }