.. _program_listing_file__tmp_ws_src_apex_containers_apex_containers_include_apex_containers_memory_common.hpp:

Program Listing for File common.hpp
===================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_apex_containers_apex_containers_include_apex_containers_memory_common.hpp>` (``/tmp/ws/src/apex_containers/apex_containers/include/apex_containers/memory/common.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   // 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_