reallocator.hpp

//
// Copyright 2014 Felix Petriconi
//
// License: http://boost.org/LICENSE_1_0.txt, Boost License 1.0
//
// Authors: http://petriconi.net, Felix Petriconi
//
#pragma once

#include "traits.hpp"
#include <type_traits>

namespace alb {
  inline namespace v_100 {
    namespace internal {

      template <class OldAllocator, class NewAllocator>
      bool reallocate_with_copy(OldAllocator &oldAllocator, NewAllocator &newAllocator, block &b,
        size_t n) noexcept
      {
        auto newBlock = newAllocator.allocate(n);
        if (!newBlock) {
          return false;
        }
        block_copy(b, newBlock);
        oldAllocator.deallocate(b);
        b = newBlock;
        return true;
      }

      template <class Allocator, typename Enabled = void> struct reallocator;

      template <class Allocator>
      struct reallocator<Allocator,
        typename std::enable_if<traits::has_expand<Allocator>::value>::type> {
        static bool is_handled_default(Allocator &allocator, block &b, size_t n) noexcept
        {
          if (b.length == n) {
            return true;
          }
          if (n == 0) {
            allocator.deallocate(b);
            return true;
          }
          if (!b) {
            b = allocator.allocate(n);
            return true;
          }
          if (n > b.length) {
            if (allocator.expand(b, n - b.length)) {
              return true;
            }
          }
          return false;
        }
      };

      template <class Allocator>
      struct reallocator<Allocator,
        typename std::enable_if<!traits::has_expand<Allocator>::value>::type> {

        static bool is_handled_default(Allocator &allocator, block &b, size_t n) noexcept
        {
          if (b.length == n) {
            return true;
          }
          if (n == 0) {
            allocator.deallocate(b);
            return true;
          }
          if (!b) {
            b = allocator.allocate(n);
            return true;
          }
          return false;
        }
      };

      template <typename Allocator>
      bool is_reallocation_handled_default(Allocator& allocator, block& b, size_t n) noexcept
      {
        return reallocator<Allocator>::is_handled_default(allocator, b, n);
      }
    } // namespace Helper
  }
  using namespace v_100;
}