
// Copyright 2006-2011 Daniel James.
// Copyright 2022 Christian Mazakas
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#if !defined(BOOST_UNORDERED_TEST_CXX11_ALLOCATOR_HEADER)
#define BOOST_UNORDERED_TEST_CXX11_ALLOCATOR_HEADER

#include <boost/config.hpp>
#include <boost/limits.hpp>
#include <cstddef>

#include "../helpers/fwd.hpp"
#include "../helpers/memory.hpp"

namespace test
{
  struct allocator_false
  {
    enum
    {
      is_select_on_copy = 0,
      is_propagate_on_swap = 0,
      is_propagate_on_assign = 0,
      is_propagate_on_move = 0,
      cxx11_construct = 0
    };
  };

  struct allocator_flags_all
  {
    enum
    {
      is_select_on_copy = 1,
      is_propagate_on_swap = 1,
      is_propagate_on_assign = 1,
      is_propagate_on_move = 1,
      cxx11_construct = 1
    };
  };

  struct select_copy : allocator_false
  {
    enum
    {
      is_select_on_copy = 1
    };
  };
  struct propagate_swap : allocator_false
  {
    enum
    {
      is_propagate_on_swap = 1
    };
  };
  struct propagate_assign : allocator_false
  {
    enum
    {
      is_propagate_on_assign = 1
    };
  };
  struct propagate_move : allocator_false
  {
    enum
    {
      is_propagate_on_move = 1
    };
  };

  struct no_select_copy : allocator_flags_all
  {
    enum
    {
      is_select_on_copy = 0
    };
  };
  struct no_propagate_swap : allocator_flags_all
  {
    enum
    {
      is_propagate_on_swap = 0
    };
  };
  struct no_propagate_assign : allocator_flags_all
  {
    enum
    {
      is_propagate_on_assign = 0
    };
  };
  struct no_propagate_move : allocator_flags_all
  {
    enum
    {
      is_propagate_on_move = 0
    };
  };

  template <typename Flag> struct swap_allocator_base
  {
    struct propagate_on_container_swap
    {
      enum
      {
        value = Flag::is_propagate_on_swap
      };
    };
  };

  template <typename Flag> struct assign_allocator_base
  {
    struct propagate_on_container_copy_assignment
    {
      enum
      {
        value = Flag::is_propagate_on_assign
      };
    };
  };

  template <typename Flag> struct move_allocator_base
  {
    struct propagate_on_container_move_assignment
    {
      enum
      {
        value = Flag::is_propagate_on_move
      };
    };
  };

  namespace {
    // boostinspect:nounnamed
    bool force_equal_allocator_value = false;
  }

  struct force_equal_allocator
  {
    bool old_value_;

    explicit force_equal_allocator(bool value)
        : old_value_(force_equal_allocator_value)
    {
      force_equal_allocator_value = value;
    }

    ~force_equal_allocator() { force_equal_allocator_value = old_value_; }
  };

  template <typename T> struct cxx11_allocator_base
  {
    int tag_;
    int selected_;

    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;
    typedef T* pointer;
    typedef T const* const_pointer;
    typedef T& reference;
    typedef T const& const_reference;
    typedef T value_type;

    explicit cxx11_allocator_base(int t) : tag_(t), selected_(0)
    {
      detail::tracker.allocator_ref();
    }

    template <typename Y>
    cxx11_allocator_base(cxx11_allocator_base<Y> const& x)
        : tag_(x.tag_), selected_(x.selected_)
    {
      detail::tracker.allocator_ref();
    }

    cxx11_allocator_base(cxx11_allocator_base const& x)
        : tag_(x.tag_), selected_(x.selected_)
    {
      detail::tracker.allocator_ref();
    }

    ~cxx11_allocator_base() { detail::tracker.allocator_unref(); }

    cxx11_allocator_base& operator=(cxx11_allocator_base const& x) = default;

    pointer address(reference r) { return pointer(&r); }

    const_pointer address(const_reference r) { return const_pointer(&r); }

    pointer allocate(size_type n)
    {
      pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
      detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
      return ptr;
    }

    pointer allocate(size_type n, void const*)
    {
      pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
      detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
      return ptr;
    }

    void deallocate(pointer p, size_type n)
    {
      // Only checking tags when propagating swap.
      // Note that tags will be tested
      // properly in the normal allocator.
      detail::tracker.track_deallocate(
        (void*)p, n, sizeof(T), tag_, !force_equal_allocator_value);
      ::operator delete((void*)p);
    }

    template <class U, typename... Args>
    void construct(U* p, Args&&... args)
    {
      detail::tracker.track_construct((void*)p, sizeof(U), tag_);
      new (p) U(std::forward<Args>(args)...);
    }

    template <class U>
    void destroy(U* p)
    {
      detail::tracker.track_destroy((void*)p, sizeof(U), tag_);
      p->~U();
    }

    size_type max_size() const
    {
      return (std::numeric_limits<size_type>::max)();
    }
  };

  template <typename T, typename Flags = propagate_swap, typename Enable = void>
  struct cxx11_allocator;

  template <typename T, typename Flags>
  struct cxx11_allocator<T, Flags,
    typename boost::disable_if_c<Flags::is_select_on_copy>::type>
    : public cxx11_allocator_base<T>,
      public swap_allocator_base<Flags>,
      public assign_allocator_base<Flags>,
      public move_allocator_base<Flags>,
      Flags
  {
#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 402000)
    template <typename U> struct rebind
    {
      typedef cxx11_allocator<U, Flags> other;
    };
#endif

    explicit cxx11_allocator(int t = 0) : cxx11_allocator_base<T>(t) {}

    template <typename Y>
    cxx11_allocator(cxx11_allocator<Y, Flags> const& x)
        : cxx11_allocator_base<T>(x)
    {
    }

    cxx11_allocator(cxx11_allocator const& x) : cxx11_allocator_base<T>(x) {}

    cxx11_allocator& operator=(cxx11_allocator const& x) = default;

    // When not propagating swap, allocators are always equal
    // to avoid undefined behaviour.
    bool operator==(cxx11_allocator const& x) const
    {
      return force_equal_allocator_value || (this->tag_ == x.tag_);
    }

    bool operator!=(cxx11_allocator const& x) const { return !(*this == x); }
  };

  template <typename T, typename Flags>
  struct cxx11_allocator<T, Flags,
    typename boost::enable_if_c<Flags::is_select_on_copy>::type>
    : public cxx11_allocator_base<T>,
      public swap_allocator_base<Flags>,
      public assign_allocator_base<Flags>,
      public move_allocator_base<Flags>,
      Flags
  {
    cxx11_allocator select_on_container_copy_construction() const
    {
      cxx11_allocator tmp(*this);
      ++tmp.selected_;
      return tmp;
    }

#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 402000)
    template <typename U> struct rebind
    {
      typedef cxx11_allocator<U, Flags> other;
    };
#endif

    explicit cxx11_allocator(int t = 0) : cxx11_allocator_base<T>(t) {}

    template <typename Y>
    cxx11_allocator(cxx11_allocator<Y, Flags> const& x)
        : cxx11_allocator_base<T>(x)
    {
    }

    cxx11_allocator(cxx11_allocator const& x) : cxx11_allocator_base<T>(x) {}

    cxx11_allocator& operator=(cxx11_allocator const& x) = default;

    // When not propagating swap, allocators are always equal
    // to avoid undefined behaviour.
    bool operator==(cxx11_allocator const& x) const
    {
      return force_equal_allocator_value || (this->tag_ == x.tag_);
    }

    bool operator!=(cxx11_allocator const& x) const { return !(*this == x); }
  };

  template <typename T, typename Flags>
  bool equivalent_impl(cxx11_allocator<T, Flags> const& x,
    cxx11_allocator<T, Flags> const& y, test::derived_type)
  {
    return x.tag_ == y.tag_;
  }

  // Function to check how many times an allocator has been selected,
  // return 0 for other allocators.

  struct convert_from_anything
  {
    template <typename T> convert_from_anything(T const&) {}
  };

  inline int selected_count(convert_from_anything) { return 0; }

  template <typename T, typename Flags>
  int selected_count(cxx11_allocator<T, Flags> const& x)
  {
    return x.selected_;
  }
}

#endif
