segregator.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"

namespace alb {
  inline namespace v_100 {
    template <size_t Threshold, class SmallAllocator, class LargeAllocator>
    class segregator : private SmallAllocator, private LargeAllocator 
    {
      static_assert(!traits::both_same_base<SmallAllocator, LargeAllocator>::value,
        "Small- and Large-Allocator cannot be both of base!");

    public:
      using small_allocator = SmallAllocator;
      using large_allocator = LargeAllocator;

      static constexpr size_t threshold = Threshold;

      static constexpr bool supports_truncated_deallocation =
        SmallAllocator::supports_truncated_deallocation &&
        LargeAllocator::supports_truncated_deallocation;

      static constexpr unsigned alignment = 
        (SmallAllocator::alignment > LargeAllocator::alignment) ? 
          SmallAllocator::alignment : LargeAllocator::alignment;

      block allocate(size_t n) noexcept {
        block result;
        if (n <= Threshold) {
          result = SmallAllocator::allocate(n);

        }
        else {
          result = LargeAllocator::allocate(n);
        }
        
        return result;
      }

      void deallocate(block &b) noexcept {
        if (!b) {
          return;
        }

        if (b.length <= Threshold) {
          return SmallAllocator::deallocate(b);
        }
        return LargeAllocator::deallocate(b);
      }

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

        if (b.length <= Threshold) {
          if (n <= Threshold) {
            return SmallAllocator::reallocate(b, n);
          }
          return internal::reallocate_with_copy(*this, static_cast<LargeAllocator &>(*this), b, n);
        }

        if (n <= Threshold) {
          return internal::reallocate_with_copy(*this, static_cast<SmallAllocator &>(*this), b, n);
        }
        return LargeAllocator::reallocate(b, n);
      }

      template <typename U = SmallAllocator, typename V = LargeAllocator>
      typename std::enable_if<traits::has_expand<SmallAllocator>::value ||
        traits::has_expand<LargeAllocator>::value, bool>::type
        expand(block &b, size_t delta) noexcept {

        if (b.length <= Threshold && b.length + delta > Threshold) {
          return false;
        }
        if (b.length <= Threshold) {
          if (traits::has_expand<U>::value) {
            return traits::Expander<U>::do_it(static_cast<U&>(*this), b,
              delta);
          }
          return false;
        }
        if (traits::has_expand<V>::value) {
          return traits::Expander<V>::do_it(static_cast<V&>(*this), b,
            delta);
        }
        return false;
      }

      template <typename U = SmallAllocator, typename V = LargeAllocator>
      typename std::enable_if<traits::has_expand<SmallAllocator>::value ||
        traits::has_expand<LargeAllocator>::value, bool>::type
        owns(const block &b) const noexcept {

        if (b.length <= Threshold) {
          return U::owns(b);
        }
        return V::owns(b);
      }

      template <typename U = SmallAllocator, typename V = LargeAllocator>
      typename std::enable_if<traits::has_expand<SmallAllocator>::value ||
        traits::has_expand<LargeAllocator>::value, void>::type
        deallocate_all() noexcept {
        traits::AllDeallocator<U>::do_it(static_cast<U&>(*this));
        traits::AllDeallocator<V>::do_it(static_cast<V&>(*this));
      }
    };
  }
  using namespace v_100;
}