Program Listing for File common.hpp

↰ Return to documentation for file (/tmp/ws/src/apex_containers/apex_containers/include/apex_containers/memory/common.hpp)

// Copyright 2019 Apex.AI, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef APEX_CONTAINERS__MEMORY__COMMON_HPP_
#define APEX_CONTAINERS__MEMORY__COMMON_HPP_

#include <foonathan/memory/config.hpp>
#include <foonathan/memory/memory_pool.hpp>
#include <foonathan/memory/std_allocator.hpp>
#include <foonathan/memory/threading.hpp>

namespace foonathan
{
namespace memory
{
#include <foonathan/memory/detail/container_node_sizes.hpp>
}  // namespace memory
}  // namespace foonathan

#include <scoped_allocator>
#include <utility>

namespace apex
{
namespace containers
{
namespace memory
{
using storage_t = foonathan::memory::fixed_allocator_storage;
using default_mutex = foonathan::memory::default_mutex;
template<typename Container>
struct NodeSize;
}  // namespace memory
using node_pool_t = foonathan::memory::memory_pool<
  foonathan::memory::node_pool,
  foonathan::memory::static_block_allocator>;
template<typename Container>
class memory_pool
{
  static constexpr std::size_t node_size = memory::NodeSize<Container>::value;

public:
  using container = Container;
  explicit memory_pool(const std::size_t capacity)
  : storage_(2U * node_size, capacity),
    pool_(node_size, storage_.size(), storage_)
  {
  }

  operator node_pool_t &()
  {
    return pool_;
  }

  template<typename ... Args>
  decltype(auto) create(Args && ... args)
  {
    return container{std::forward<Args>(args)..., *this};
  }

private:
  memory::storage_t storage_;
  node_pool_t pool_;
};  // class memory_pool

template<typename T, typename Mutex = memory::default_mutex>
using node_allocator = foonathan::memory::std_allocator<T, node_pool_t, Mutex>;
template<typename T, typename Mutex = memory::default_mutex, typename ... InnerAlloc>
using scoped_node_allocator =
  std::scoped_allocator_adaptor<node_allocator<T, Mutex>, InnerAlloc...>;
}  // namespace containers
}  // namespace apex
#endif  // APEX_CONTAINERS__MEMORY__COMMON_HPP_