Arena.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 2019-20 CERN for the benefit of the LHCb and ATLAS collaborations   *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
#include <cstddef>
#include <functional>
#include <type_traits>
namespace Gaudi::Allocator {
  template <typename Resource, typename T, typename DefaultResource = void>
  struct Arena {
    using value_type                             = T;
    using propagate_on_container_swap            = std::true_type;
    using propagate_on_container_copy_assignment = std::true_type;
    using propagate_on_container_move_assignment = std::true_type;
 
    constexpr Arena( Resource* resource ) noexcept : m_resource{ resource } {}
 
    template <typename D = void>
      requires( std::is_invocable_r_v<Resource*, DefaultResource> )
    Arena() : Arena( std::invoke( DefaultResource{} ) ) {}
 
    template <typename U>
    constexpr Arena( Arena<Resource, U, DefaultResource> const& other ) noexcept : m_resource{ other.m_resource } {}
 
    [[nodiscard]] T* allocate( std::size_t n ) {
      return reinterpret_cast<T*>( m_resource->template allocate<alignof( T )>( n * sizeof( T ) ) );
    }
 
    void deallocate( T* p, std::size_t n ) noexcept {
      m_resource->deallocate( reinterpret_cast<std::byte*>( p ), n * sizeof( T ) );
    }
 
    [[nodiscard]] Resource* resource() const noexcept { return m_resource; }
 
    template <typename U>
    friend constexpr bool operator==( Arena const& lhs, Arena<Resource, U, DefaultResource> const& rhs ) {
      return lhs.m_resource == rhs.m_resource;
    }
 
    template <typename U>
    struct rebind {
      using other = Arena<Resource, U, DefaultResource>;
    };
 
  private:
    // Required for the Arena<Resource, U, DefaultResource> converting copy constructor
    template <typename, typename, typename>
    friend struct Arena;
 
    Resource* m_resource{ nullptr };
  };
 
  template <typename Resource, typename T, typename U, typename DefaultResource>
  inline constexpr bool operator!=( Arena<Resource, T, DefaultResource> const& lhs,
                                    Arena<Resource, U, DefaultResource> const& rhs ) {
    return !( lhs == rhs );
  }
} // namespace Gaudi::Allocator