affix_allocator.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 "allocator_base.hpp"
#include "internal/reallocator.hpp"
#include "internal/affix_helper.hpp"

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4345)
#endif

namespace alb {
  inline namespace v_100 {

    template <class Allocator, typename Prefix, typename Sufix = affix_helper::no_affix>
    class affix_allocator 
    {
      Allocator allocator_;

      constexpr Prefix *inner_to_prefix(const block &b) const noexcept
      {
        return static_cast<Prefix *>(b.ptr);
      }

      constexpr Sufix *inner_to_sufix(const block &b) const noexcept
      {
        return reinterpret_cast<Sufix*>(static_cast<char*>(b.ptr) + b.length - sufix_size);
      }

      constexpr block to_inner_block(const block &b) const noexcept
      {
        return { static_cast<char *>(b.ptr) - prefix_size, b.length + prefix_size + sufix_size };
      }

      constexpr block to_outer_block(const block &b) const noexcept
      {
        return { static_cast<char *>(b.ptr) + prefix_size, b.length - prefix_size - sufix_size };
      }

    public:
      affix_allocator(const affix_allocator &) = delete;
      affix_allocator &operator=(const affix_allocator &) = delete;

      static constexpr bool supports_truncated_deallocation = Allocator::supports_truncated_deallocation;
      static constexpr unsigned alignment = Allocator::alignment;

      using allocator = Allocator;
      using prefix = Prefix;
      using sufix = Sufix;

      static constexpr size_t prefix_size =
        std::is_same<Prefix, affix_helper::no_affix>::value ? 0 : internal::round_to_alignment(alignment, sizeof(Prefix));

      static constexpr size_t sufix_size =
        std::is_same<Sufix, affix_helper::no_affix>::value ? 0 : internal::round_to_alignment(alignment, sizeof(Sufix));

      static constexpr size_t good_size(size_t n) {
        return Allocator::good_size(n);
      }

      affix_allocator() noexcept
      {}

      affix_allocator(affix_allocator &&x) = default;

      affix_allocator &operator=(affix_allocator &&x) = default;

      constexpr Prefix *outer_to_prefix(const block &b) const noexcept
      {
        return b ? reinterpret_cast<Prefix *>(static_cast<char*>(b.ptr) - prefix_size) : nullptr;
      }

      constexpr Sufix *outer_to_sufix(const block &b) const noexcept
      {
        return b ? (reinterpret_cast<Sufix*>(static_cast<char *>(b.ptr) + b.length)) : nullptr;
      }

      block allocate(size_t n) noexcept
      {
        block result;
        if (n == 0) {
          return result;
        }

        auto innerMem = allocator_.allocate(prefix_size + n + sufix_size);
        if (innerMem) {
          if (prefix_size > 0) {
            affix_helper::create_affix_in_place<Prefix>(inner_to_prefix(innerMem), *this);
          }
          if (sufix_size > 0) {
            affix_helper::create_affix_in_place<Sufix>(inner_to_sufix(innerMem), *this);
          }
          result = to_outer_block(innerMem);
          return result;
        }
        return result;
      }

      void deallocate(block &b) noexcept
      {
        if (!b) {
          return;
        }
        if (prefix_size > 0) {
          outer_to_prefix(b)->~Prefix();
        }
        if (sufix_size > 0) {
          outer_to_sufix(b)->~Sufix();
        }
        auto innerBlock(to_inner_block(b));
        allocator_.deallocate(innerBlock);
        b.reset();
      }

      template <typename U = Allocator>
      typename std::enable_if<traits::has_owns<U>::value, bool>::type
        owns(const block &b) const noexcept
      {
        return b && allocator_.owns(to_inner_block(b));
      }

      bool reallocate(block &b, size_t n) noexcept
      {
        if (internal::is_reallocation_handled_default(*this, b, n)) {
          return true;
        }
        auto innerBlock = to_inner_block(b);

        // Remember the old Sufix in case that it is available, because it must
        // be later placed to the new position
        affix_helper::optinal_sufix_store<Sufix, sufix_size> oldSufix;
        oldSufix.store(outer_to_sufix(b));

        if (allocator_.reallocate(innerBlock, n + prefix_size + sufix_size)) {
          oldSufix.unload(inner_to_sufix(innerBlock));
          b = to_outer_block(innerBlock);
          return true;
        }
        return false;
      }

      template <typename U = Allocator>
      typename std::enable_if<traits::has_expand<U>::value, bool>::type
        expand(block &b, size_t delta) noexcept
      {
        if (delta == 0) {
          return true;
        }

        if (!b) {
          b = allocate(delta);
          return static_cast<bool>(b);
        }

        auto oldBlock = b;
        auto innerBlock = to_inner_block(b);

        if (allocator_.expand(innerBlock, delta)) {
          if (sufix_size > 0) {
            new (inner_to_sufix(innerBlock)) Sufix(*outer_to_sufix(oldBlock));
          }
          b = to_outer_block(innerBlock);
          return true;
        }
        return false;
      }
    };

    namespace traits {
      template <class Allocator, typename T> struct affix_extractor {
        static constexpr T *prefix(Allocator &, const block &) noexcept
        {
          return nullptr;
        }
        static constexpr T *sufix(Allocator &, const block &) noexcept
        {
          return nullptr;
        }
      };

      template <class A, typename Prefix, typename Sufix, typename T>
      struct affix_extractor<affix_allocator<A, Prefix, Sufix>, T> {
        static constexpr Prefix *prefix(affix_allocator<A, Prefix, Sufix> &allocator, const block &b) noexcept
        {
          return allocator.outer_to_prefix(b);
        }
        static constexpr Sufix *sufix(affix_allocator<A, Prefix, Sufix> &allocator, const block &b) noexcept
        {
          return allocator.outer_to_sufix(b);
        }
      };
    }
  }
  using namespace v_100;
}

#ifdef _MSC_VER
#pragma warning(pop)
#endif