From dada51675497283637b58bdcd46919712d0f5b01 Mon Sep 17 00:00:00 2001 From: Fcitx5 Android Bot <102923727+fcitx5-android-bot@users.noreply.github.com> Date: Fri, 22 Nov 2024 18:00:41 +0000 Subject: [PATCH] Auto update --- .../boost_beast-targets.cmake | 2 +- .../boost_container-config-version.cmake | 77 + .../boost_container-config.cmake | 22 + .../boost_container-targets-release.cmake | 19 + .../boost_container-targets.cmake | 116 + .../boost_geometry-targets.cmake | 2 +- .../boost_icl-1.86.0/boost_icl-targets.cmake | 2 +- .../boost_interprocess-targets.cmake | 2 +- .../boost_lexical_cast-targets.cmake | 2 +- boost/arm64-v8a/lib/libboost_container.a | Bin 0 -> 190026 bytes .../boost_beast-targets.cmake | 2 +- .../boost_container-config-version.cmake | 77 + .../boost_container-config.cmake | 22 + .../boost_container-targets-release.cmake | 19 + .../boost_container-targets.cmake | 116 + .../boost_geometry-targets.cmake | 2 +- .../boost_icl-1.86.0/boost_icl-targets.cmake | 2 +- .../boost_interprocess-targets.cmake | 2 +- .../boost_lexical_cast-targets.cmake | 2 +- boost/armeabi-v7a/lib/libboost_container.a | Bin 0 -> 153738 bytes .../include/boost/container/adaptive_pool.hpp | 622 +++ boost/include/boost/container/allocator.hpp | 376 ++ .../boost/container/allocator_traits.hpp | 641 +++ .../include/boost/container/container_fwd.hpp | 390 ++ boost/include/boost/container/deque.hpp | 2883 +++++++++++++ .../container/detail/adaptive_node_pool.hpp | 169 + .../detail/adaptive_node_pool_impl.hpp | 1260 ++++++ .../boost/container/detail/addressof.hpp | 33 + .../container/detail/advanced_insert_int.hpp | 543 +++ .../boost/container/detail/algorithm.hpp | 185 + .../boost/container/detail/alloc_helpers.hpp | 60 + .../boost/container/detail/alloc_lib.h | 314 ++ .../container/detail/allocation_type.hpp | 58 + .../detail/allocator_version_traits.hpp | 162 + .../boost/container/detail/auto_link.hpp | 51 + .../boost/container/detail/block_list.hpp | 140 + .../boost/container/detail/block_slist.hpp | 158 + .../container/detail/compare_functors.hpp | 134 + .../boost/container/detail/config_begin.hpp | 61 + .../boost/container/detail/config_end.hpp | 16 + .../container/detail/construct_in_place.hpp | 132 + .../detail/container_or_allocator_rebind.hpp | 53 + .../container/detail/container_rebind.hpp | 163 + .../boost/container/detail/copy_move_algo.hpp | 1987 +++++++++ .../boost/container/detail/destroyers.hpp | 502 +++ .../detail/dispatch_uses_allocator.hpp | 461 +++ .../boost/container/detail/dlmalloc.hpp | 103 + .../boost/container/detail/flat_tree.hpp | 1743 ++++++++ .../container/detail/function_detector.hpp | 96 + .../boost/container/detail/guards_dended.hpp | 198 + .../boost/container/detail/is_container.hpp | 72 + .../detail/is_contiguous_container.hpp | 82 + .../boost/container/detail/is_pair.hpp | 91 + .../boost/container/detail/is_sorted.hpp | 57 + .../boost/container/detail/iterator.hpp | 94 + .../detail/iterator_to_raw_pointer.hpp | 33 + .../boost/container/detail/iterators.hpp | 909 +++++ .../boost/container/detail/math_functions.hpp | 176 + .../boost/container/detail/min_max.hpp | 37 + .../detail/minimal_char_traits_header.hpp | 32 + boost/include/boost/container/detail/mpl.hpp | 144 + .../detail/multiallocation_chain.hpp | 393 ++ .../include/boost/container/detail/mutex.hpp | 308 ++ .../boost/container/detail/next_capacity.hpp | 96 + .../container/detail/node_alloc_holder.hpp | 619 +++ .../boost/container/detail/node_pool.hpp | 157 + .../boost/container/detail/node_pool_impl.hpp | 375 ++ boost/include/boost/container/detail/pair.hpp | 606 +++ .../detail/pair_key_mapped_of_value.hpp | 55 + .../boost/container/detail/placement_new.hpp | 24 + .../boost/container/detail/pool_common.hpp | 57 + .../container/detail/pool_common_alloc.hpp | 102 + .../boost/container/detail/pool_resource.hpp | 187 + .../boost/container/detail/singleton.hpp | 121 + .../boost/container/detail/std_fwd.hpp | 62 + .../boost/container/detail/thread_mutex.hpp | 181 + .../container/detail/transform_iterator.hpp | 180 + boost/include/boost/container/detail/tree.hpp | 1471 +++++++ .../boost/container/detail/type_traits.hpp | 75 + .../boost/container/detail/value_functors.hpp | 32 + .../boost/container/detail/value_init.hpp | 51 + .../detail/variadic_templates_tools.hpp | 163 + .../boost/container/detail/version_type.hpp | 101 + .../boost/container/detail/workaround.hpp | 245 ++ boost/include/boost/container/devector.hpp | 3041 ++++++++++++++ boost/include/boost/container/flat_map.hpp | 3150 +++++++++++++++ boost/include/boost/container/flat_set.hpp | 1946 +++++++++ boost/include/boost/container/list.hpp | 1519 +++++++ boost/include/boost/container/map.hpp | 2330 +++++++++++ .../include/boost/container/new_allocator.hpp | 199 + .../boost/container/node_allocator.hpp | 347 ++ boost/include/boost/container/node_handle.hpp | 456 +++ boost/include/boost/container/options.hpp | 671 +++ boost/include/boost/container/pmr/deque.hpp | 45 + .../include/boost/container/pmr/devector.hpp | 51 + .../include/boost/container/pmr/flat_map.hpp | 63 + .../include/boost/container/pmr/flat_set.hpp | 59 + .../boost/container/pmr/global_resource.hpp | 63 + boost/include/boost/container/pmr/list.hpp | 45 + boost/include/boost/container/pmr/map.hpp | 67 + .../boost/container/pmr/memory_resource.hpp | 135 + .../pmr/monotonic_buffer_resource.hpp | 183 + .../container/pmr/polymorphic_allocator.hpp | 166 + .../boost/container/pmr/pool_options.hpp | 52 + .../boost/container/pmr/resource_adaptor.hpp | 277 ++ boost/include/boost/container/pmr/set.hpp | 63 + boost/include/boost/container/pmr/slist.hpp | 45 + .../boost/container/pmr/small_vector.hpp | 45 + .../boost/container/pmr/stable_vector.hpp | 45 + boost/include/boost/container/pmr/string.hpp | 50 + .../pmr/synchronized_pool_resource.hpp | 139 + .../pmr/unsynchronized_pool_resource.hpp | 194 + boost/include/boost/container/pmr/vector.hpp | 45 + .../boost/container/scoped_allocator.hpp | 905 +++++ .../boost/container/scoped_allocator_fwd.hpp | 71 + boost/include/boost/container/set.hpp | 1695 ++++++++ boost/include/boost/container/slist.hpp | 1731 ++++++++ .../include/boost/container/small_vector.hpp | 693 ++++ .../include/boost/container/stable_vector.hpp | 2270 +++++++++++ .../include/boost/container/static_vector.hpp | 1324 ++++++ boost/include/boost/container/string.hpp | 3593 +++++++++++++++++ .../boost/container/throw_exception.hpp | 295 ++ .../boost/container/uses_allocator.hpp | 169 + .../boost/container/uses_allocator_fwd.hpp | 73 + boost/include/boost/container/vector.hpp | 3337 +++++++++++++++ .../boost_beast-targets.cmake | 2 +- .../boost_container-config-version.cmake | 77 + .../boost_container-config.cmake | 22 + .../boost_container-targets-release.cmake | 19 + .../boost_container-targets.cmake | 116 + .../boost_geometry-targets.cmake | 2 +- .../boost_icl-1.86.0/boost_icl-targets.cmake | 2 +- .../boost_interprocess-targets.cmake | 2 +- .../boost_lexical_cast-targets.cmake | 2 +- boost/x86/lib/libboost_container.a | Bin 0 -> 137894 bytes .../boost_beast-targets.cmake | 2 +- .../boost_container-config-version.cmake | 77 + .../boost_container-config.cmake | 22 + .../boost_container-targets-release.cmake | 19 + .../boost_container-targets.cmake | 116 + .../boost_geometry-targets.cmake | 2 +- .../boost_icl-1.86.0/boost_icl-targets.cmake | 2 +- .../boost_interprocess-targets.cmake | 2 +- .../boost_lexical_cast-targets.cmake | 2 +- boost/x86_64/lib/libboost_container.a | Bin 0 -> 171498 bytes toolchain-versions.json | 2 +- 146 files changed, 53686 insertions(+), 21 deletions(-) create mode 100644 boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-config-version.cmake create mode 100644 boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-config.cmake create mode 100644 boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-targets-release.cmake create mode 100644 boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-targets.cmake create mode 100644 boost/arm64-v8a/lib/libboost_container.a create mode 100644 boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-config-version.cmake create mode 100644 boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-config.cmake create mode 100644 boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-targets-release.cmake create mode 100644 boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-targets.cmake create mode 100644 boost/armeabi-v7a/lib/libboost_container.a create mode 100644 boost/include/boost/container/adaptive_pool.hpp create mode 100644 boost/include/boost/container/allocator.hpp create mode 100644 boost/include/boost/container/allocator_traits.hpp create mode 100644 boost/include/boost/container/container_fwd.hpp create mode 100644 boost/include/boost/container/deque.hpp create mode 100644 boost/include/boost/container/detail/adaptive_node_pool.hpp create mode 100644 boost/include/boost/container/detail/adaptive_node_pool_impl.hpp create mode 100644 boost/include/boost/container/detail/addressof.hpp create mode 100644 boost/include/boost/container/detail/advanced_insert_int.hpp create mode 100644 boost/include/boost/container/detail/algorithm.hpp create mode 100644 boost/include/boost/container/detail/alloc_helpers.hpp create mode 100644 boost/include/boost/container/detail/alloc_lib.h create mode 100644 boost/include/boost/container/detail/allocation_type.hpp create mode 100644 boost/include/boost/container/detail/allocator_version_traits.hpp create mode 100644 boost/include/boost/container/detail/auto_link.hpp create mode 100644 boost/include/boost/container/detail/block_list.hpp create mode 100644 boost/include/boost/container/detail/block_slist.hpp create mode 100644 boost/include/boost/container/detail/compare_functors.hpp create mode 100644 boost/include/boost/container/detail/config_begin.hpp create mode 100644 boost/include/boost/container/detail/config_end.hpp create mode 100644 boost/include/boost/container/detail/construct_in_place.hpp create mode 100644 boost/include/boost/container/detail/container_or_allocator_rebind.hpp create mode 100644 boost/include/boost/container/detail/container_rebind.hpp create mode 100644 boost/include/boost/container/detail/copy_move_algo.hpp create mode 100644 boost/include/boost/container/detail/destroyers.hpp create mode 100644 boost/include/boost/container/detail/dispatch_uses_allocator.hpp create mode 100644 boost/include/boost/container/detail/dlmalloc.hpp create mode 100644 boost/include/boost/container/detail/flat_tree.hpp create mode 100644 boost/include/boost/container/detail/function_detector.hpp create mode 100644 boost/include/boost/container/detail/guards_dended.hpp create mode 100644 boost/include/boost/container/detail/is_container.hpp create mode 100644 boost/include/boost/container/detail/is_contiguous_container.hpp create mode 100644 boost/include/boost/container/detail/is_pair.hpp create mode 100644 boost/include/boost/container/detail/is_sorted.hpp create mode 100644 boost/include/boost/container/detail/iterator.hpp create mode 100644 boost/include/boost/container/detail/iterator_to_raw_pointer.hpp create mode 100644 boost/include/boost/container/detail/iterators.hpp create mode 100644 boost/include/boost/container/detail/math_functions.hpp create mode 100644 boost/include/boost/container/detail/min_max.hpp create mode 100644 boost/include/boost/container/detail/minimal_char_traits_header.hpp create mode 100644 boost/include/boost/container/detail/mpl.hpp create mode 100644 boost/include/boost/container/detail/multiallocation_chain.hpp create mode 100644 boost/include/boost/container/detail/mutex.hpp create mode 100644 boost/include/boost/container/detail/next_capacity.hpp create mode 100644 boost/include/boost/container/detail/node_alloc_holder.hpp create mode 100644 boost/include/boost/container/detail/node_pool.hpp create mode 100644 boost/include/boost/container/detail/node_pool_impl.hpp create mode 100644 boost/include/boost/container/detail/pair.hpp create mode 100644 boost/include/boost/container/detail/pair_key_mapped_of_value.hpp create mode 100644 boost/include/boost/container/detail/placement_new.hpp create mode 100644 boost/include/boost/container/detail/pool_common.hpp create mode 100644 boost/include/boost/container/detail/pool_common_alloc.hpp create mode 100644 boost/include/boost/container/detail/pool_resource.hpp create mode 100644 boost/include/boost/container/detail/singleton.hpp create mode 100644 boost/include/boost/container/detail/std_fwd.hpp create mode 100644 boost/include/boost/container/detail/thread_mutex.hpp create mode 100644 boost/include/boost/container/detail/transform_iterator.hpp create mode 100644 boost/include/boost/container/detail/tree.hpp create mode 100644 boost/include/boost/container/detail/type_traits.hpp create mode 100644 boost/include/boost/container/detail/value_functors.hpp create mode 100644 boost/include/boost/container/detail/value_init.hpp create mode 100644 boost/include/boost/container/detail/variadic_templates_tools.hpp create mode 100644 boost/include/boost/container/detail/version_type.hpp create mode 100644 boost/include/boost/container/detail/workaround.hpp create mode 100644 boost/include/boost/container/devector.hpp create mode 100644 boost/include/boost/container/flat_map.hpp create mode 100644 boost/include/boost/container/flat_set.hpp create mode 100644 boost/include/boost/container/list.hpp create mode 100644 boost/include/boost/container/map.hpp create mode 100644 boost/include/boost/container/new_allocator.hpp create mode 100644 boost/include/boost/container/node_allocator.hpp create mode 100644 boost/include/boost/container/node_handle.hpp create mode 100644 boost/include/boost/container/options.hpp create mode 100644 boost/include/boost/container/pmr/deque.hpp create mode 100644 boost/include/boost/container/pmr/devector.hpp create mode 100644 boost/include/boost/container/pmr/flat_map.hpp create mode 100644 boost/include/boost/container/pmr/flat_set.hpp create mode 100644 boost/include/boost/container/pmr/global_resource.hpp create mode 100644 boost/include/boost/container/pmr/list.hpp create mode 100644 boost/include/boost/container/pmr/map.hpp create mode 100644 boost/include/boost/container/pmr/memory_resource.hpp create mode 100644 boost/include/boost/container/pmr/monotonic_buffer_resource.hpp create mode 100644 boost/include/boost/container/pmr/polymorphic_allocator.hpp create mode 100644 boost/include/boost/container/pmr/pool_options.hpp create mode 100644 boost/include/boost/container/pmr/resource_adaptor.hpp create mode 100644 boost/include/boost/container/pmr/set.hpp create mode 100644 boost/include/boost/container/pmr/slist.hpp create mode 100644 boost/include/boost/container/pmr/small_vector.hpp create mode 100644 boost/include/boost/container/pmr/stable_vector.hpp create mode 100644 boost/include/boost/container/pmr/string.hpp create mode 100644 boost/include/boost/container/pmr/synchronized_pool_resource.hpp create mode 100644 boost/include/boost/container/pmr/unsynchronized_pool_resource.hpp create mode 100644 boost/include/boost/container/pmr/vector.hpp create mode 100644 boost/include/boost/container/scoped_allocator.hpp create mode 100644 boost/include/boost/container/scoped_allocator_fwd.hpp create mode 100644 boost/include/boost/container/set.hpp create mode 100644 boost/include/boost/container/slist.hpp create mode 100644 boost/include/boost/container/small_vector.hpp create mode 100644 boost/include/boost/container/stable_vector.hpp create mode 100644 boost/include/boost/container/static_vector.hpp create mode 100644 boost/include/boost/container/string.hpp create mode 100644 boost/include/boost/container/throw_exception.hpp create mode 100644 boost/include/boost/container/uses_allocator.hpp create mode 100644 boost/include/boost/container/uses_allocator_fwd.hpp create mode 100644 boost/include/boost/container/vector.hpp create mode 100644 boost/x86/lib/cmake/boost_container-1.86.0-static/boost_container-config-version.cmake create mode 100644 boost/x86/lib/cmake/boost_container-1.86.0-static/boost_container-config.cmake create mode 100644 boost/x86/lib/cmake/boost_container-1.86.0-static/boost_container-targets-release.cmake create mode 100644 boost/x86/lib/cmake/boost_container-1.86.0-static/boost_container-targets.cmake create mode 100644 boost/x86/lib/libboost_container.a create mode 100644 boost/x86_64/lib/cmake/boost_container-1.86.0-static/boost_container-config-version.cmake create mode 100644 boost/x86_64/lib/cmake/boost_container-1.86.0-static/boost_container-config.cmake create mode 100644 boost/x86_64/lib/cmake/boost_container-1.86.0-static/boost_container-targets-release.cmake create mode 100644 boost/x86_64/lib/cmake/boost_container-1.86.0-static/boost_container-targets.cmake create mode 100644 boost/x86_64/lib/libboost_container.a diff --git a/boost/arm64-v8a/lib/cmake/boost_beast-1.86.0/boost_beast-targets.cmake b/boost/arm64-v8a/lib/cmake/boost_beast-1.86.0/boost_beast-targets.cmake index 7d494f0f..3c0f7d38 100644 --- a/boost/arm64-v8a/lib/cmake/boost_beast-1.86.0/boost_beast-targets.cmake +++ b/boost/arm64-v8a/lib/cmake/boost_beast-1.86.0/boost_beast-targets.cmake @@ -95,7 +95,7 @@ unset(_IMPORT_CHECK_TARGETS) # Make sure the targets which have been exported in some other # export set exist. unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) -foreach(_target "Boost::asio" "Boost::assert" "Boost::bind" "Boost::config" "Boost::core" "Boost::endian" "Boost::intrusive" "Boost::logic" "Boost::mp11" "Boost::optional" "Boost::smart_ptr" "Boost::static_assert" "Boost::static_string" "Boost::system" "Boost::throw_exception" "Boost::type_traits" "Boost::utility" "Boost::winapi" ) +foreach(_target "Boost::asio" "Boost::assert" "Boost::bind" "Boost::config" "Boost::container" "Boost::core" "Boost::endian" "Boost::intrusive" "Boost::logic" "Boost::mp11" "Boost::optional" "Boost::smart_ptr" "Boost::static_assert" "Boost::static_string" "Boost::system" "Boost::throw_exception" "Boost::type_traits" "Boost::utility" "Boost::winapi" ) if(NOT TARGET "${_target}" ) set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") endif() diff --git a/boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-config-version.cmake b/boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-config-version.cmake new file mode 100644 index 00000000..20807a5a --- /dev/null +++ b/boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-config-version.cmake @@ -0,0 +1,77 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version, +# but only if the requested major version is the same as the current one. +# The variable CVF_VERSION must be set before calling configure_file(). + + +set(PACKAGE_VERSION "1.86.0") + +if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) +else() + + if("1.86.0" MATCHES "^([0-9]+)\\.") + set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") + if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}") + endif() + else() + set(CVF_VERSION_MAJOR "1.86.0") + endif() + + if(PACKAGE_FIND_VERSION_RANGE) + # both endpoints of the range must have the expected major version + math (EXPR CVF_VERSION_MAJOR_NEXT "${CVF_VERSION_MAJOR} + 1") + if (NOT PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL CVF_VERSION_MAJOR_NEXT))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR + AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE TRUE) + else() + set(PACKAGE_VERSION_COMPATIBLE FALSE) + endif() + else() + if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR) + set(PACKAGE_VERSION_COMPATIBLE TRUE) + else() + set(PACKAGE_VERSION_COMPATIBLE FALSE) + endif() + + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed project requested no architecture check, don't perform the check +if("FALSE") + return() +endif() + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() + +# Do not return static libraries when Boost_USE_STATIC_LIBS is OFF +if(NOT PACKAGE_VERSION_UNSUITABLE AND DEFINED Boost_USE_STATIC_LIBS AND NOT Boost_USE_STATIC_LIBS) + set(PACKAGE_VERSION_UNSUITABLE TRUE) + set(PACKAGE_VERSION "${PACKAGE_VERSION} (static)") + return() +endif() diff --git a/boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-config.cmake b/boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-config.cmake new file mode 100644 index 00000000..d3bc2f1e --- /dev/null +++ b/boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-config.cmake @@ -0,0 +1,22 @@ +# Generated by BoostInstall.cmake for boost_container-1.86.0 + +if(Boost_VERBOSE OR Boost_DEBUG) + message(STATUS "Found boost_container ${boost_container_VERSION} at ${boost_container_DIR}") +endif() + +include(CMakeFindDependencyMacro) + +if(NOT boost_assert_FOUND) + find_dependency(boost_assert 1.86.0 EXACT HINTS "${CMAKE_CURRENT_LIST_DIR}/..") +endif() +if(NOT boost_config_FOUND) + find_dependency(boost_config 1.86.0 EXACT HINTS "${CMAKE_CURRENT_LIST_DIR}/..") +endif() +if(NOT boost_intrusive_FOUND) + find_dependency(boost_intrusive 1.86.0 EXACT HINTS "${CMAKE_CURRENT_LIST_DIR}/..") +endif() +if(NOT boost_move_FOUND) + find_dependency(boost_move 1.86.0 EXACT HINTS "${CMAKE_CURRENT_LIST_DIR}/..") +endif() + +include("${CMAKE_CURRENT_LIST_DIR}/boost_container-targets.cmake") diff --git a/boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-targets-release.cmake b/boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-targets-release.cmake new file mode 100644 index 00000000..e4629156 --- /dev/null +++ b/boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-targets-release.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Release". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Boost::container" for configuration "Release" +set_property(TARGET Boost::container APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) +set_target_properties(Boost::container PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C;CXX" + IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/libboost_container.a" + ) + +list(APPEND _IMPORT_CHECK_TARGETS Boost::container ) +list(APPEND _IMPORT_CHECK_FILES_FOR_Boost::container "${_IMPORT_PREFIX}/lib/libboost_container.a" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-targets.cmake b/boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-targets.cmake new file mode 100644 index 00000000..7e664082 --- /dev/null +++ b/boost/arm64-v8a/lib/cmake/boost_container-1.86.0-static/boost_container-targets.cmake @@ -0,0 +1,116 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.6) + message(FATAL_ERROR "CMake >= 2.6.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 2.6...3.20) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_targetsDefined) +set(_targetsNotDefined) +set(_expectedTargets) +foreach(_expectedTarget Boost::container) + list(APPEND _expectedTargets ${_expectedTarget}) + if(NOT TARGET ${_expectedTarget}) + list(APPEND _targetsNotDefined ${_expectedTarget}) + endif() + if(TARGET ${_expectedTarget}) + list(APPEND _targetsDefined ${_expectedTarget}) + endif() +endforeach() +if("${_targetsDefined}" STREQUAL "${_expectedTargets}") + unset(_targetsDefined) + unset(_targetsNotDefined) + unset(_expectedTargets) + set(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT "${_targetsDefined}" STREQUAL "") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_targetsDefined}\nTargets not yet defined: ${_targetsNotDefined}\n") +endif() +unset(_targetsDefined) +unset(_targetsNotDefined) +unset(_expectedTargets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Boost::container +add_library(Boost::container STATIC IMPORTED) + +set_target_properties(Boost::container PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "BOOST_CONTAINER_NO_LIB;BOOST_CONTAINER_STATIC_LINK" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Boost::assert;Boost::config;Boost::intrusive;Boost::move" +) + +if(CMAKE_VERSION VERSION_LESS 2.8.12) + message(FATAL_ERROR "This file relies on consumers using CMake 2.8.12 or greater.") +endif() + +# Load information for each installed configuration. +get_filename_component(_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) +file(GLOB CONFIG_FILES "${_DIR}/boost_container-targets-*.cmake") +foreach(f ${CONFIG_FILES}) + include(${f}) +endforeach() + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(target ${_IMPORT_CHECK_TARGETS} ) + foreach(file ${_IMPORT_CHECK_FILES_FOR_${target}} ) + if(NOT EXISTS "${file}" ) + message(FATAL_ERROR "The imported target \"${target}\" references the file + \"${file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + unset(_IMPORT_CHECK_FILES_FOR_${target}) +endforeach() +unset(_IMPORT_CHECK_TARGETS) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Boost::assert" "Boost::config" "Boost::intrusive" "Boost::move" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/boost/arm64-v8a/lib/cmake/boost_geometry-1.86.0/boost_geometry-targets.cmake b/boost/arm64-v8a/lib/cmake/boost_geometry-1.86.0/boost_geometry-targets.cmake index 807e6052..d2fd0f90 100644 --- a/boost/arm64-v8a/lib/cmake/boost_geometry-1.86.0/boost_geometry-targets.cmake +++ b/boost/arm64-v8a/lib/cmake/boost_geometry-1.86.0/boost_geometry-targets.cmake @@ -95,7 +95,7 @@ unset(_IMPORT_CHECK_TARGETS) # Make sure the targets which have been exported in some other # export set exist. unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) -foreach(_target "Boost::algorithm" "Boost::any" "Boost::array" "Boost::assert" "Boost::concept_check" "Boost::config" "Boost::core" "Boost::function_types" "Boost::iterator" "Boost::lexical_cast" "Boost::move" "Boost::mpl" "Boost::multiprecision" "Boost::numeric_conversion" "Boost::qvm" "Boost::range" "Boost::rational" "Boost::static_assert" "Boost::throw_exception" "Boost::tokenizer" "Boost::tuple" "Boost::type_traits" "Boost::utility" "Boost::variant" ) +foreach(_target "Boost::algorithm" "Boost::any" "Boost::array" "Boost::assert" "Boost::concept_check" "Boost::config" "Boost::core" "Boost::function_types" "Boost::iterator" "Boost::lexical_cast" "Boost::move" "Boost::mpl" "Boost::multiprecision" "Boost::numeric_conversion" "Boost::qvm" "Boost::range" "Boost::rational" "Boost::static_assert" "Boost::throw_exception" "Boost::tokenizer" "Boost::tuple" "Boost::type_traits" "Boost::utility" "Boost::variant" "Boost::container" ) if(NOT TARGET "${_target}" ) set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") endif() diff --git a/boost/arm64-v8a/lib/cmake/boost_icl-1.86.0/boost_icl-targets.cmake b/boost/arm64-v8a/lib/cmake/boost_icl-1.86.0/boost_icl-targets.cmake index 2c2dd109..5f7204dd 100644 --- a/boost/arm64-v8a/lib/cmake/boost_icl-1.86.0/boost_icl-targets.cmake +++ b/boost/arm64-v8a/lib/cmake/boost_icl-1.86.0/boost_icl-targets.cmake @@ -94,7 +94,7 @@ unset(_IMPORT_CHECK_TARGETS) # Make sure the targets which have been exported in some other # export set exist. unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) -foreach(_target "Boost::assert" "Boost::concept_check" "Boost::config" "Boost::core" "Boost::detail" "Boost::iterator" "Boost::move" "Boost::mpl" "Boost::range" "Boost::rational" "Boost::static_assert" "Boost::type_traits" "Boost::utility" ) +foreach(_target "Boost::assert" "Boost::concept_check" "Boost::config" "Boost::container" "Boost::core" "Boost::detail" "Boost::iterator" "Boost::move" "Boost::mpl" "Boost::range" "Boost::rational" "Boost::static_assert" "Boost::type_traits" "Boost::utility" ) if(NOT TARGET "${_target}" ) set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") endif() diff --git a/boost/arm64-v8a/lib/cmake/boost_interprocess-1.86.0/boost_interprocess-targets.cmake b/boost/arm64-v8a/lib/cmake/boost_interprocess-1.86.0/boost_interprocess-targets.cmake index 4fce9ac1..9599f217 100644 --- a/boost/arm64-v8a/lib/cmake/boost_interprocess-1.86.0/boost_interprocess-targets.cmake +++ b/boost/arm64-v8a/lib/cmake/boost_interprocess-1.86.0/boost_interprocess-targets.cmake @@ -94,7 +94,7 @@ unset(_IMPORT_CHECK_TARGETS) # Make sure the targets which have been exported in some other # export set exist. unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) -foreach(_target "Boost::assert" "Boost::config" "Boost::core" "Boost::integer" "Boost::intrusive" "Boost::move" "Boost::static_assert" "Boost::type_traits" "Boost::unordered" "Boost::winapi" ) +foreach(_target "Boost::assert" "Boost::config" "Boost::container" "Boost::core" "Boost::integer" "Boost::intrusive" "Boost::move" "Boost::static_assert" "Boost::type_traits" "Boost::unordered" "Boost::winapi" ) if(NOT TARGET "${_target}" ) set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") endif() diff --git a/boost/arm64-v8a/lib/cmake/boost_lexical_cast-1.86.0/boost_lexical_cast-targets.cmake b/boost/arm64-v8a/lib/cmake/boost_lexical_cast-1.86.0/boost_lexical_cast-targets.cmake index dd410f19..75cf7210 100644 --- a/boost/arm64-v8a/lib/cmake/boost_lexical_cast-1.86.0/boost_lexical_cast-targets.cmake +++ b/boost/arm64-v8a/lib/cmake/boost_lexical_cast-1.86.0/boost_lexical_cast-targets.cmake @@ -94,7 +94,7 @@ unset(_IMPORT_CHECK_TARGETS) # Make sure the targets which have been exported in some other # export set exist. unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) -foreach(_target "Boost::config" "Boost::core" "Boost::integer" "Boost::throw_exception" "Boost::type_traits" ) +foreach(_target "Boost::config" "Boost::container" "Boost::core" "Boost::integer" "Boost::throw_exception" "Boost::type_traits" ) if(NOT TARGET "${_target}" ) set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") endif() diff --git a/boost/arm64-v8a/lib/libboost_container.a b/boost/arm64-v8a/lib/libboost_container.a new file mode 100644 index 0000000000000000000000000000000000000000..156be15608c47e27fe608fb50abd6bf0405fc062 GIT binary patch literal 190026 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 H-v0Y9kCY93 literal 0 HcmV?d00001 diff --git a/boost/armeabi-v7a/lib/cmake/boost_beast-1.86.0/boost_beast-targets.cmake b/boost/armeabi-v7a/lib/cmake/boost_beast-1.86.0/boost_beast-targets.cmake index 7d494f0f..3c0f7d38 100644 --- a/boost/armeabi-v7a/lib/cmake/boost_beast-1.86.0/boost_beast-targets.cmake +++ b/boost/armeabi-v7a/lib/cmake/boost_beast-1.86.0/boost_beast-targets.cmake @@ -95,7 +95,7 @@ unset(_IMPORT_CHECK_TARGETS) # Make sure the targets which have been exported in some other # export set exist. unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) -foreach(_target "Boost::asio" "Boost::assert" "Boost::bind" "Boost::config" "Boost::core" "Boost::endian" "Boost::intrusive" "Boost::logic" "Boost::mp11" "Boost::optional" "Boost::smart_ptr" "Boost::static_assert" "Boost::static_string" "Boost::system" "Boost::throw_exception" "Boost::type_traits" "Boost::utility" "Boost::winapi" ) +foreach(_target "Boost::asio" "Boost::assert" "Boost::bind" "Boost::config" "Boost::container" "Boost::core" "Boost::endian" "Boost::intrusive" "Boost::logic" "Boost::mp11" "Boost::optional" "Boost::smart_ptr" "Boost::static_assert" "Boost::static_string" "Boost::system" "Boost::throw_exception" "Boost::type_traits" "Boost::utility" "Boost::winapi" ) if(NOT TARGET "${_target}" ) set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") endif() diff --git a/boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-config-version.cmake b/boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-config-version.cmake new file mode 100644 index 00000000..c297dd0f --- /dev/null +++ b/boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-config-version.cmake @@ -0,0 +1,77 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version, +# but only if the requested major version is the same as the current one. +# The variable CVF_VERSION must be set before calling configure_file(). + + +set(PACKAGE_VERSION "1.86.0") + +if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) +else() + + if("1.86.0" MATCHES "^([0-9]+)\\.") + set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") + if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}") + endif() + else() + set(CVF_VERSION_MAJOR "1.86.0") + endif() + + if(PACKAGE_FIND_VERSION_RANGE) + # both endpoints of the range must have the expected major version + math (EXPR CVF_VERSION_MAJOR_NEXT "${CVF_VERSION_MAJOR} + 1") + if (NOT PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL CVF_VERSION_MAJOR_NEXT))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR + AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE TRUE) + else() + set(PACKAGE_VERSION_COMPATIBLE FALSE) + endif() + else() + if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR) + set(PACKAGE_VERSION_COMPATIBLE TRUE) + else() + set(PACKAGE_VERSION_COMPATIBLE FALSE) + endif() + + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed project requested no architecture check, don't perform the check +if("FALSE") + return() +endif() + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "4" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "4") + math(EXPR installedBits "4 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() + +# Do not return static libraries when Boost_USE_STATIC_LIBS is OFF +if(NOT PACKAGE_VERSION_UNSUITABLE AND DEFINED Boost_USE_STATIC_LIBS AND NOT Boost_USE_STATIC_LIBS) + set(PACKAGE_VERSION_UNSUITABLE TRUE) + set(PACKAGE_VERSION "${PACKAGE_VERSION} (static)") + return() +endif() diff --git a/boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-config.cmake b/boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-config.cmake new file mode 100644 index 00000000..d3bc2f1e --- /dev/null +++ b/boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-config.cmake @@ -0,0 +1,22 @@ +# Generated by BoostInstall.cmake for boost_container-1.86.0 + +if(Boost_VERBOSE OR Boost_DEBUG) + message(STATUS "Found boost_container ${boost_container_VERSION} at ${boost_container_DIR}") +endif() + +include(CMakeFindDependencyMacro) + +if(NOT boost_assert_FOUND) + find_dependency(boost_assert 1.86.0 EXACT HINTS "${CMAKE_CURRENT_LIST_DIR}/..") +endif() +if(NOT boost_config_FOUND) + find_dependency(boost_config 1.86.0 EXACT HINTS "${CMAKE_CURRENT_LIST_DIR}/..") +endif() +if(NOT boost_intrusive_FOUND) + find_dependency(boost_intrusive 1.86.0 EXACT HINTS "${CMAKE_CURRENT_LIST_DIR}/..") +endif() +if(NOT boost_move_FOUND) + find_dependency(boost_move 1.86.0 EXACT HINTS "${CMAKE_CURRENT_LIST_DIR}/..") +endif() + +include("${CMAKE_CURRENT_LIST_DIR}/boost_container-targets.cmake") diff --git a/boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-targets-release.cmake b/boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-targets-release.cmake new file mode 100644 index 00000000..e4629156 --- /dev/null +++ b/boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-targets-release.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Release". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Boost::container" for configuration "Release" +set_property(TARGET Boost::container APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) +set_target_properties(Boost::container PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C;CXX" + IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/libboost_container.a" + ) + +list(APPEND _IMPORT_CHECK_TARGETS Boost::container ) +list(APPEND _IMPORT_CHECK_FILES_FOR_Boost::container "${_IMPORT_PREFIX}/lib/libboost_container.a" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-targets.cmake b/boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-targets.cmake new file mode 100644 index 00000000..7e664082 --- /dev/null +++ b/boost/armeabi-v7a/lib/cmake/boost_container-1.86.0-static/boost_container-targets.cmake @@ -0,0 +1,116 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.6) + message(FATAL_ERROR "CMake >= 2.6.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 2.6...3.20) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_targetsDefined) +set(_targetsNotDefined) +set(_expectedTargets) +foreach(_expectedTarget Boost::container) + list(APPEND _expectedTargets ${_expectedTarget}) + if(NOT TARGET ${_expectedTarget}) + list(APPEND _targetsNotDefined ${_expectedTarget}) + endif() + if(TARGET ${_expectedTarget}) + list(APPEND _targetsDefined ${_expectedTarget}) + endif() +endforeach() +if("${_targetsDefined}" STREQUAL "${_expectedTargets}") + unset(_targetsDefined) + unset(_targetsNotDefined) + unset(_expectedTargets) + set(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT "${_targetsDefined}" STREQUAL "") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_targetsDefined}\nTargets not yet defined: ${_targetsNotDefined}\n") +endif() +unset(_targetsDefined) +unset(_targetsNotDefined) +unset(_expectedTargets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Boost::container +add_library(Boost::container STATIC IMPORTED) + +set_target_properties(Boost::container PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "BOOST_CONTAINER_NO_LIB;BOOST_CONTAINER_STATIC_LINK" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Boost::assert;Boost::config;Boost::intrusive;Boost::move" +) + +if(CMAKE_VERSION VERSION_LESS 2.8.12) + message(FATAL_ERROR "This file relies on consumers using CMake 2.8.12 or greater.") +endif() + +# Load information for each installed configuration. +get_filename_component(_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) +file(GLOB CONFIG_FILES "${_DIR}/boost_container-targets-*.cmake") +foreach(f ${CONFIG_FILES}) + include(${f}) +endforeach() + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(target ${_IMPORT_CHECK_TARGETS} ) + foreach(file ${_IMPORT_CHECK_FILES_FOR_${target}} ) + if(NOT EXISTS "${file}" ) + message(FATAL_ERROR "The imported target \"${target}\" references the file + \"${file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + unset(_IMPORT_CHECK_FILES_FOR_${target}) +endforeach() +unset(_IMPORT_CHECK_TARGETS) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Boost::assert" "Boost::config" "Boost::intrusive" "Boost::move" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/boost/armeabi-v7a/lib/cmake/boost_geometry-1.86.0/boost_geometry-targets.cmake b/boost/armeabi-v7a/lib/cmake/boost_geometry-1.86.0/boost_geometry-targets.cmake index 807e6052..d2fd0f90 100644 --- a/boost/armeabi-v7a/lib/cmake/boost_geometry-1.86.0/boost_geometry-targets.cmake +++ b/boost/armeabi-v7a/lib/cmake/boost_geometry-1.86.0/boost_geometry-targets.cmake @@ -95,7 +95,7 @@ unset(_IMPORT_CHECK_TARGETS) # Make sure the targets which have been exported in some other # export set exist. unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) -foreach(_target "Boost::algorithm" "Boost::any" "Boost::array" "Boost::assert" "Boost::concept_check" "Boost::config" "Boost::core" "Boost::function_types" "Boost::iterator" "Boost::lexical_cast" "Boost::move" "Boost::mpl" "Boost::multiprecision" "Boost::numeric_conversion" "Boost::qvm" "Boost::range" "Boost::rational" "Boost::static_assert" "Boost::throw_exception" "Boost::tokenizer" "Boost::tuple" "Boost::type_traits" "Boost::utility" "Boost::variant" ) +foreach(_target "Boost::algorithm" "Boost::any" "Boost::array" "Boost::assert" "Boost::concept_check" "Boost::config" "Boost::core" "Boost::function_types" "Boost::iterator" "Boost::lexical_cast" "Boost::move" "Boost::mpl" "Boost::multiprecision" "Boost::numeric_conversion" "Boost::qvm" "Boost::range" "Boost::rational" "Boost::static_assert" "Boost::throw_exception" "Boost::tokenizer" "Boost::tuple" "Boost::type_traits" "Boost::utility" "Boost::variant" "Boost::container" ) if(NOT TARGET "${_target}" ) set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") endif() diff --git a/boost/armeabi-v7a/lib/cmake/boost_icl-1.86.0/boost_icl-targets.cmake b/boost/armeabi-v7a/lib/cmake/boost_icl-1.86.0/boost_icl-targets.cmake index 2c2dd109..5f7204dd 100644 --- a/boost/armeabi-v7a/lib/cmake/boost_icl-1.86.0/boost_icl-targets.cmake +++ b/boost/armeabi-v7a/lib/cmake/boost_icl-1.86.0/boost_icl-targets.cmake @@ -94,7 +94,7 @@ unset(_IMPORT_CHECK_TARGETS) # Make sure the targets which have been exported in some other # export set exist. unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) -foreach(_target "Boost::assert" "Boost::concept_check" "Boost::config" "Boost::core" "Boost::detail" "Boost::iterator" "Boost::move" "Boost::mpl" "Boost::range" "Boost::rational" "Boost::static_assert" "Boost::type_traits" "Boost::utility" ) +foreach(_target "Boost::assert" "Boost::concept_check" "Boost::config" "Boost::container" "Boost::core" "Boost::detail" "Boost::iterator" "Boost::move" "Boost::mpl" "Boost::range" "Boost::rational" "Boost::static_assert" "Boost::type_traits" "Boost::utility" ) if(NOT TARGET "${_target}" ) set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") endif() diff --git a/boost/armeabi-v7a/lib/cmake/boost_interprocess-1.86.0/boost_interprocess-targets.cmake b/boost/armeabi-v7a/lib/cmake/boost_interprocess-1.86.0/boost_interprocess-targets.cmake index 4fce9ac1..9599f217 100644 --- a/boost/armeabi-v7a/lib/cmake/boost_interprocess-1.86.0/boost_interprocess-targets.cmake +++ b/boost/armeabi-v7a/lib/cmake/boost_interprocess-1.86.0/boost_interprocess-targets.cmake @@ -94,7 +94,7 @@ unset(_IMPORT_CHECK_TARGETS) # Make sure the targets which have been exported in some other # export set exist. unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) -foreach(_target "Boost::assert" "Boost::config" "Boost::core" "Boost::integer" "Boost::intrusive" "Boost::move" "Boost::static_assert" "Boost::type_traits" "Boost::unordered" "Boost::winapi" ) +foreach(_target "Boost::assert" "Boost::config" "Boost::container" "Boost::core" "Boost::integer" "Boost::intrusive" "Boost::move" "Boost::static_assert" "Boost::type_traits" "Boost::unordered" "Boost::winapi" ) if(NOT TARGET "${_target}" ) set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") endif() diff --git a/boost/armeabi-v7a/lib/cmake/boost_lexical_cast-1.86.0/boost_lexical_cast-targets.cmake b/boost/armeabi-v7a/lib/cmake/boost_lexical_cast-1.86.0/boost_lexical_cast-targets.cmake index dd410f19..75cf7210 100644 --- a/boost/armeabi-v7a/lib/cmake/boost_lexical_cast-1.86.0/boost_lexical_cast-targets.cmake +++ b/boost/armeabi-v7a/lib/cmake/boost_lexical_cast-1.86.0/boost_lexical_cast-targets.cmake @@ -94,7 +94,7 @@ unset(_IMPORT_CHECK_TARGETS) # Make sure the targets which have been exported in some other # export set exist. unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) -foreach(_target "Boost::config" "Boost::core" "Boost::integer" "Boost::throw_exception" "Boost::type_traits" ) +foreach(_target "Boost::config" "Boost::container" "Boost::core" "Boost::integer" "Boost::throw_exception" "Boost::type_traits" ) if(NOT TARGET "${_target}" ) set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") endif() diff --git a/boost/armeabi-v7a/lib/libboost_container.a b/boost/armeabi-v7a/lib/libboost_container.a new file mode 100644 index 0000000000000000000000000000000000000000..a65b4058cbf6f543c5997361e2eb0d91efea471e GIT binary patch literal 153738 zcmeFad3;n=wlBWVsUektP+>BJ0F?yNAs|%3AlMF-O4TudKm-S*)tn*(Paz~BfK%IT zRiL?uwl4_n4T#>Ltq+H$6VYzDYFAL?gJV|#+QC+DY2Ox-@^x20yd~b&-*@eEY9xu^ z<=uDx_#Hl#bN0OV+H0@9_8K+?m${m1l`Ar)Sdt%WLQwrq{A;n4O)W1|W8@6R*ncoK zZO{Mz0}O=mul@J@7L_vL|HW_Pawhyw`Mpxlg#RhOQ#+XO-}nL z)UstOmp9eb;Z++AH`S?MtJXBSYU^sWd|F7$tmUb3*Vil8xyjvTjN@~vaV*0`|dhc3n;7wfH<6z zLp67}*D5tjU2E!?2Dr6NuG-sbR=S#Qt*fb3*45v(hApdGv$m<>u4n~XMhzHRC}lFv zg1eS225T*x1jwZ6OiGD@SSuBWvlhXjtbNBI7adVDgi~{AAk?D!g07a72vIGH&nlpv z7_6-Uw%)d~Zp|9Dw4q@Qkfs5cvufSSwQdy$Tun``yOI+5Bqe560g({HBV23U4fUvQ z)hbv0vc$^QC_t&(5@R?HCX|nXJuxocrTPX;aZ>pho+cE~I#IWbR!l?FU5N!$Od(`T zE>N>fU8KOjq%LdgVa;0C+N6fDPS>pgs-D#VpW%eMZ*6M0Bc&}6iG&Os;#%uT@#-wp zDs{CD{FXF1EpytYnIHP z&O0`Xu*v1FuWKrs8lx(NKhEm8x3j*oO^;<$VeVYfXSR54ggegazAL*VUYSNkoh$mR zuRNjI6g)$T71ia_65x#4u2nFo8uzNkm3{TDd`7(8cx~!Ja;~VJ`vYn$ORiBv6z6$% ztZZhini$z}_6fQKfTXUYz6&H&9a~)eO>+6PST|64;+pHb?(&4utIL5e#C|fD$0|=+ zoqgv{KucP({a{iLt)!&b3qt!rB4uE*J$s7If~qyMVVvlab!?FZBb-u%MVHy}0de^8e+ zfl~xJ{2&yF62894aQ}^#U9zqb0Ssu*Ib?Vo=|O*mD%>%qU)tXbR8$mYjD*(`wf>HIeXBU3))pWHS=hCl^ZopcyJJi*CD+vNo)$(YiL!9z4Lbox?U> zHhryvb0-9(%hVnJ2X*`W_WSSY@wx2yeGrye@gelRXC!AhYyHQQ`&}lp>h7$qYa}7% zv^x~nS`MmyHmCCb2g!Gwem0LERI2Zdu{lCf>A ztHn-Jv$SE^UFX~~SO@L6QOLjeILW=5STpw$l7lg`sR<$uAt9> zog)Gb#I&Tel+38~xhbcVI6p2UrSK)uDLPkBp38CWJT}La?wr?#m|E7#ajv#uUA?-+ z^v%-rT`FN&p9{>(XYjUE-i6lnnwmx&Ke#+zUE=3bOPSi^1j2AmrDm$*bV1_0tcDj} z!`u8Hw7LI3+89&j7CTO#tMIw=?H*EbDux8nEhf+w9JvitpR`2CCu* zZi53=d5(MHfK~LnL7siu`aWFf=M?u}DAxB$vhSYtnfLsO2E&+{Xz71pb^bnSAPLF&n5lsk^?r=|2{cju>p6=?<;w}bM<}oo!@RbU~L2Lmjjm^ zNYyuB$#dB=2dv;ccg+FoI){C8!1Cw3a}Hd~dFko~uIgO%b^Yv~16O{I`{%h-^1VCg zfR+5vJ#@fI&vh3axRUeTM+dBJpq=!G7VL9>>_@WPXWqW|(gC}3few}B-`7b0`|0qFX<4bwHf~wpxQ#m zU+VpGaB-KZHB0WaE6_{&R$xnJHx_eo2kfd*N->b%!R^C zvB!LwgknR?TgXV?da(?&oSj`^t8pZRsK-EHn_z$p+^wPwD!nvNb3G8ri+* zU;07J%z@B*SyYExeyNuYc1Et~9PhX~EFhfgU(nMf3I&)Q-4xYG%z5<$%M8CtCFr+S zWNZa~-vTe62g0`F?fhrK+x~33hoh?Yhj4XXME@$)BNR-!`X0x%CxpR{6G99p+d9~I zp;%T_jMP$H2^cwjxAE^BBfmJ_riAyESa`3;nCxQ%BWDkNeCgMJ&qyo0%Mp~BWq)^r zMc->?wy*zJ2IKjhCl_C12@hs(oV@OuDq9=!P)}s}=7|1fbu`SE^pCGTJ$i3pY54mb zev9#|`l``_MMkk>_BcX7O;u+VSUz-clG&6Bp$zkw&=LWWDct z{7v^aDHOXfZ-@Od-(G2`R4)DfxIbcUIp$<1|KQ0C30WUGZ7276{v63_`*S4M^Pw}# z|L2Iww##Yk`b=5k)cZb+m@G@2WBmlXo1|+a!)nIwqqn(+UA)*|EKQQ0;j!%ENZ?v6 z{#2j?^|yFfVL8XFv_MtxE!27dtq`VFppASR3vHmjU-PUp+b_E9&bzw0B4*35;w4U# z&s_Yk$X69HwxtD1gW~DdCJMh6VQsm{yUj=ZIOJ-0{3!M#wB5jO1br!z>SV z7~K!s7b9+%YB%_wR}Ai7 z+4X#NlvavzxfGB)U?`4^p85l#B-v3G{ zr(vppL3nHy3q3%PEMpTF`CsWBYgiB-Ddzef58Y%C&KSOB<7mu-g9~~-x&3ChF0@g% zpl5#eD0iv!sNLi%l-R|&zG2eadzWaqvc%ban3Zmoc1V8>pk(F_DPOuFs5{+QXc{k` zzSpiFXXqJX-)hsH{&u{+XSh=wSL%2cp~mSHqVLy2N6N+C;ktq|x>GvPs>&X_DE8(j z^z+$(+N*1OGQ^UASR^Sr;5$+2a@)23>+PoT<5b5#8IpWyZ6ILR`5gM*ayxWKh}VCJ66Pp%0jG&Pp~2uI>+%9 z!7NccxlXz+GVIEtee^b8$tK?HpCpZz9^s%;Xg$qn#pBMwd~L9k|M2kDQM8a&N6{aUvnrwsrUfSR)j?sbj^HT2&bwLo3Z|KF{WYGCptv;4#XZq>@c*P8_dKSk(3>_;`l1brrx|1 zc)54*;G8Z{3YMX*l(!OAN=Cv;sp%P2G&iAQ}qj)wk z8P9a@bnA0yr_-GV90j`~oNitH4xn0UAL~z7_V$i7MpwupW9Av-sX@|gr68Op+z2{% zZ17K*A>`GA!i{AUdIQYeW|z7SL|ErLk=$xSa6i6EEA28u=6A5)y%WjmOoV~}?q#QM zx8k*%`FQd`2QsABkZV8X?iLFYbF+ds5Zj4VUSGFpNK8$o4T<4_=*0T=7w74vP14UC zyJI}wHt=_yX;=9bx6SG33L?J3->n>tyd;=Hf;ihgrd;e1jMk2$k@kWuBe&Sgk9qCZ zF3C9=JQqs`-(`Kbo24^LnWQT$ETW!NHD$vRyLzo zIoD86%9uqLN*8z7Z6`yX&A`|b9%eyb%Fq`xv&@e5rM>sND+DRa*DEau3)xlqEbMGP z+PzYIR;qFwh_nkW_D#M6kr#wE_u>xy>Cf(2Djn`-wWo8RwrBbuQdsGKU>#Z9V4=f* z^mx&;0@vHY!`Q8AdNS4(9L)#|hIP)-fsOW2U0(ahV{;v!DvM-{Tcq(1$)nNFcI5g* zys?W~-pkWDK9^071Kq}Q2`gfWeCMZy?pkS!UBGCl_R-3(>^lD=3Y++KU}*3YWqO+V zsFAml6t?0Y(QN;ZW9Wqr9HQYT zdBXwQT%QhqpYAQ8eze^(YLFunJwYFg_44DrKQf|6OG?JyEWg(KBi-Y@Qw+$hyFD$} zH`>8^&ALbJ3&NvxGkpf>Hrdc?GOh$Sv>-ezYpPWF^#d6Px>t`(D>%@-roJ+wAGHI0 z_=TN?f9hSKOvo$5C^IwO=w?GI@MV`T!oI|^Xoq6qZ#`p+#(ZjV(R^5wW`j6eb%fzp z-!u_b(1R)zajL+=Ht%N8@U58pE4+kn%=ZrX#sZh^tM6{_n5PFXUc9teT3RbbtWydl zdt_#V{`7{%&ufb%DPo(VKfURmrOPP3s^Mpj&zBWT;A^bU*`-MJl%;hPzqp}xX^~VJ zk*6$OPGRNBzbvP4~eMBD)$cL;Is@Hju>j`FxJ#C^o$f{6Qf9(Mw9Um)&4 zi15xexSRe_(1nn z?;Yr#9Xt@3B#iN28_{RYb`Xx@^u#Oduml@kI6S+PkLI-nAd7XK{lcgmygZwPg zD3@3&BIB}t5d^L=%$aD*8v@+V^)dVft})bS-I$l*FggAvztL?h0>0@M$t499@@>R7 z6r08yPv0x)3yE$M1^;%u*fZQNjvwLBoe@upryHjldWKexaqO@i3?1%^bI=Keb&7aK z_mv*|B5{M$?XSB!yY=sk_75R?P8^Rh*Y{Lt5pg`HMo0@eFSFS`-2WlyxiQpiz^*)n zmG%Y-K%cMdDv>w3zr)6X2gN;;!ohcmh}`HWsHjC((JM%U6S5>7-j+GA(*Qg@59GrX$# z#)$qh9eOOFt>w){pyhu~!;X+`3%>=9gIR5RcZYN)%6mhz;vVU+Ij#QhCfd3d^c>0R z>K11hLhrB=>w3G8AqC=w}#QnJB*kzGqNiPEfFvDh$$r!XCy-WP7k(KFHH9M{D`u5j>pdu5=Fa zm$+r{TyrR?Mfo&`OJvp(q-r$uKd%|F@w7+Sc?`-yTpW@DXqC+K&kcY{3* zBWOcPlebN2L`uE)3Hc-0@hPbKS#ZzD06%AG2W21PA6r-!JY*6Iyf#Cqla(qZ)(q76 zoX4w_x;KMvKjWd<#rnnxS9ki}O8qz^*7**bc>3F7J#lp7raGQSsBs2`===3P)_;Dv zA=Ip^R}OXSnPAbKZe7!2GujVD@-091k5Zmjxj9g;w$MVOaK?BtSNe$pJl5TBztVqX z@InS2(0D!P$$JA6+#ML_mmWwzJclB=%o1FvW9)>o!fkTA0gf567vY2q{4%#VMIS48 zT6Vj--J39$cRcr0u>w`j^hWS?l($x*2CIVHCe)SXDOn-RELmy`|K8IC=^Bl^BS>?) z)8_?6DdiMpxAI10n8)PUO_WujcB&$bJsSK3xcmt)<93`YaK2y@-RptPuPbYS&3p0p zN{-Drl@nw^+K;w6sm*TD>;X-pZ;C^2EEK2qV@=@Y<7-l||Av0CpW3^#ixufK?3aN3 z6FK%1{*}mA#IS!B`p22 z{7)ig>!^-a`_)}jU5~jw0p4%wpthwh4eN{QaS~+V;v}qpBTz^?k3(@2cLAtbJWiqm z_kQ`(o~LD%DryoZ%NwA7$r2};i68P~z8=V@4&v9Jd{E_CFU@e~@V5`w=|mUmbo z2RzfYS}{4=>|Y%VD=eH2%53!KVEso!nSs@iH=2%EmC9Tp_>giKl;oSPt@f{vv2iw) zo{r22P`jX0=1ukuKH}c7UKm7ECE(93fKOWZ)mH;rr8-+1h8s(pi!nv4<;13TWmiSM!Wqu@YL^ut5FgQx%){%$0 zjn=AB-ceW=X3UvjcHGGMfj!5IWAJSBu!JWn4*VG_3VgXZGOt;}SwvU}{&utDLtu>v zDULAV-;hIZ21c3m4`qZ*MtiPqTgjyl+m9RpKH_AbixYU34P%tAbqZTX(COboc)Jyp zV}$pJvIuMP3H-H%2YVlvkIFM%b_a2S@5EWUb6Ic^tvPTSe8;(%l`i(bAdP|KZI~7x z2^7(ugB+&mdQ4d|Qz33r~)FsC11J zJh^~9rr_FYVf(awrF@+U+wh-&5q;iSRJX4$8sD z@~&s8Ya4bN+Dn8Y$X`zFsKhR75rdff$u9@q1zkBL^-9?sL*x$qPMVYVBuhpvWKY8y z_Di|`u@-UX%-}KX+3!iZo%5|EP@d+@>R>I!$01{t#GQq~1z)k%rozsX zg9Uw&;1G9;JvkMdZ0z*6g^+sM#iATX3qp9x4;ux{25An?^ppmp)S|=M5tQOqpVru2_Lsx{BI4Oja{Kx zr_Mt!p9km~x=F6yhZr-Ymq^KKyGf!E`93EoM=5)L7btKWC@_`n zdYF!ge^LCc($V&fU^i8= zQmp2}_S2p#4M*skv?C0&XHls@i9s6c8xD@YrpMD*A{9uvT-#G3wZF<(1<4uPGdCnG z!2~(u{gT`)8x)y6+(R1m{`OQ)$bTThP%ky&wP8OzTdQIu1 z37CmKnN6E6kY33u&6ezvz@-mo>lv&aSoOxlUQ*w?I*ig1z`&bEC!PjS0Fw`MD3~0J zoilywC98Cew1mT}n*WWLXT=HMzM}xt0K7Vv<(u2@cV=}3B6`ne$;4^R7+(p_;~61? z@p`AwMg8$gjmm+vul@V?{>pyY;bXupPyq05$0Eb{*Yh548tZ)lJa3u+iAmNraNfW1 zd{@Fw2Eoz!vp?t-b?K@u%CH;!^?GogYrOlF4!bSf;9ZZpzV3F_ zb@`G{pFi!ncg$g|&5T=u&*qsY{^W=W99~996wH;ju*gWVSIJK=jS6X@8s#b}PlHW# z?#-irVgEJw8~qW%y(jN?p^CvXkL_1Jj4(OFK~kh=LPiEjlK$zDSaYUAse+fU$VaO} zm7j%-8IO;8yw_}8=r{&CgcfCc#FU>AG74#ht@b(cOy8T}qK|d26n>5Kl-cnn=*cEX zZ{CFTraFd!@vmc`{3VVSd)_e`2galGax4Og*qQ8b0XU~Ou>;zIZSn!0{$qdG zoenA)fQDeNeUKk;XN}HVxN}Oc1M@&+Ta=ljp8wt67!SFo4_EPRmM@jUJpDM5_JS4(zMum zvRD+yGD2A~IK`o3uA~`^=27vGa@x7})GojDd4H6W;vXFNES=_&T5x*4Px7P{zHd4m zT&L=}uY-=qd4eVC6vqk0C7MoAOHI@%LdzZ1Dei-o`$t{rpnEtco3UOE`&2FW_!FiA zXt{T!P4)}p#&IpTDfF6Q;%z0;conc=tw-<9wx7B7Uu7s{8 z*JdsfX6ky(S6F}@#-8dCVcYG{ptL}f7_?>eREwtGk}SWioV4A#JV%#J46*dA(3|=v z6t%Zc*=wn{7COoQi|3@W1C-_w&r|Z3^36g08S$$QoP(G-aF(|FZr=Zrj(D$EgDW+e zpSBM>Ox)>id(km)lx7=oiNFnk%^68&m}=P>lc3NThp{=(d=G)AwqjEjiNL@>covZgB|OszzJE z)+7!1Ayoqoemjc2(ep%~{BIhYz{0<6R5713*#*@EjUk2 zw9A0ZCyKE&i(9atG&f^MB&m;4m<$Q7CiO`N^|FNn*ol~R{@$lUx^&9BvKdg2M>^&w z$bF7M?qdqQqc55E1fW9v<;~3>EAzk+-^k@YPa&4D<@)C5l{tuA$mKpyK<w+n;=?ZSl5>~2fV*^ z2TsZ#q8*a^%yCZOlyn}^OfL5UC57C_1xh*|avwD|5+F*e%6+K!`es&`$4|b41J%G0 zl6#5JM;1XF2HdttL6TdM{G|dd=37iS*Di__R?maxnqayVd+p~W{jm%yniD$#j{#?1 z87Y+C>xizN54iM)_C1v=|G-P9VC?*sXDAQn%HQ)gK_UdYT7=avlYEqPa&+d6%79)C zR6z#R=CvzF(!e=*x28=wigg4T91H)8hj5m@{=}s~pK&RWzgwIhoi7vhSSC5pFCYin zh_&qXK8pN9y-(WJv^_}snRgFQyUY8m{INWbBtZ#tLGuuo0}X>5XsRX$GC>Xm=vh=r z(2I}+(b!2Av^P~21npi_7NlzTqOu?g^)Cy0lS_fv8S#`U)QqEc%h0BAm zz9D@aW>!zuwvz#mO=1PKvfmC$JvyNiwUAT?dYPn^d1t0M+^3}i#jND(AM zlw+@b0hbLK+@m|5#rJgA9+%DC%G1`{XLHF=7H?NCw?acrt#U4dOGKlxAGBR@Uu?d_hZ49DAUp3n-evRSGc zBiIK?dcWCXkZkOi_HT|fgs)__Q7!f%$3$>8aus+ReP$`y2D(Px>BuT;hP{P)5?e2A z+V|ri?aebeO;b*NKzt3W)WZOJxCGTgP4)(KC`a4)Lw8N&9z0w=i zk5qRE343MSvO^hT?#Uc{sXsGhU@Ppx%%4Q``DR;NuSx&wP&yl2((0S!z$h3(q9^aZ zw6T7dLXrxh(&DHHi_kAc&jcu$#ju~Lr>(gNrH8}>PIxvSlOFOEX3l~3n3;D$x}`U> zM>eI6@lhMPUbEO@A9jrDe=TohWfgCMC`EcmC)lxf&Xp_4Vo6tt(+~D`FAHeEI8BnUmao5Px$6Y4qA%9I_NuCs%&BA zo-H_q@R`kPfn?HHrOtoUD)ZAo7BA_4mHEuT6;<{yXah$a?GMQ{GGVolXtU6*m?r4E zEWpinuK(6o6~fXp8e+Z@l!e@{Pgw@lH|VVT&8e~zu0U$lFqhpNU%4`GCZq*s)=9@{O_MBoqxZ>wd}iyYx&<{Y#WgOzRR@RZv9)!DD&T1 zCW;{;Guxkm6J<%>H4*(ptYckfDQR5LLeV1*Vdkj-EA9f`$#V*T?T4^F?{?_6Wrm=? z2@Cobr`|7&Rd+%$sGmt#>Xq1}F+P;R`A;oD^4**LM7!VZ7V5N9TR$rsmZ0a%14G}L z<&*#`lfKoHW_(}Qx;w;}Ft&=%+$#z+t?c7&q4w&1ER-qi4rPkac4u?IWe?*uS33wb-M-i99Mdf^>$==#oiW8j5EtCWc zM}r6dv934Mm^rano1Ihnl`^EIuqoLcGMZ4|kA+#G0QAW?<(#eMu*9T@s>P~aN{I2< zaUO2O^xxjk`X)SXZqJkiNngbt$^+IhE>{zQttLWFJcOT=F9W$WivJz6cwRNC$%*)z z*38e>TVQoWa|J4Vd(@H~Hf_o0mGQzjt9D+w9;X?kChDjYtab?pF87;y^~MD~_d&n{ z!7R+?Q_epJJ_60O%2*ddjsrG|Vn(G7b1dQnsK0p0Vmf0kseb!7Gyx3qcxX{{$Evlt zqx~k%Pk@>x@DqLSowP5)mid<+X)NJEOjDE(t7fvx^2B!fYoXJ3r0Vp?AC2kswe*zp zUDWR0qDk9OXMzp(0nmF`E#Du0^-j!NJ$|Z9ve~0eBY)BS`f&zpyo&jv^GkcW8vnvs z@p_*BCAb}!xPFPsWos2uxr+QWzj5|mj&x{NXA{k}K{9R8A!a{p&Kj>8fxJ;Xi}DU+ z?>%(BLCQ+fr=7?j@F>k#=a5p=fI}S`UYZ4B(Xg{hkeaoocCHUZH6@7BtXiY{xoRY zEz)e96Vu4P$6*AAx!}w2YL)sfud%3pr!+06urjuHIfWaiG~G(!JID6kN@35GgOLpuirF;wVB`Ta#kC-A8;@&6 z+)f_XhPYqzxZQ|*j>okl?gbwA65?Lrah-@ez~c@f?j0WIN8C{!*M+!`cw7*1|IXu1 zAnpsq9fXBd1uU$nFOjhayDN$gc3(Nfc)De^@$|N)gOOR22jO?kWRLyuWC zsUff{2b#BtpJP}7I8$I(Stnvu%;IYXRD$`cV{0avMrb&e>E*OurS$0+gwh`aj;nYt zKtCgty@_6Vqi42)H;H3~zYt?MrNEb@KYcvW4|e*q)$mmcmPxmF1iD38)e8SdAkfWX zQYRBQ_P-ssNE)r^lRgmt=I2+X!jB2aJOTVlG8#Zp;{{_PP!Z?j}1PH!?WlC*Dvs(JII zu`NaKXZCw0f?wBooQcv?&O}?HXCnA@CG5v+`{J1X4Q(duF>hmrxc*I_+)tu#!47>t z8n|{?+8V*NTm!!p%DEU{^p4j-y3FW`==+=!r+coBA%NN7D9n;HmUQNh)}wMN_e*sC z1hmpKOL2NMsb}sB$GcP~ox1517Cm)?W8kOmTX5=*_Nni&nI>!^jjb<-pyH$5NZpUr zGswS1rgi?O<0I&l>Gv*d$VHq%7|tRDL)~^`pJx!lzhS(lIDgmN&bG$6KQ%GR`%zuQ z^HFTVdFB5C4XDz%m+eWIMQdMO^-3m2e*;Hqr~#f z$Ot58xO6+jtpm4W#L%FDH!eB8k#b*e`&S zF=S4_nGE`RbGzXv_kW?LzwD)PIB-!uAwNF}EH|d{-bN$ofGMx-uuDI?=%|mt5 zSJWaR=79+<)Kb^uvZ{YFS=HPEd{a!lr9DChPLpkKgbtA&N*L{+^UjT=hY~6yGlS%X zDHJT|IcBVNlU*aUP(ogh2rtadN-;d#R4+_BJgCS@`G|Z!X`u@0T(G+ds_oF)rC(q2 zyeQqgul?O_qp)4NzltOerk42WWYfHJusDXc^el_x6n$y*bV8E6QGSvVsZ`!5(RkDS zA4e?hBXOGkxZ7BnPEw?-?4a$d|GbCdDK0HI-zh-i@lr7Tn~ZQRlW5xm`o0bvpdj6C*>e3$?{PgzFYOP zIBhJM>(|30SfBrr@@t&jVSQ#nE!l=`9z_gg3vWY~m);AD0OxvXw4b#$^rVX-tj<{I zJ^?#lL_b&mO~#k{-ps7bNt3`gqUFM)`8UZ!9Xgy;_k_f3;R-!=|L(vo@L*sTg33#w zbm3!IoXv+EXR-WC|I11%v^6H*PTA0Em2;Is+2qKTy~hc@IsTUvn?n85dM4J81P4_>pX_FZp5=-~XvSTe@YoUSgKJ9L6oJ(s1cM1(H_ACaCSEL6SToTs3(6 zi3~B@Zw%v%+EN9sN1f|jUzKE$(=-?`%O+>8{2yJ0U(JoJmGPPfeX7j)quO{uED zs-?bF@1;4WHjIw}|8)1Il`C|*&2yB?>gjf*gJykl@MUGT^lrr5hQ4GNTI~|m3mIF6 z6|tI&}r80q1(Hv=ZD6I!ma-w%a9?F_T4Bv{Wue2#VItGR~G&#USQu z0=|^s_XmLdclh-sd#1S}c}c-M59GmWZPA+vQsD{?_B^~E=!}u+&#GDsSlvlddqKo% z5M=c{e0IOplaUAgEXA+Cb2s&smCW{kK98hOKXXjPy#Srzre@5@N+Z@N`BvQ43@M-Z zRT|__@U3{qldV+ky>Ardy9Is~s`stO-)UU;68Fte>&qga?*{TS zhey#WHo3;X8~XKW;AqwONI*}%;K*?*@GScIm6vpgPKk8r=D^j#xE9eVMfHdk!3}bd z>lrWezwMq37_8SHg@5=j?b-gR?po;B|3o@=>#%XtrTa;jIPPkUs$}2zp#F60+UZ!A zySXhnd0BK~G}-Rrj=gC6px5YXcg=O*-=X?Hbb2dYtuA_4;Xc(;AO#QD%~%^QrawUM5}js4{BZ( z8=zg!_C9BKO5}m@6w+3EpWkU{Wi+eXldeSpNe$X{KctW|&ZFW5E0+%J8z)cj}?TOwM_kQ)< zo}Y2=3c{`^4^<|YR6gjE<@@9}Wea>OEKBeGvUSf|>=%i-RG+PO_(Wc;d04nzX4Ss} z@_JLXim%M~kd85US=h+SVy&~tKUpF_i;LaA0JguOtb_H)llbf4*q&EeDvMG;_LA>D zNfJpaQrIEymp8i*V~qCZnmxZi-iW)u&CBnf{m~Pc2Bo= zF-wWI8gc^j)zu)APTeV~`fbn}*zZlpiYBbQoO~`kC0G%g4DZ7x{C3!#7$pY3i$$v6 z#dz*_LArI@bZHV+gaKOkNwPuuHGD7H>~^x_>x8|ZJf@@FUeQ(TdO`EOnC#wY|1r1Z zgU3yg#`6ZharI%Zoa^h`V5@W{uS1OSU+4ZM|&&_|ITB46c$aM zn{i{ov*3u$z2e}`@UtGNCzFwtxBkde-((7Gf-StuGYaX?NQ3<^qhw}a!Iz$DRf^m! z{qD4^1DrajsYygIzW&M{zlF{MkaW;GZ5=7hDwT&r+N$44 z_ZQ?zrvtj})D!&<1}{Wm`$)&{kHg{ww&iT_P@ENpwcX6?g>IAhY{4I4o@?^n()d~7 zavO28L60Q1vXU`A8a-$Z!-xgrqp-hki;mzi@Vsa1Nuu2C*`)=`@#ALjyL$Zk;#vCB zpJ=$1c_rs_NfJS;=r9Fi*}Mkxs49+VoLiNPuP}@ zcwYv}(i7Fk!1oF^_a5mAzHc1rW;tZ*6F0N_$YAr zHC_dDHJUhnNH(%!)dfu zaN08d6srYTVJwFgAG6q%G29RRn!GZ{NLls0i_YF#7&o0M`kK4we&lWcGxnXMIEytq z2X*-)`rshw2C{Lg6L3zS4D88-Z+4gFSwhz0#nOSah<}>2fA6#QyASVjS3v5q!{g%b zz1*{8jF-kMgmhWYIXlA_dAGp}W~oH}C6m1eP4MW}=^4aN5F$ zxOd4MFL{^jK>Ta)E}{58aPN`_xpzrt_;HVU^m=;`*k^!;$Yb0?#CGx%&wd4XodFqy z<|p#3>L-%Eo%@N9AEJsY75Vr0Y2C1pF>@EJoo>XbRc}cvs)(4L%Y=VGp?j{Z-W`Jb zB!s8Aj|koHK|UgM!^iI6R%jLSq(|W2LcPfb^`~;?O7bkATb@+U0zk{MuZpC3WLtZu zL-lisdNze$4Jx^g-LPBT=xMRH`f#ojsTS16{Y!$71B&7<;%BK&_?E;=wki8@uZa7| z7W5-SB9D?4N2uJ~NYtZb35`kfD8bD-F^`hEAUqQZ4|OlXQ>W@k2_R`a@?h1Cqd*JY z9UtM1tZS5#vhpf4hW{5C0Gn6G#J{4=PR|Zu{IImrg*?;nLqD=k$?!j2fLHrBx`w%~} zJsX(T+yyVbR%r`tFYcGV_cln_@SJrUWQr9}RPNiC_uVMy70A+=u~y$mXzlcx)=rSG z50V#QD|D=xnQuE6bd|ZG&19P(Cwa`Hc`X#d!OoKpd4y1gI0V%Aa2gBW z?*UyGL67yj?A9ays?6J)KFT~{BJ56e={+5=^wC)yMU@qE$g^t>?1Uhx*Hy}uxpzBE z)|(Y4?%=su9;)1!mm?Eo^T3&S(l|{|Plx>)^;obNg8O<;55~875aiNldm=_@{0msc z7|EBOwT`e}w;gM_VD6w%uo-l}7^)on>9H|$4a!d)e^&AxulF*YzITjX-=ou`UR&wQ z6CActss|k_A{U-mLO${iu*P!u zi>fD~XC|!#b9=D&7Bs^*1@^$So3n6U^N6sRK1|Ai21F;K9xjmvF99D&D&K0qA{?#)aIXcs9;h={+JN)?iv*%CUIy0SRieMqU3#Y?u=|QQ)XDWs! z+D4jmQ?>vrEuGyKzIA<-9d}y_7F%a!uET_T-?DX$!J3|my9@lAa1ZREw09%=7TrUa zLQb-s_uDk;3~s;@q|Q?nY(YKTm<_a+RT9kfWeM`SBu zq}W={=YWlZL_1iSdwD{dX_UB~%9Kl$xr@^x3eGK#1wFRxiNRgcNvRPQ72?(`-a4CL zk-iR8!&{o_{91txJO9e~#`u-E1KJyckwZOe3)ZWp->GeWV>~4WsfA2Qx8q}sNDsSG zF@w3AG1G4}@37mB(5@l`Zk8qnjTq=-C|KXIKXG6lCsV4RMkIvG48ZvC+nKuSE&B$!12{I<1PeH zU`S!fo77CV;NH-@UAYEni<)=HH$xlQ_$k#ckF?6yI4}2qcX35m57jNC<3`z%sjXVg zxIyfsqxp?k%~v#gQS(P0s23z&H++ZK$yv>tar2@rJiU1nWN`2E{r%%lVVh~iEe)NE z;F*TAml-`lZbR2w{FcTY_`85h^SCE2dE>C({tj>9f*&DIF(lx)=32ctVu9UEp(m zOLA}Xu)+@MX59XOvv?tH7qTwe_lF?Id)$Y`CQ{l^nT3A=|2=g^9`@p9$4;_|E$pD% zBOdbRxwg7+2ZWh{-t3}$9J-slH@fb3wFVbT5{-p(Ul=2}FBV?vHNyjZq!u3uWY8En z|E0o>om>^WGsy~VkzgU;g%-|+!#hct~9 zGUdA4K~yM5@r*J#%n4LTl4#aR7TJY)&S&stCis*s!c86M1*5x{CTVvsRY##?_U_w% zTquP11U&hK-Xachy?H#pkBLpl0i=2e0^lsz$-!Rma~h=RR;F}shHDE!3aYBds10BU zJITCNF0bq1-z zd(;CDzeX;l7GifIJuT_EC){?MfLoEGo^TxqsrOvYgD)JdyAIrq6etsLtEwe-+hqmL zY56+bc~O{-d(kjfSty{}(YD*N={5{&kw1sz_OL+JZbuWzZ!SZ-?b2%>&2PIDLteTc ziQjgKKEfYvE&Q=qTakqOEG)Rs;+Y=>>E_+CN(z&&3B~0H)$#1~ZGo03i;s%@?wKV+ z!flth4+A%5z#ah_#G=>mt=*4dMcj}g3FjsecYq1xmp>mTsX4L`$`%)K&y_{6-T2Ym zIl!J4+DRFmt@&=se(F&7!YbT>NVq~AlF49(t~*ZGxIemuIB>eR3%zBpe$EQi84K?D z{pYk|{;NN7TzLjObzi)brn~%av;9%^=tHZ9&c4$T)u6}u7UOPx0jwbl!MU0ByM+RM zk+_XUuZMIr*Qb}$lB~p{+H|s+uELLOwENSg6Hj+yujPVsb?2*_y&HWj#jh_uE;<)_ zsbAk|+#sG}`xuk2CfhznEzA4TA25Drz91*cFQaV_2Y(uuutodv!*4Q=_G4je%pMOu zV~-Bm|1e}xkVEN&iMH^ooz=jk0M^@CY|s+@3RVS_YBYWJ}3WG{#Ecbg|xPF9Iug$ z6~pbpbl0S2@!O2FVMuF^rC|rO#M9qb4nz9=E8OO~Rnfb5f(!Ua*#-^vbNH*?tuaEn zUh@ct*9bhqZ}d-vKlpepHWHYOFV!QQ$`iF`N#{F`nr*=IIk5`?$61&mAgHt9w^;WK>u8QcZ$7@>Z@$zpv)X^XH(0y~m z+~fHD%zyMuay{u<<`u@e~Vf6rBp~L%4HU9*tdQsPa2?7vkFE z>&0~38j+{n(l^(c?>{y8b|!|_llBL#4+dix74Oq46f)gvT_jFduxF6XPy>B@_ z?>b=PPG5_%-k!rpGPP2NTd=U-bmBhkPUOdp?O6$U!uO(1?Y?ECnSf`B>EE|A^sT?p zSMqh2ky^&0BgdAdlX#$J&64sVlT)2nVS$hi{GR0>)@fh?PTMj*|X2w3v0j3 z@T+tlj@o!^^;ocm$WNNq5_n$=qzaHysyW~0)*ko6+GCTl5%Oh-d;#KNS}`}x zUO*40(gzzS9mU-e%!X6IW8e>m@vj4%!m*R@!RF%=y7ja!o!@>z_gs*L$!*@SLid~A z>U|NXmv22!BAzH*op(2ncX{bS3cN4esAl@-*=K+jhoOk4w9#6s2gL+B# zApe@5OMb{|O}6t;Z95q5(*@s%w)E9>hr-*g>Gn(gEag635%=lFEj^~6W$8h4MwT9b z^^m0p*=ndbL-#TPepb4{DT~qngd1H^;(;W3TK>vF>Zreu`khO9U;15EQNOII!M)5*g z-Q?PaRa4gDf2yxlT<-cQD_7pW>f*+xh81<3wIUnDeuis1Dg6Zlg)d?kTNvAbH1*N3e?xurSnw0rPlYd$pPr9UNMLtU z(b%J7s3hUhq5VIOO^85vHNx$&C|JKHJUW(<5MmhJAT~6qJUXB7=wQ^6_~5)EI(Zb-_15esPWutP2*vPR+S(ToLS@VJOQj_|)Hgy$mM9vk*WiH)QG zBU8fp?B|xmsC;HYcqQ6WpM3Tj#@m<>uE|p8=Q2QAWCiRZqZ%H<`&Z1CA^)aW``YAa zwdq*W;Lx7}W=w)-0o#o%Gh?$@5bX$m>u{+@;-h25Y)(>@#fizNza%9*k$nO9#Gi@r zPkiZcy+Gol17Z7BQhqBNpRJDf0Y2X8>4}+9-z6#GOWBJ_@Vhi6{j!wsmF$M3{8y%=SEPg;?CT`>I@lu!cgAu# zVqf&3V^T_ZHoH8j{A{*5Q-$A4fSJhVv3~>na$}`t$G+%8hxAQJ@Sn%Z5Pl&B?|CWt z7o>z2vSpUUsD;dk@Zwn1!q^vm=-9O>;TzcQBzWDx<{&&Rmg|Pt7k%j1jVa-q*cVCT zzllAFaC}y7O38mqO4!A$N#$K^Czdb`e;KEjb?h+U5wFjcQofG;GzornY#hRiWAvgf zCI77{;T7x#OJdXt_BF%BJ_n~Tkv-x~CvCEMTIivQ}M?d&m z$C}u`C5^W!C4Fs5_zvbx%6|tdLU>aw*B!Ah`p~hvQo{GJH<=$*n=tIEzFlRo-HZq+nAD+zKt!-QRnk0pU>?q2kG%vwxyJRI3>KD zIV_1$+u7$BuOD@(&-UmCf9u#IDdET1rX=`0#!3-h7R&Wm?2A5htSu${1bZh5UQeW? zKbaEV&FYi#?@md7CMEnEW=_ig8@3PdiOFngs9XQ_^2Z3ICpDCguNq zO8UN(@GI;JOJdY3i2=Z?lLeFD+sT>{j?7(SxTO3CQqm8xgGul>l#>1qQMvI z=#g%V(f?3N`Tvs=4zu4R!6TfKeu`b6lzxhRhs~inmg`jPi#~MhbV@kF$}Nde5q3+u z+F!ki`a4%R3V3ab(T7N4X4H2kCHxO|dlJ0=!EzC9iRJo7?2A5h?7Nh(DEw;@{6yg< zgh?-|KBDj~#`|1C_?c;7CcC7V8PWrwNrv z4@R43Q&P&8rG%#me@zv^i!^ z$?r%BUnO)U!Q(2yi*RnN{8cIW=L)4s`R58ZTX24k!E3JY9gR03ybIy~Op8`HH>JLL zDdB3NGHLwP!e23-#nIxdIwk+Yl<;-JKPAEAIv75)gj30NDfw?m2`>@eP8#15VJ*UO z{%lD~{+m+5HNxnm@-->xu9WaHp&IauKg&|mZxv1^!Q)n88^Us|z^y6y-6`Rf!i=Qy zD}^q=BTgSyrsQuF?oNVVV@i5cN_d@+pOk-HO8Ols;Z*t3PlZQ-Y?P@LGzCO7q7P-=o)SKd{8VKN_M9PNKHHd*{=1a+9!g1P zqtxnPwn?rau`?VIniH8@m_KVc~L?ecXH?ZYe*uld$vCFjnR`IZltr&z4?V$)I`v)qb^l?0W3!ALLqlJgJF^4vP3J*WV7Gm?E{F`|A3HH7Q zPm<&e5qGoyqm5s!|2OQ%d20Sb6dEEv&jgI0${*zUf6qEJ`3l5TNPmUhr75-uNmDYb19;et-+W1>JJRn%~!+fd|e^z z*5%YUg#C=f6&{Y3*&};U&VI5Lr`x6&^Lh zZ#DR-<69=2($bgl{I?3C7FNf*QlNJRV78Rr< zM|*p;H_7&On1fC91}%C(d$(wB`adHno*v@1P&F$>=c@3g_Nd<((@-zHrwi;cdZV3A zys6#;^p2Lt-1G7n;|p58AoUOV^=OCQCheW2z0KNtnD)-q-YCvW0SjIqVEnLF&j~I4 zCBTI0i)iov)ZSEpx2L^L+B-{oo3%HuABz-0Rtg{k?KzxR&>L*qSK9j{v^xekNInl# zZxC-9_tk(sg;QJ(sVL6B}DHs6!A`pQ-R80ybwlz%$> zW+*?#U#0b*=9|(<_e1Zs+MCWA6s9uCA|K7W_S@ia{R#yrfS^2qm@mj4y%hXwSM-UZ;@wSHZO z3Mk*X;?YJ8pEhgn2etP@+WTScy+eCHroA86-cM=oXSDYo?ajyYV{JT_t9%E|>jN|% zz-K4DF`u1y$L0-4!N*^ro>gi7Y5yMMQ0YP}pB;3T%7e%+p*QNSr#JE+q&MoP6BW&O zi}og6O02x3wKH3l2~asiu?)1c81GmMR-bhfT@d@o3EAo z|JZvQ_^PTaefZ?wh#{bah>D1K6A(khcoPByr8PhZK~YiBqGFSf1QHENCIp4nwrRDN zTH8{GcIeb;nQFhCDV@<7+R;Kgv_m^iC$;>i&eV2j>r^PVg$~n3>%YFwv(H-RuDf$? z5Zx%go zmH2&`;}dZ_J~?~)#Xc?fb}9F+0KcpPhk74?-_dw+zvMrd;dAW_o>t%^+YA0h3lV~BR-aV+ZZ_!$Hy1m(|Q#qg`){>pKo3h_eRcEFJ4 z#*>u@$-{bLy|OB!`rRu$e;?LIbRL1h1Xbbe8(;{#UXZYic77AbEeW?GBtOrOX&=X7 zhTA1Xv7mgP=-HoXuRij@&us`Do*{TB<=+zgvq5-XfPViIq_aNXg?eCkD}0@n3hxb0 zD}jE*na+FL`;^KThf$2pOPLgo4gi|FbH#j20XKE|M|Y~{F^t9{y_F?@UA5v_ABoHEI*#1+VLYP|6_n4;&W&GJn`!MeEmj|}*=NZDjLkwZh%Mu<% zNWS9?p^xJe!`CEq{Qp<@gS;R`UW^+x3>(7pkRju7o?M@zUUmQ70X+3Q$`JgNa{NpL zH-d8f{Bt%!w%=rgQ9e4=$C-|HxfS*lZpm}wC`0ED!UK}-uD5YrvP z@OcSekno^{FG_ew!j~n)!<RXQk96#8es|3$-Y}YjsA_&UyvzKeH$rx7==YG?}5dG_6gsew5PHX#KAb4Di)e9a$ zP>!Fs9M8pQC&p9Zc|GmD332i^A&mUOMViB3f_AX!Gi5(S`{;d&AF-VgF9jFFnG%*u zSRrARg!3f4Qo=V%2sJ_ZEYW)zp0Grm*IhW&INrNN&pN?tzuGVT=2-~`Bs?JD^Af%w z;Xw&sl<<&*FH3k-!s8O+QD3M3H3@Sax19a6#r_J^b471kXT_qMuB&L<+|jzZqOWap zU&Y$)?u~toE!|yxjU8Q$n>MyJZfM)k-Mb|Oj{=gLuer0cyQR6Wt#w$+p{S6tuX*hd z3x{AE8{NaaRM65RHs>~I9NN_V$^Kd*wfsC zZa2hkKf|NEM4MSleXWSqc1CHt1NNU5xipEV{7_(a&H@2;3 zvs(Q*5uWOtxEQV0_0a8&ea%@~b0R#gIdL&swXJ*G+8S|4xf^prtfTSSp1yccZe?yb zY8gh|5J0@bA+Q*g9bFxLjT?HJdz&{{zp|4(`s~cL8#h)|tZ2Nht#^G}>$1-7wauNv z6c&pHC#i+D(0J@wV75kl8`Hx^aXa zaW@i_XU~X?UTxrT(AL}4+}X$@ZR6VRzV^nA9og!0Lp+S8rtjd_a(bv1Bv9~SU*IY|A-rE5)H*|EFIvNh-nK>LZMm@$(nAq8| z-m3Exy;^PU?CIXvv6&}jLreNuo_X9KFzvavCf>1Z=a9$zLSx04=MG=9)7F7lH_icn#4y}L_WmK&9)pO{VfxO-cAQn;ZFI!sc|OD-M$o|vw@qC<_J@kR zsx*Y_-NCQXU7*<#{w|RVmz&v9W=!x2P4+PE(vb{DZe`ZI4Bpo{6qQ@`Q0(w^F1tZX zdz)6euRR;l)!o-tvF!R=E_Yo&z-WM*3hPE{uJGie<1K9?0XOEt$T+cSWAob1HXOcl zP(?fbNI-XDg>&lO#tl5T6~mnGL$kc<9ts$~j$NN=!Qnkijp@x<08d#iSd7Y01srl$ z+U^8`v$D-jn-k$F&4ugh*bv`@IxxC(O{36D_tbc~F)p=suEXVkA=CtqNt0tJOa*#e zLvlRQA^9=vt(|K(bz=DUt@Khu=IEdhoicbZ>3?#%YBD{`a+UYgNKY_4^uQ^J&x$Ya zIVVNKRL`)iytwKLZ_7y^we9LcJzZJ9skyfmS0v$mRd>^ILw9TFm{+f6FL2i<&3$;8 z18ybb(xyvF_=k)*oM+_ltQ&DWYHi%o(bhQ{n{cyNG`8h7Xeh|@6W1j7IGU{HjnX{( zJ@gQ+7%EK~!lW57y`r_VqpP*8rwuFIx<{oCwJq87nwmMp zRn3TT)$|C9^81$NdDJ;dd&Wu?CuPHVcy9aGBV4Q~#bD$oRvNt0vTkA?}uV$wV! zlM}<0Jpvd)Kf`17vty`jJ@amk?0QB=PK2i{CoV>7YiG;Qj;~1`Z#Fi}j1Iis{xp;{ ztKXY!k4I`M7ut5JT$p%9b&8c>Sv1{qR_xH+n5r|?Y~1npDwE~e#p`{O>k67Q&mNN# zV@pr38_I_8dFdXfmy6%^a6dh$*tlhb3wcwtas7tIU`A`jf(2aHVBJ?S->v7ll(}xZ z+N~?+xFoLoDk`g7glj}9U4&~y@WvoAa(h7y*EMcE->v7l^<1o5E2`bPa*j*lx)ro8 z!Zjk5F2Xe;X%}(Z3+6jox1Nu6YsEabJ=d+P-MVs)%ix;Ux(L^_HVndb+U2?Lvxo*3%+C{>3J=d)(t6dPT zE9W56TER7KcM+~>yNk#=?b6(8LA7Id>-lay59`*7xo%xq?UJ~Lg>zhlYufH2T+?1I(E07k2N}r+n(#zmDMhZYufH2 zT+?M~xrn3XbLO#r|gd)gY+Lb%=}nH~<{&As0pUUghas3BB4Le5OtH{z~dk$AcHZw=Kqx z175u}f$w?nusxtE;`oo$6XGI2HUmdL$VE{pet>9|_h_xiOd(`OVGvliF-(k1)V-?D!m>{BjUjxqa1@F#`yX;@e z_kV;>{phJQ!8Ng4R~ zt^pO@EcfbVFZjqqKdwZmek>L~E%$UuydUF3T+|->fulX-qNpDQp58&@#~TF4a`#Tk zZjS-*{nZ&{3PtUC6L7X)6+9Tu{i7dO1FC*(5I!yUz@_niTovLXKeho!d&osmKjwRS z_d~DttHpw2xrZ>$!jx#d+5x_Oh^r`H3vkwt=fRf(hx5=k|tSO84qc+4v zezXI}^5mkZ-i4mtLF30V!Li&D9KWp}J>b)0k>$G@IO|8jd%|b&>Bn-zHzVYW?0Z=3 zBZi{(r98eA_-GILt`!{PcjIKx+P58iyO|)Od`p3|_LYH8`~7vm5=Xvf;nR9vQ668< z(?eY3$7ixhSf46>wJXR^!Jlf@8VQil1N1P-VdDR+X22Z zVA#HILa2W16h8H1{AKZe^o6*{kIBH%9&%AsZx3)*?_T4_?Sf;uCeb^Fg&`^M)rFgG zt$d3;z5(M0+fV(tRru78)*OD6g}BI%9`Qr_g6f^&=^ZqFG#b70a6Gf^u^D^~F@975 zXX~Y4Yoe?J+2i{x_*kCx(kVE`-!AWSQTy7#HyP|!k%C7`;lkgR`A)k@M(Mgt;e??d?}Qt zzrBXc=)u?;+^bdf6m6mis+A8%&AD@h8By4RICa zdjU9G&x7DA1Biayi%{$NxbUeT3)As_d^N;Hel!3_d&osmykxNBce!@gEeZ)|dui4}4G4?$qIP&p5Lbm<}z^BJR%lAuwtiPL$eGeNx&UYuD?nkpLnhg=lZTkPpQX!JfRIF@^3akd|W;AIsD-KWfYCtqhM~xM=px`!THWsZ_4=bX~EHsf1Z@>M-lk+ zo(1{To+p5_d}-syXAR#sgip(@0AJkx@%|7O`LSC3AQwgbc(13o#`y6C!O@SGyz~1e z@WqXj-|)`I8^D)BdA7%27``70pZf814nIB<;vzrxiy!2os2`7cdfSa3y97r+=1$3O zj{)#u+IA#rPcd+|JvM_+ujBv9@LeW+TJHF~`1bfu?>c~=3ZXsZqNpFg@~#7R89$y9 z9LxRg+-yGz!1qlOiKspQ44n02FZgsn|65?Gmwd;BPsaQTy)q_y)m8 zd)QCEDmcdPmwu|_&}-nUL%NFcy~FE&!TU1(elNgk-z{E$u0^M!9%3lUccaIb0-xIV zb-^*d0FBA+tM)a34?}h&T7Pqav-MYI`1S#<_KgksqWW6{KI$QcqV}EP@udwP`=Ros zWV}-QTES=gmD)GeABPOze#7@WTpz*T$i5!2j~I&D_gmnszqN+%+k&HCpM^2D{x*Z} zEhG|A`?dmS`5M5d$E|09RewJ&d|K|f=daq=8R8;8f(2nclZ&FbcHpeu)kg0>3yyw# zF1)UY`auEsw9d(=_Ix75MS6=w?{^7;sNRnOXZ5z5`g=}r)cZ1sZT(Hoq4y^tF4CJ4 zy$7fiqI&sW46C=t=>0!}quzf&0jswRd~xH(Ga)Y0i>IqxfBrs|LR9aUv0?RYHhP~I z9QD?EdTYT~Mj{dATj=ri8@_)7mN@cF4EZAa+QmL%D9U%1$G6q+y&yR94WLundg%e* z3=)ZGKlo;di}Y?6y+0D1>is%!wqCXwz5fm@an$=QuOB=LzPR&)PkZgV1AMw4{n+sB z5k9qd5PaAbB2oL^6XGI2@~;f-As0n)_j`IjYxKS-IQr2Zp8rMr&Uo;p)ClD3<{P~8 zzun+VBcI2QpBcV43!j#oy)fR7^FmzYM-6bahg=l(quA4X$oO$sa4g67U)p|93%(U< zgyC!R?h6cpuNL|AA~CXtBR^T`kw>D?`Qj|xupejGTfw*h*ohyETzNF3uwp@jbG7`hjH zasBz*z*)YP;7g+%`Ti53^8HNs)ZVH1!7r{qe>TKLev|=6d&osmKOXn=_M7_qjo?^r zC!Sxhex$*-g9#$a*9DyQV;lHZ14BOs5vm^_5kB=}e{H-UwIMF@;{b59hg=lZyU^2n z$oTO)!LeLjc-)WLQGq0XX_WE{f{?6mVAWpz-4jqxXz)*?znTzEvSr7T*sGv-t`>kh%ZNujy#L z{0=ypqJGpYi}&NpAujTx4mkQjE{gi`l&3chz1a0#{S_L$FQ71s!fhujz{hvZt0>|(lhq%a(t-vA4aZ$JGz0cFT+4wQR=C+-ych@mLo%^u%2!*`D1`x45qsMhmmX`gUezIP%r z7E3J?Av?gALP-1YTDQo)&maxasK4yKCcd6;32{+9?*oqhl8d5#+=y+fcekl$yhbk4 zdp|0bMb(dI!H2FEiMIQe5EtovUi9)khZNPj2{@~Fzp1|qjo#$>*?JFx50^}lDBtVe zcsgMC@H)H5j|1NLd|d1!hN66Y{>|F=yy3gp@Vy5W!lGI)uYoVFeeVFk@*M9!l(5)enouy&Ixf*Jx>OX?Mp6-`f-J)H^9wv?jO`U!|1I-8jAw%B$Y#N1#+z) zMc~u@2(SB#>X}13qLF>G#Xe#vY9FJPZ?fSlGkjymXWLf|z8#J!Tq)mwV0^ZGDe$EM zp}*yZ?{yi+wVt2N;qNy>T;#{|;s?1Xs`qQ2-j$}FFE@I3Vw**^o)3cWkYfs0%6A_? z){iFer2wHH{2CW=toM~@RGu>ZRF{<0>-MSdIrj^*{sUaEIBa8_@>@dK}YjP$+^ z5cR4bFMyBV4pY(10pKj(Ht=l&h<;QXzW)+FZI9}k;{Etkh>QHF1&)4@i=uk}+|!$a zQtkJ6?P}!5{by(U(Ez@vG7aCIz*#@i;9H4&`hnL@Mtoa@PyJ}X$-#KwRMft!LR{p> zD&Xh`xhRU8@9FI~e(*VC;#h9R)NDW2fUk~3BFdKn&ib(pd?{e)2fu=*e6M@=>voEL z`lU4G`<-{cZWs7y5BX{h-zTSJ+xJ=U?F3Fm`R)PE+PB--x7hIQ5Wc9MalnhK=j%gU zrk;VLedMC3-fKL)&zpK)YV=-Rlhe9H{qIU!$U-)6Co7>e>u z@c0J7r}d22z((!18cJDI_sf3p*W@*P%;*vwSs%Z>8aD5fPw+-D>>cv4A-Gk5@Hkwa0zn+fE`8<>NC&){h8*^8fuFg?(TeylZmKPSf--9H`%Utvh) z)@siuyyMIc(c9|j{g`*0IcWUFYv`l;`-S+cdUt}a)#z0}p7H!R1is0@vHsQ@zMl%8 z+MC}L-w!?%;-dO10*>uLE{f`Xzo$3&q6Dq3Hk^N!~!@T~@j_1t6lz9xKHZgWd~ zJ-;u+MfLmuaP)&*6!qghp5D!-o;Mo3d(O(<-yWu3bKghp`7_|`{DJ8Sawm*2YJzJ!3`j6c>4b5xtw(c-Tc{C)%JCBX(7I#x zR^W=TV=})IE80i@^#vgnEj>LI-B+a2sf>i%;d)+mwadWV@Oj}@Q{g+7uBgw;Q;p;< zi}Zs!cmn5)kTa@XPzIy%y{@Oa>tFxv?_ckK#w7*?5By1gTpBQYh}gAjS8RS<8K%8! z*Y^ht_Wsjgu$NjAyR4p*#PUD)(O{fym56Iluh1~mkMi~?Ruh^U{P0VZ+Ay)s%*iWxmEMh zb7rUbhP2jHcUP*ndTx4tO?7MKtW-;9bJzORJ#D=k@v5U#WpzcmVt%Tuy|1rl1#b&D!e9^t_fi>E_nf>gvjxb@OHgi>^X-xK}a-d6n2)QdNPs zP>d-&b5TLw*hFD+eBRl?guJ4>iHYL;NqOf6=O-uUU63~=QJSYWLu{p*?IiZ-O74u2 z=;#wBB!e@9R8~F)A0x?NT)^vwjNm4Pkz_C-_&tu78Oe%3`#AxR_Zc}SvxzNyS3Tgo z-HhO7oslFy>idsb`QeVQkYsRius19JV$E`4GMFAbm6bo;%fB@Ed{+LYUjAjlWm*1T z=H*`zOv%c>!pol%jLpiQjjzae-$EB^*B|3)vqD!3%8KJ1w@?Oh#A%F5@NNJf&l zf=g!QugPR$D;YEezs|C!$;)pIew>xx>gBfw16ld)!8fqW@JPgSV}1wwFwVbJXv#O_ zd?L(0Gq}x^Xa0*gSh75ii^Yj?L6Mg~9v5F3{t3bJJV_8?d43Z%lYdU|w3pwBlOE>d zb~E_T5AOBy`8!fZ|AoQbp8g7)OJ(>k4sP?xKLx`x`P1EZWyCypoL`kyKbHmvy!t5u zU#9$J!5cmOk7en$CE-a<#bsD4M_;G=g^MI#bWK|# zar6a;Un+6brHjk3R*riWF1}pyaX51EYbAcJ#IKV$4o5Ek28mxFaT(UiaX51MH%tCS z630C=N;wWk&fYgkyhQSEllXLr-y!i!&_>uSyi?+rhWX{Q1lK6(m%LzeVB| zlHVrrwB)asc$MULNSr6q=8a+5-wHAr?u}sfqdz9kz0Fp?zhlxfU&!%ZG1hqd^>ZC= z0Y6ZL^QX4ns`+}^5WXxd>!p)R?}DtnYbCyu6TK$w6ga%sjhzBh%q!30*eWC6Y*j5C z(Vr2@jiOf5*_y*QXOFCS_+lgLt*pt`%U4~GsCC#vqtH1g(#bc~j;t;ReiWKA-bL@Z zUb^zy5qhU_FQ(Kev}Ww(+ptHWFjs+*byZbGb(u9HEFHnek;;ui^V~?YKje(4eB`1d z>o=_weO72B#lw{uSz}dZFArZw%8v~6Z5&DI2*pOBH#6eecgV{SF;YX1rtm0i$TXR? z!3`H9Suk?ZQRp91_wK#;Ctmki#YUmm8(_niQje&1*ixg=T5b0&`+npRH4j^ouL!j# z5w08KQ+4K4AljD#-Z*hzDl@r5KaFKG-8c~L6yawr%=d>Z&i~es&C}1xn6%9IMMhC` z^P-v?V(ZeoR$j}~ld5V%j<3GB8$*p98+z>5M&iy6P6PKSJjm=W#sl}cC7xZKy!EHZ zI||FqK5AY-y!7NvJ_$n8wDMsTn_@m=Vv_BMCZ8-Zx$aEReFDTJ+9H0Q9314s9o}a- z;yy7I)7L69!?u2x2(3T-S@m#bMsB^z%t;6@2XI!#Gx-rT4pU|n8nec#?iM&WqQcxo zMxifbEr*n)qj%22N1?~;X>LdyQB$r0C!{Ov?$T}@BQ#t_V_dOO=rv;@eeCI5+A)&O z*dk`1icYre@yLBo#(?YxSxmC~z98AX9$8*(>|S#mzU$b$ zhB$l)vAjUoDdZ}A^KbaFU))w0wQR?|7`ff!%Jkvh%{<;z65%~2O0C>4)aL`j-}u5j zu6e(OvIk@=V{yC(tD?VA{vB|*Z4}f>#C5BVbdnvh5P16ZunqYFnt7`kUBQLK0 z62MveUNd~?auMHt7y^GI`}&Ya`-q{a@B4tWeECpH9QzAyA4Yugp1i34-G{t5`%*}> zeB%ute+|?6`#M0@zOBfkUScR}-&cXNe3J|xZeK=x>q5TBzHP|kJ!}W6LG9R+&+!?zK?X<|8^M;Y)1X>d%#(~*@h3dUn9Qz zLcXYdpF|$@5<^k@HhX;4h7Y%IBfc{1%+|iAkq2lbT7NTuv-T}Ce7OA^@%s;_!Q)$D_@*1ayF$LG{$4;H^$b# zh?TW(kZD*{w0*|_XWOIG@LdKl^^)(K7>I5A<|D#%Vkm0g*MYNqeTMIH!Li(*dHs)b zrQ+=SsMr6vAFw?4w<`?anvgH5KhDh|ju?vCx7y=-!0=THj^(OQ02ERGOXaYy0yyjM z!-j8;;XCTJ?`*M;7>e5Wve&-b4c}bB(Y{;4<7H$YpYI1W5^dibz2oJhhHpO5)Jwjp zAzxH~wPGJJ6t!=%$M?A5>YnO{{zrSwEp_M+e52 ze_t?s%YfGQc*3i{N5wv3C~6Hy=?fdHGI#9 zzXM0@yG!gNhNAWz0M6QX-0)o|INJ9r7Ena??M8&Zk*jF^J%I$v_nP6m0eM<~JYJAb z%N;-jRTYWaw-zbLiu^c;2<;&kMR9n1Jxg!?xbQdfZlvENIF{Sy)$<|n!Nf?^o`=19 zo&-LYCm+xC)sK}SUu55Lv5y#v+PA{vn`-!O6&(5dQ6B$MJ->#Cav(XXulta0>zU6% zsC|4&NA2VM9{fl4k$^aTl1I5YAHed>Hhi}mzHXEUG_tP%@gl@kwEphKhUKd^e0ps| zJ2*$#+BX?-rV~R^`(}H53k@IJUj2OqWY)eE$|(o=5Owlj09pI$3||uv%Ex|=|ET_E zh<(IRl>14KZ-wDoD>(Y~XW@Ps)gS$etG|zW`{gRb*J}7yd;9r9v5y#v+PBK%TVwdv z36Az%81hB-)qzhr$cLzt^F6*+!`BW3%aHGYcb?NA_7Ou-?g8&Sr_=D=B{=eRVTG!W zp0i#FzE2>o!aOcdqC7*DU#a1epn04Rk5iZ)i(9A>go=A~LdJJy&qkr0Qdjd3ryp#` zE9`^Sc#_&iW1q90lb$=zJ#ig9XAS01{O7FqhZiT&bJlN#b$n*GuwipuuzAma-tob` zXC?+1>wjhp)_mGGDErMozHA?RDcCa;)I2WZFdV&4N1x3;9Xx#Ic-)Hn>QY_$2 zG4?|CZusmh#RP>pVUB4VSL$(jYF6zA!%M>hpZi)Reu1;yk*|cNx-ZLlf8F+@? zYuzRW@=~dufoBRL9lsgSz7*yJd&paXWg3?A{$JG5vkb~1oI8NF*`wP9>{%`r<^{8+ z?g`Vv62#X|+4XAw(b}=OIJjTsr`Y0L@|Wjdv!(7Wbz|F$+Zhk`@SH)S$ti?5uEACS6xw?x>bZVaYgtKV+N z*%ZrNRo%6zv$N4t5E|q0N1XqQpY!K&f%meeV&Q!%?h72Ad0x5_OD~p%fjPi-3aGh%*n!!3(63$jxgf_-mjx@-^vT_aof5| zMqjxLQ<6ASxG0OSC@4mJyB5egBjouBNArv%gL8v3v&x?vaQUrEf-H%)xRJzO$N9+_;a-@LWUwNr$;#(mnUN&=8?QfD z|Fu{+FCxi{8<8S}zhcJ}Vf;N3XSXd$+#Zx>#a9Jeke=Z?Gk8jNi4flz+>jMt7rZwS z;yK=MUWI(GE7^Dd}lAlPFHPV#THsVz{^MwG zmZzDei7SJ5VMxj7dt=Z7V#do{{*vH%8Y05-Q-D`te4<7WGJd|-USmAGejg$9w;{UU z7TU8S_$;n>C_EmOB;FLv8tU14@#UY zwC_$Y{_oOWp}vk_t?(08lIRI|e}lqfRY{`D*;R-G7WEZk;G`W%>~tC6c1qa8P>+LyRFJbot@h3EE( z#bMu1pmIxzx)xN&150^dbn(=61=2~WiXOBbexk`qb@u~U>J{VgO^BCUn+D2o@=vYQqqod+RdrW1diq zQoQ~XrQ?ZI6bOegd9<&sv2AlpTTdSz@e3+W?jhUZn-mYkcAKXJ-Gh}U)LC-Xac<&a z`_75ejj}7{?39(2r~$3+5g$Jup*CZ=MrmPA*JDXft`=jdTATZtaa0XP+khv>0-oEVCKeQeWsVDDJu2wkB z9-V-i#@oA^?~-9*{if#LR-71gw&ArQS!vBJf3&Hi7iqVzT5gXBL!RB0b{KlA^AsAp za!xp9s1Xf~SB@;rH1>asniE%&yZTS3D<`5Q>b2bH?Z%$6>eiut@z!|Gkqp(|+bunR z)y*eSSa+O^3Cm9lOAbeJR?jH>7_RK7-N;SiYQHk=P70dWcHC20h3$b9-gND7RWe#-x%%8Fb;-<& z)(SWMqB48tMQepW^P&>>^I9w1#0zh>MQcSRCR(&s#Lc#7t*F9m3m_`pA!f*FaYdMW z^0P3?aL>=&<_oHEpN8`?RB-#tNiA+NaGUo;D7<%Lh4&yRe+iI}t93cyN^zeDh_@Rx zkKfi!BmNdFw1+s}r?@-hi=KVylXSIN`S{L8%Qyb4usr#2TQ%a_h;3`%eTdg$QBl5b zBv`&l;8Xi}+ga`7?Hlk#_C1X_?Uq~94u`0F=GXGo8T**7eEhbKwQnEtc>hgB?VAIf z3dm8_ktp9wNVk6Q*<$)3w@@QLeu{Lfw-0*JWt?9A9HDx@ zi*!Jv{xS)X-H5BG-g|+we4Nv=86f&WUgi4-;Zr}J1z(&WB_S?qkLQ7-ALOE_-itiF zuOY5};1*@1w-V*?ANg?*5%xh9<@*H^tRLf184XCIAG}qjeq1Vi>c=W<#QE_TCiz;=Wyk*-1v zuo@(r@6J*vgNOC2g>-#1X$w#SRG zkM^)1lwrwb-*_BICJAn_;D|i~D{J3E=w-T!+M0(%tM_H2_cDN4hITxS^5Bd7s1-km zp(yumq+7n@hVOF0#np4l_)#Y~a{eCa){h48>#-BrQJuevM5~v-p=JsFtANdAAD@-ge!pCB#NG!z*1mqkRTovOeYD5wa7a- zB0o5nl{jK3%3a~{%{F|sf@3+qzjPWu@Y9jwBj=q+w|+bf{xYPisNUOvvwl=VFL4|< zmS9mo&J6h?Kb{mnh@mK7(&JlW{8%cuI6wMPPW#JB!I5)9*iWNzlH-WB0kWg*Gra!1 zSL|yb2%`4odHuQ7*r)v<&c1ENKK>*}J}#Ge{dqt1#`WhCuRk9U`&NL1qV`?n_2*7w z-*tkcefdzrFqueUjrUc9kL|6Z+wBo9%pp#7F-5m)&Q=rN(df3GS0RJ`s}M&y2%N3wCs5Bi z9yB4JIF|GMc){q!Pxg`Csh-|7AYlJfQN5Ery-!0g&)3;*Em(5tJ!JIqQ4`|0EXM_> z^|u{~OjptErNCK#519VE4q)Qq{5@{;;!%P~?{nDCt=>)$#P#Rz0B7~SVES{%FnW0* zO?y}`HAe3)N!R|o6?)Z2z@lxx-3kmJ9%+dD;M^+uq5YYBd~QgEc@&?o2z+c`+IKq^ z+Q8)&Z$Ez;iE;hlMsGhKkItw4phvjqKMo&mzJ&U_AAHoKqT967*7FSTY5nygkGMF# zXGh65+wk=nzBZI6FNOgp0}_{LWNSUrX=7S4i2HgP*k z?cY5dtligMR$nlE=d#NB|9a{9!()p3Q^EB8gOh^&gZb&&`u&HK#nAA+qtCGJI95^m zp=j5xFBH8VoRybfI;J6ym1#tE4nSXjeVnEsMP1Ml^rxtU8Z&xGm8E0yn1#7?^w*y? zqF=T3J!>Feol&&+KZ7#zPh@5uP%^2K>qT~PbyN54Bg4u`Pbti`jm zuO=q%NxX^=S);Gcs&8(dc&uQ;WzX$w&pTEyrm{ZK{>SYFr8}0b#aABo9u8)**EKci zeq4}V+Z>eMd_hs&x27z<0Q*Hr*!S#go-?v$^RT9Qe86dVY~QqX7B{zt`)7fhD^#$& z;F_`5a;8whb#JX3-#)SZZFN)H^N$rIVdq@x;qhgPEZmNpC#K)wc;-;Q>j{9l@24zk zPc{UzHrGwYY$n*W2d4#2IG;&2V}tl#FXwLP#-lXdT^%irYd5W1*VdbP(r(nVi^Ag$ zmGbzbGDKhI$*h=(OADfBdzOO0^4M+nGOjDHj9yKB<(1LXUMcsmV^^@L>+Y`Zd%IFT zG!-dO1O4!S`8*|@?z!`7-h(d2!eNltl^pwTz_JnxuWy;o^J!jd@cMw~^h{fgh3B0- z$KrV#)0!k)i?Btu*GtHAN@DKD(ka_r2)kvQ=R*7~XgJ}Vo}bd-NRrVOH=L9PeUlT$2OGZXG zXU9qsXPQ@Mm7g3`AkMlDg`-18l5W(n@r#0svdUi+{1EXK5kwxgmN>u7Vuf>VK9N;^ zy3I!YUgE`P1s}-5&kEj#cx{B56>V{Yb9AgE@n)OOtnydbY~ZVcJF@b5W|$Gq*|{bw zpI6u!N#Y7+K~{cECKFpp%!Vt=%IBTJjBrlR`C0jTw=TpaF>CJoS^0~Ck0QP+qF5Ad zaf5S!tRykRZfjQgdYcXW@_^rX%*gW0Cbp8;W7lQnUl-hhxSk(ykAAc40&K~=%xSsf zNxD5fLz%>$UYEtkJwGG-_RE~C{MA7z;zbc;b?|w_sY~^J65HJGImU1f(z6)A883J7 zF~Q&90Lyr_i;oQ+HWvlt{b$+5cnv!-u_pKj?4rc;I8d6H5cHc}miV)Eag!UpM}-{0*>&`L!;8dhltvM&UVYabnhxIYk44 z2QBii2sVhn{4K0FQ5DP=`_FUnxdG4F$RFZsf;+O}R|R~x3-ft?P@H&UaGvn(cJW04 z@B6CI-d~eQgmIQtVf@3%Fpbw_rHSi;A9?lnBd`2dz)ub~OEE4kc%PJU+&(~jdGIlk zLMCA;!3@{mNSxR^>AKQYl7oF#GY`4cfG z=}S}$DZ^5dXbOHQaa0T9YlAY06T_nXhP4Xg`-G1pVF_lN-YWPo-Vtn-cxeCK!MnZs zO^W~8Uw3-_s|E$>kM=MAF3b2zEX9d%{N)@b3cszw{i3ioJO(8fF%{|PV{C?UIt3|Q z62=Sb!Z^RN!un!4>WRvsZ@Y5Xr`TVZ&tpfF58GWnlr}JbvCPR)y-b9Z<1poL=%nl? z#8JvMA5%wN{srMZ+-cW_bBl?q1uoL3co^gGa`@4?KIJKZA)MRe!Wk0Il&~zE|5}J) zXa|xCSA}z?3UMOx1midv*@dtPH(;M+NM|9O)8q7AF7XNp)8TJ^9!XzsTQjQye#3!1oi7Jo+H(7Y=Mz$F|JrR!zsFwb+evw?5ii(Su#{7*-bJ8BfB=j-lmhePSk~% z`Cg}G4p{E4Jj%IOqair;T8k#64c$Tfn#|ma8QB9L%l?u1REXOf%~wAvR`C7kLB$C3 zw`68U)RRwXLRaqU%{}pI)nmT0#Covamn2H!O+3A$~ zTfBWk-9F)CEe<#v@ZmYkw8EEVx_g_~w=KQvCi!&3P

>kI-y$s^ZQR8k_qXd93Vf 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 literal 0 HcmV?d00001 diff --git a/boost/include/boost/container/adaptive_pool.hpp b/boost/include/boost/container/adaptive_pool.hpp new file mode 100644 index 00000000..a6a89fa5 --- /dev/null +++ b/boost/include/boost/container/adaptive_pool.hpp @@ -0,0 +1,622 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2005-2013. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_CONTAINER_ADAPTIVE_POOL_HPP +#define BOOST_CONTAINER_ADAPTIVE_POOL_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include + + +namespace boost { +namespace container { + +//!An STL node allocator that uses a modified DLMalloc as memory +//!source. +//! +//!This node allocator shares a segregated storage between all instances +//!of adaptive_pool with equal sizeof(T). +//! +//!NodesPerBlock is the number of nodes allocated at once when the allocator +//!needs runs out of nodes. MaxFreeBlocks is the maximum number of totally free blocks +//!that the adaptive node pool will hold. The rest of the totally free blocks will be +//!deallocated to the memory manager. +//! +//!OverheadPercent is the (approximated) maximum size overhead (1-20%) of the allocator: +//!(memory usable for nodes / total memory allocated from the memory allocator) +template < class T + , std::size_t NodesPerBlock BOOST_CONTAINER_DOCONLY(= ADP_nodes_per_block) + , std::size_t MaxFreeBlocks BOOST_CONTAINER_DOCONLY(= ADP_max_free_blocks) + , std::size_t OverheadPercent BOOST_CONTAINER_DOCONLY(= ADP_overhead_percent) + BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I unsigned Version) + > +class adaptive_pool +{ + //!If Version is 1, the allocator is a STL conforming allocator. If Version is 2, + //!the allocator offers advanced expand in place and burst allocation capabilities. + public: + typedef unsigned int allocation_type; + typedef adaptive_pool + self_t; + + BOOST_STATIC_CONSTEXPR std::size_t nodes_per_block = NodesPerBlock; + BOOST_STATIC_CONSTEXPR std::size_t max_free_blocks = MaxFreeBlocks; + BOOST_STATIC_CONSTEXPR std::size_t overhead_percent = OverheadPercent; + BOOST_STATIC_CONSTEXPR std::size_t real_nodes_per_block = NodesPerBlock; + + BOOST_CONTAINER_DOCIGN(BOOST_CONTAINER_STATIC_ASSERT((Version <=2))); + + public: + //------- + typedef T value_type; + typedef T * pointer; + typedef const T * const_pointer; + typedef typename ::boost::container:: + dtl::unvoid_ref::type reference; + typedef typename ::boost::container:: + dtl::unvoid_ref::type const_reference; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + typedef boost::container::dtl:: + version_type version; + + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + typedef boost::container::dtl:: + basic_multiallocation_chain multiallocation_chain_void; + typedef boost::container::dtl:: + transform_multiallocation_chain + multiallocation_chain; + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + + //!Obtains adaptive_pool from + //!adaptive_pool + template + struct rebind + { + typedef adaptive_pool + < T2 + , NodesPerBlock + , MaxFreeBlocks + , OverheadPercent + BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I Version) + > other; + }; + + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + private: + //!Not assignable from related adaptive_pool + template + adaptive_pool& operator= + (const adaptive_pool&); + + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + + public: + //!Default constructor + adaptive_pool() BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!Copy constructor from other adaptive_pool. + adaptive_pool(const adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!Copy assignment from other adaptive_pool. + adaptive_pool & operator=(const adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW + { return *this; } + + //!Copy constructor from related adaptive_pool. + template + adaptive_pool + (const adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!Destructor + ~adaptive_pool() BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!Returns the number of elements that could be allocated. + //!Never throws + size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW + { return size_type(-1)/(2u*sizeof(T)); } + + //!Allocate memory for an array of count elements. + //!Throws bad_alloc if there is no enough memory + pointer allocate(size_type count, const void * = 0) + { + if(BOOST_UNLIKELY(count > size_type(-1)/(2u*sizeof(T)))) + boost::container::throw_bad_alloc(); + + if(Version == 1 && count == 1){ + typedef typename dtl::shared_adaptive_node_pool + shared_pool_t; + typedef dtl::singleton_default singleton_t; + return pointer(static_cast(singleton_t::instance().allocate_node())); + } + else{ + return static_cast(dlmalloc_malloc(count*sizeof(T))); + } + } + + //!Deallocate allocated memory. + //!Never throws + void deallocate(const pointer &ptr, size_type count) BOOST_NOEXCEPT_OR_NOTHROW + { + (void)count; + if(Version == 1 && count == 1){ + typedef dtl::shared_adaptive_node_pool + shared_pool_t; + typedef dtl::singleton_default singleton_t; + singleton_t::instance().deallocate_node(ptr); + } + else{ + dlmalloc_free(ptr); + } + } + + pointer allocation_command(allocation_type command, + size_type limit_size, + size_type &prefer_in_recvd_out_size, + pointer &reuse) + { + pointer ret = this->priv_allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse); + if(BOOST_UNLIKELY(!ret && !(command & BOOST_CONTAINER_NOTHROW_ALLOCATION))) + boost::container::throw_bad_alloc(); + return ret; + } + + //!Returns maximum the number of objects the previously allocated memory + //!pointed by p can hold. + size_type size(pointer p) const BOOST_NOEXCEPT_OR_NOTHROW + { return dlmalloc_size(p); } + + //!Allocates just one object. Memory allocated with this function + //!must be deallocated only with deallocate_one(). + //!Throws bad_alloc if there is no enough memory + pointer allocate_one() + { + typedef dtl::shared_adaptive_node_pool + shared_pool_t; + typedef dtl::singleton_default singleton_t; + return (pointer)singleton_t::instance().allocate_node(); + } + + //!Allocates many elements of size == 1. + //!Elements must be individually deallocated with deallocate_one() + void allocate_individual(std::size_t num_elements, multiallocation_chain &chain) + { + typedef dtl::shared_adaptive_node_pool + shared_pool_t; + typedef dtl::singleton_default singleton_t; + singleton_t::instance().allocate_nodes(num_elements, static_cast(chain)); + //typename shared_pool_t::multiallocation_chain ch; + //singleton_t::instance().allocate_nodes(num_elements, ch); + //chain.incorporate_after + //(chain.before_begin(), (T*)&*ch.begin(), (T*)&*ch.last(), ch.size()); + } + + //!Deallocates memory previously allocated with allocate_one(). + //!You should never use deallocate_one to deallocate memory allocated + //!with other functions different from allocate_one(). Never throws + void deallocate_one(pointer p) BOOST_NOEXCEPT_OR_NOTHROW + { + typedef dtl::shared_adaptive_node_pool + shared_pool_t; + typedef dtl::singleton_default singleton_t; + singleton_t::instance().deallocate_node(p); + } + + void deallocate_individual(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW + { + typedef dtl::shared_adaptive_node_pool + shared_pool_t; + typedef dtl::singleton_default singleton_t; + //typename shared_pool_t::multiallocation_chain ch(&*chain.begin(), &*chain.last(), chain.size()); + //singleton_t::instance().deallocate_nodes(ch); + singleton_t::instance().deallocate_nodes(chain); + } + + //!Allocates many elements of size elem_size. + //!Elements must be individually deallocated with deallocate() + void allocate_many(size_type elem_size, std::size_t n_elements, multiallocation_chain &chain) + { + BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));/* + dlmalloc_memchain ch; + BOOST_CONTAINER_MEMCHAIN_INIT(&ch); + if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch))){ + boost::container::throw_bad_alloc(); + } + chain.incorporate_after(chain.before_begin() + ,(T*)BOOST_CONTAINER_MEMCHAIN_FIRSTMEM(&ch) + ,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch) + ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );*/ + if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes + ( n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS + , move_detail::force_ptr(&chain)))){ + boost::container::throw_bad_alloc(); + } + } + + //!Allocates n_elements elements, each one of size elem_sizes[i] + //!Elements must be individually deallocated with deallocate() + void allocate_many(const size_type *elem_sizes, size_type n_elements, multiallocation_chain &chain) + { + BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));/* + dlmalloc_memchain ch; + BOOST_CONTAINER_MEMCHAIN_INIT(&ch); + if(BOOST_UNLIKELY(!dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch))){ + boost::container::throw_bad_alloc(); + } + chain.incorporate_after(chain.before_begin() + ,(T*)BOOST_CONTAINER_MEMCHAIN_FIRSTMEM(&ch) + ,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch) + ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );*/ + if(BOOST_UNLIKELY(!dlmalloc_multialloc_arrays + ( n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS + , move_detail::force_ptr(&chain)))){ + boost::container::throw_bad_alloc(); + } + } + + void deallocate_many(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW + {/* + dlmalloc_memchain ch; + void *beg(&*chain.begin()), *last(&*chain.last()); + size_t size(chain.size()); + BOOST_CONTAINER_MEMCHAIN_INIT_FROM(&ch, beg, last, size); + dlmalloc_multidealloc(&ch);*/ + dlmalloc_multidealloc(move_detail::force_ptr(&chain)); + } + + //!Deallocates all free blocks of the pool + static void deallocate_free_blocks() BOOST_NOEXCEPT_OR_NOTHROW + { + typedef dtl::shared_adaptive_node_pool + shared_pool_t; + typedef dtl::singleton_default singleton_t; + singleton_t::instance().deallocate_free_blocks(); + } + + //!Swaps allocators. Does not throw. If each allocator is placed in a + //!different memory segment, the result is undefined. + friend void swap(adaptive_pool &, adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!An allocator always compares to true, as memory allocated with one + //!instance can be deallocated by another instance + friend bool operator==(const adaptive_pool &, const adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW + { return true; } + + //!An allocator always compares to false, as memory allocated with one + //!instance can be deallocated by another instance + friend bool operator!=(const adaptive_pool &, const adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW + { return false; } + + private: + pointer priv_allocation_command + (allocation_type command, std::size_t limit_size + ,size_type &prefer_in_recvd_out_size, pointer &reuse_ptr) + { + std::size_t const preferred_size = prefer_in_recvd_out_size; + dlmalloc_command_ret_t ret = {0 , 0}; + if(BOOST_UNLIKELY(limit_size > this->max_size() || preferred_size > this->max_size())){ + return pointer(); + } + std::size_t l_size = limit_size*sizeof(T); + std::size_t p_size = preferred_size*sizeof(T); + std::size_t r_size; + { + void* reuse_ptr_void = reuse_ptr; + ret = dlmalloc_allocation_command(command, sizeof(T), l_size, p_size, &r_size, reuse_ptr_void); + reuse_ptr = ret.second ? static_cast(reuse_ptr_void) : 0; + } + prefer_in_recvd_out_size = r_size/sizeof(T); + return (pointer)ret.first; + } +}; + + + + + + + + + + + + + + + + + + + + +template < class T + , std::size_t NodesPerBlock = ADP_nodes_per_block + , std::size_t MaxFreeBlocks = ADP_max_free_blocks + , std::size_t OverheadPercent = ADP_overhead_percent + , unsigned Version = 2 + > +class private_adaptive_pool +{ + //!If Version is 1, the allocator is a STL conforming allocator. If Version is 2, + //!the allocator offers advanced expand in place and burst allocation capabilities. + public: + typedef unsigned int allocation_type; + typedef private_adaptive_pool + self_t; + + BOOST_STATIC_CONSTEXPR std::size_t nodes_per_block = NodesPerBlock; + BOOST_STATIC_CONSTEXPR std::size_t max_free_blocks = MaxFreeBlocks; + BOOST_STATIC_CONSTEXPR std::size_t overhead_percent = OverheadPercent; + BOOST_STATIC_CONSTEXPR std::size_t real_nodes_per_block = NodesPerBlock; + + BOOST_CONTAINER_DOCIGN(BOOST_CONTAINER_STATIC_ASSERT((Version <=2))); + + typedef dtl::private_adaptive_node_pool + pool_t; + pool_t m_pool; + + public: + //------- + typedef T value_type; + typedef T * pointer; + typedef const T * const_pointer; + typedef typename ::boost::container:: + dtl::unvoid_ref::type reference; + typedef typename ::boost::container:: + dtl::unvoid_ref::type const_reference; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + typedef boost::container::dtl:: + version_type version; + + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + typedef boost::container::dtl:: + basic_multiallocation_chain multiallocation_chain_void; + typedef boost::container::dtl:: + transform_multiallocation_chain + multiallocation_chain; + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + + //!Obtains private_adaptive_pool from + //!private_adaptive_pool + template + struct rebind + { + typedef private_adaptive_pool + < T2 + , NodesPerBlock + , MaxFreeBlocks + , OverheadPercent + BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I Version) + > other; + }; + + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + private: + //!Not assignable from related private_adaptive_pool + template + private_adaptive_pool& operator= + (const private_adaptive_pool&); + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + + public: + //!Default constructor + private_adaptive_pool() BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!Copy constructor from other private_adaptive_pool. + private_adaptive_pool(const private_adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!Copy assignment from other adaptive_pool. + private_adaptive_pool & operator=(const private_adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW + { return *this; } + + //!Copy constructor from related private_adaptive_pool. + template + private_adaptive_pool + (const private_adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!Destructor + ~private_adaptive_pool() BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!Returns the number of elements that could be allocated. + //!Never throws + size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW + { return size_type(-1)/(2u*sizeof(T)); } + + //!Allocate memory for an array of count elements. + //!Throws bad_alloc if there is no enough memory + pointer allocate(size_type count, const void * = 0) + { + if(BOOST_UNLIKELY(count > size_type(-1)/(2u*sizeof(T)))) + boost::container::throw_bad_alloc(); + + if(Version == 1 && count == 1){ + return pointer(static_cast(m_pool.allocate_node())); + } + else{ + return static_cast(dlmalloc_malloc(count*sizeof(T))); + } + } + + //!Deallocate allocated memory. + //!Never throws + void deallocate(const pointer &ptr, size_type count) BOOST_NOEXCEPT_OR_NOTHROW + { + (void)count; + if(Version == 1 && count == 1){ + m_pool.deallocate_node(ptr); + } + else{ + dlmalloc_free(ptr); + } + } + + pointer allocation_command(allocation_type command, + size_type limit_size, + size_type &prefer_in_recvd_out_size, + pointer &reuse) + { + pointer ret = this->priv_allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse); + if(BOOST_UNLIKELY(!ret && !(command & BOOST_CONTAINER_NOTHROW_ALLOCATION))) + boost::container::throw_bad_alloc(); + return ret; + } + + //!Returns maximum the number of objects the previously allocated memory + //!pointed by p can hold. + size_type size(pointer p) const BOOST_NOEXCEPT_OR_NOTHROW + { return dlmalloc_size(p); } + + //!Allocates just one object. Memory allocated with this function + //!must be deallocated only with deallocate_one(). + //!Throws bad_alloc if there is no enough memory + pointer allocate_one() + { + return (pointer)m_pool.allocate_node(); + } + + //!Allocates many elements of size == 1. + //!Elements must be individually deallocated with deallocate_one() + void allocate_individual(std::size_t num_elements, multiallocation_chain &chain) + { + m_pool.allocate_nodes(num_elements, static_cast(chain)); + } + + //!Deallocates memory previously allocated with allocate_one(). + //!You should never use deallocate_one to deallocate memory allocated + //!with other functions different from allocate_one(). Never throws + void deallocate_one(pointer p) BOOST_NOEXCEPT_OR_NOTHROW + { + m_pool.deallocate_node(p); + } + + void deallocate_individual(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW + { + m_pool.deallocate_nodes(chain); + } + + //!Allocates many elements of size elem_size. + //!Elements must be individually deallocated with deallocate() + void allocate_many(size_type elem_size, std::size_t n_elements, multiallocation_chain &chain) + { + BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 )); + if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes + ( n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS + , move_detail::force_ptr(&chain)))){ + boost::container::throw_bad_alloc(); + } + } + + //!Allocates n_elements elements, each one of size elem_sizes[i] + //!Elements must be individually deallocated with deallocate() + void allocate_many(const size_type *elem_sizes, size_type n_elements, multiallocation_chain &chain) + { + BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 )); + if(BOOST_UNLIKELY(!dlmalloc_multialloc_arrays + (n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS + , move_detail::force_ptr(&chain)))){ + boost::container::throw_bad_alloc(); + } + } + + void deallocate_many(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW + { + dlmalloc_multidealloc(move_detail::force_ptr(&chain)); + } + + //!Deallocates all free blocks of the pool + void deallocate_free_blocks() BOOST_NOEXCEPT_OR_NOTHROW + { + m_pool.deallocate_free_blocks(); + } + + //!Swaps allocators. Does not throw. If each allocator is placed in a + //!different memory segment, the result is undefined. + friend void swap(private_adaptive_pool &, private_adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!An allocator always compares to true, as memory allocated with one + //!instance can be deallocated by another instance + friend bool operator==(const private_adaptive_pool &, const private_adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW + { return true; } + + //!An allocator always compares to false, as memory allocated with one + //!instance can be deallocated by another instance + friend bool operator!=(const private_adaptive_pool &, const private_adaptive_pool &) BOOST_NOEXCEPT_OR_NOTHROW + { return false; } + + private: + pointer priv_allocation_command + (allocation_type command, std::size_t limit_size + ,size_type &prefer_in_recvd_out_size, pointer &reuse_ptr) + { + std::size_t const preferred_size = prefer_in_recvd_out_size; + dlmalloc_command_ret_t ret = {0 , 0}; + if(BOOST_UNLIKELY(limit_size > this->max_size() || preferred_size > this->max_size())){ + return pointer(); + } + std::size_t l_size = limit_size*sizeof(T); + std::size_t p_size = preferred_size*sizeof(T); + std::size_t r_size; + { + void* reuse_ptr_void = reuse_ptr; + ret = dlmalloc_allocation_command(command, sizeof(T), l_size, p_size, &r_size, reuse_ptr_void); + reuse_ptr = ret.second ? static_cast(reuse_ptr_void) : 0; + } + prefer_in_recvd_out_size = r_size/sizeof(T); + return (pointer)ret.first; + } +}; + +} //namespace container { +} //namespace boost { + +#include + +#endif //#ifndef BOOST_CONTAINER_ADAPTIVE_POOL_HPP diff --git a/boost/include/boost/container/allocator.hpp b/boost/include/boost/container/allocator.hpp new file mode 100644 index 00000000..68a158c0 --- /dev/null +++ b/boost/include/boost/container/allocator.hpp @@ -0,0 +1,376 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2007-2013. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_CONTAINER_ALLOCATOR_HPP +#define BOOST_CONTAINER_ALLOCATOR_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +//!\file + +namespace boost { +namespace container { + +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +template +class allocator +{ + typedef allocator self_t; + public: + typedef void value_type; + typedef void * pointer; + typedef const void* const_pointer; + typedef int & reference; + typedef const int & const_reference; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef boost::container::dtl:: + version_type version; + + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + typedef boost::container::dtl:: + basic_multiallocation_chain multiallocation_chain; + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + + //!Obtains an allocator that allocates + //!objects of type T2 + template + struct rebind + { + typedef allocator< T2 + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + , Version, AllocationDisableMask + #endif + > other; + }; + + //!Default constructor + //!Never throws + allocator() + {} + + //!Constructor from other allocator. + //!Never throws + allocator(const allocator &) + {} + + //!Constructor from related allocator. + //!Never throws + template + allocator(const allocator &) + {} +}; + +#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +//! This class is an extended STL-compatible that offers advanced allocation mechanism +//!(in-place expansion, shrinking, burst-allocation...) +//! +//! This allocator is a wrapper around a modified DLmalloc. +//! If Version is 1, the allocator is a STL conforming allocator. If Version is 2, +//! the allocator offers advanced expand in place and burst allocation capabilities. +//! +//! AllocationDisableMask works only if Version is 2 and it can be an inclusive OR +//! of allocation types the user wants to disable. +template< class T + , unsigned Version BOOST_CONTAINER_DOCONLY(=2) + , unsigned int AllocationDisableMask BOOST_CONTAINER_DOCONLY(=0)> +class allocator +{ + typedef unsigned int allocation_type; + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + private: + + //Self type + typedef allocator self_t; + + //Not assignable from related allocator + template + allocator& operator=(const allocator&); + + BOOST_STATIC_CONSTEXPR unsigned int ForbiddenMask = + BOOST_CONTAINER_ALLOCATE_NEW | BOOST_CONTAINER_EXPAND_BWD | BOOST_CONTAINER_EXPAND_FWD ; + + //The mask can't disable all the allocation types + BOOST_CONTAINER_STATIC_ASSERT(( (AllocationDisableMask & ForbiddenMask) != ForbiddenMask )); + + //The mask is only valid for version 2 allocators + BOOST_CONTAINER_STATIC_ASSERT(( Version != 1 || (AllocationDisableMask == 0) )); + + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + + public: + typedef T value_type; + typedef T * pointer; + typedef const T * const_pointer; + typedef T & reference; + typedef const T & const_reference; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + typedef boost::container::dtl:: + version_type version; + + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + typedef boost::container::dtl:: + basic_multiallocation_chain void_multiallocation_chain; + + typedef boost::container::dtl:: + transform_multiallocation_chain + multiallocation_chain; + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + + //!Obtains an allocator that allocates + //!objects of type T2 + template + struct rebind + { + typedef allocator other; + }; + + //!Default constructor + //!Never throws + allocator() BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!Constructor from other allocator. + //!Never throws + allocator(const allocator &) BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!Constructor from related allocator. + //!Never throws + template + allocator(const allocator &) BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!Allocates memory for an array of count elements. + //!Throws bad_alloc if there is no enough memory + //!If Version is 2, this allocated memory can only be deallocated + //!with deallocate() or (for Version == 2) deallocate_many() + BOOST_CONTAINER_ATTRIBUTE_NODISCARD pointer allocate(size_type count, const void * hint= 0) + { + (void)hint; + if(count > size_type(-1)/(2u*sizeof(T))) + boost::container::throw_bad_alloc(); + void *ret = dlmalloc_malloc(count*sizeof(T)); + if(!ret) + boost::container::throw_bad_alloc(); + return static_cast(ret); + } + + //!Deallocates previously allocated memory. + //!Never throws + inline void deallocate(pointer ptr, size_type) BOOST_NOEXCEPT_OR_NOTHROW + { dlmalloc_free(ptr); } + + //!Returns the maximum number of elements that could be allocated. + //!Never throws + inline size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW + { return size_type(-1)/(2u*sizeof(T)); } + + //!Swaps two allocators, does nothing + //!because this allocator is stateless + inline friend void swap(self_t &, self_t &) BOOST_NOEXCEPT_OR_NOTHROW + {} + + //!An allocator always compares to true, as memory allocated with one + //!instance can be deallocated by another instance + BOOST_CONTAINER_ATTRIBUTE_NODISCARD + friend bool operator==(const allocator &, const allocator &) BOOST_NOEXCEPT_OR_NOTHROW + { return true; } + + //!An allocator always compares to false, as memory allocated with one + //!instance can be deallocated by another instance + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator!=(const allocator &, const allocator &) BOOST_NOEXCEPT_OR_NOTHROW + { return false; } + + //!An advanced function that offers in-place expansion shrink to fit and new allocation + //!capabilities. Memory allocated with this function can only be deallocated with deallocate() + //!or deallocate_many(). + //!This function is available only with Version == 2 + BOOST_CONTAINER_ATTRIBUTE_NODISCARD pointer allocation_command(allocation_type command, + size_type limit_size, + size_type &prefer_in_recvd_out_size, + pointer &reuse) + { + BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 )); + const allocation_type mask(AllocationDisableMask); + command &= ~mask; + pointer ret = this->priv_allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse); + if(!ret && !(command & BOOST_CONTAINER_NOTHROW_ALLOCATION)) + boost::container::throw_bad_alloc(); + return ret; + } + + //!Returns maximum the number of objects the previously allocated memory + //!pointed by p can hold. + //!Memory must not have been allocated with + //!allocate_one or allocate_individual. + //!This function is available only with Version == 2 + BOOST_CONTAINER_ATTRIBUTE_NODISCARD size_type size(pointer p) const BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 )); + return dlmalloc_size(p); + } + + //!Allocates just one object. Memory allocated with this function + //!must be deallocated only with deallocate_one(). + //!Throws bad_alloc if there is no enough memory + //!This function is available only with Version == 2 + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline pointer allocate_one() + { + BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 )); + return this->allocate(1); + } + + //!Allocates many elements of size == 1. + //!Elements must be individually deallocated with deallocate_one() + //!This function is available only with Version == 2 + inline void allocate_individual(std::size_t num_elements, multiallocation_chain &chain) + { + BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 )); + this->allocate_many(1, num_elements, chain); + } + + //!Deallocates memory previously allocated with allocate_one(). + //!You should never use deallocate_one to deallocate memory allocated + //!with other functions different from allocate_one() or allocate_individual. + //Never throws + void deallocate_one(pointer p) BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 )); + return this->deallocate(p, 1); + } + + //!Deallocates memory allocated with allocate_one() or allocate_individual(). + //!This function is available only with Version == 2 + inline + void deallocate_individual(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 )); + return this->deallocate_many(chain); + } + + //!Allocates many elements of size elem_size. + //!Elements must be individually deallocated with deallocate() + //!This function is available only with Version == 2 + void allocate_many(size_type elem_size, std::size_t n_elements, multiallocation_chain &chain) + { + BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 )); + dlmalloc_memchain ch; + BOOST_CONTAINER_MEMCHAIN_INIT(&ch); + if(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch)){ + boost::container::throw_bad_alloc(); + } + chain.incorporate_after(chain.before_begin() + ,(T*)BOOST_CONTAINER_MEMCHAIN_FIRSTMEM(&ch) + ,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch) + ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) ); +/* + if(!dlmalloc_multialloc_nodes( n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS + , move_detail::force_ptr(&chain))){ + boost::container::throw_bad_alloc(); + }*/ + } + + //!Allocates n_elements elements, each one of size elem_sizes[i] + //!Elements must be individually deallocated with deallocate() + //!This function is available only with Version == 2 + void allocate_many(const size_type *elem_sizes, size_type n_elements, multiallocation_chain &chain) + { + BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 )); + dlmalloc_memchain ch; + BOOST_CONTAINER_MEMCHAIN_INIT(&ch); + if(!dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch)){ + boost::container::throw_bad_alloc(); + } + chain.incorporate_after(chain.before_begin() + ,(T*)BOOST_CONTAINER_MEMCHAIN_FIRSTMEM(&ch) + ,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch) + ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) ); + /* + if(!dlmalloc_multialloc_arrays( n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS + , move_detail::force_ptr(&chain))){ + boost::container::throw_bad_alloc(); + }*/ + } + + //!Deallocates several elements allocated by + //!allocate_many(), allocate(), or allocation_command(). + //!This function is available only with Version == 2 + void deallocate_many(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 )); + dlmalloc_memchain ch; + void *beg(&*chain.begin()), *last(&*chain.last()); + size_t size(chain.size()); + BOOST_CONTAINER_MEMCHAIN_INIT_FROM(&ch, beg, last, size); + dlmalloc_multidealloc(&ch); + //dlmalloc_multidealloc(move_detail::force_ptr(&chain)); + } + + private: + + pointer priv_allocation_command + (allocation_type command, std::size_t limit_size + ,size_type &prefer_in_recvd_out_size + ,pointer &reuse_ptr) + { + std::size_t const preferred_size = prefer_in_recvd_out_size; + dlmalloc_command_ret_t ret = {0 , 0}; + if((limit_size > this->max_size()) || (preferred_size > this->max_size())){ + return pointer(); + } + std::size_t l_size = limit_size*sizeof(T); + std::size_t p_size = preferred_size*sizeof(T); + std::size_t r_size; + { + void* reuse_ptr_void = reuse_ptr; + ret = dlmalloc_allocation_command(command, sizeof(T), l_size, p_size, &r_size, reuse_ptr_void); + reuse_ptr = ret.second ? static_cast(reuse_ptr_void) : 0; + } + prefer_in_recvd_out_size = r_size/sizeof(T); + return (pointer)ret.first; + } +}; + +} //namespace container { +} //namespace boost { + +#include + +#endif //BOOST_CONTAINER_ALLOCATOR_HPP + diff --git a/boost/include/boost/container/allocator_traits.hpp b/boost/include/boost/container/allocator_traits.hpp new file mode 100644 index 00000000..dd5bf0e4 --- /dev/null +++ b/boost/include/boost/container/allocator_traits.hpp @@ -0,0 +1,641 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Pablo Halpern 2009. 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) +// +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2011-2013. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// +#ifndef BOOST_CONTAINER_ALLOCATOR_ALLOCATOR_TRAITS_HPP +#define BOOST_CONTAINER_ALLOCATOR_ALLOCATOR_TRAITS_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include + +// container +#include +#include +#include //is_empty +#include +#include +#include +#ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP +#include +#endif +// intrusive +#include +#include +// move +#include +// move/detail +#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) +#include +#endif + +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +#if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-result" +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#endif + +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME allocate +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace dtl { +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END }}} +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 2 +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 2 +#include + +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME destroy +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace dtl { +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END }}} +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 1 +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 1 +#include + +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME construct +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace dtl { +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END }}} +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 1 +#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 9 +#include + +#if defined(BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED) +#pragma GCC diagnostic pop +#endif + +#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +namespace boost { +namespace container { +namespace dtl { + +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + +template +BOOST_CONTAINER_FORCEINLINE void construct_type(T *p, BOOST_FWD_REF(Args) ...args) +{ + ::new((void*)p, boost_container_new_t()) T(::boost::forward(args)...); +} + +template < class Pair, class KeyType, class ... Args> +typename dtl::enable_if< dtl::is_pair, void >::type +construct_type + (Pair* p, try_emplace_t, BOOST_FWD_REF(KeyType) k, BOOST_FWD_REF(Args) ...args) +{ + construct_type(dtl::addressof(p->first), ::boost::forward(k)); + BOOST_CONTAINER_TRY{ + construct_type(dtl::addressof(p->second), ::boost::forward(args)...); + } + BOOST_CONTAINER_CATCH(...) { + typedef typename Pair::first_type first_type; + dtl::addressof(p->first)->~first_type(); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END +} + +#else + +#define BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPEJ(N) \ +template\ +BOOST_CONTAINER_FORCEINLINE \ + typename dtl::disable_if_c::value, void >::type \ +construct_type(T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\ +{\ + ::new((void*)p, boost_container_new_t()) T( BOOST_MOVE_FWD##N );\ +}\ +// +BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPEJ) +#undef BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPEJ + +#define BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPE(N) \ +template < class Pair, class KeyType BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\ +typename dtl::enable_if< dtl::is_pair, void >::type construct_type\ + (Pair* p, try_emplace_t, BOOST_FWD_REF(KeyType) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\ +{\ + construct_type(dtl::addressof(p->first), ::boost::forward(k));\ + BOOST_CONTAINER_TRY{\ + construct_type(dtl::addressof(p->second) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\ + }\ + BOOST_CONTAINER_CATCH(...) {\ + typedef typename Pair::first_type first_type;\ + dtl::addressof(p->first)->~first_type();\ + BOOST_CONTAINER_RETHROW\ + }\ + BOOST_CONTAINER_CATCH_END\ +}\ +// +BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPE) +#undef BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_TYPE + +#endif + +template +inline +typename dtl::enable_if, void >::type +construct_type(T* p) +{ + dtl::construct_type(dtl::addressof(p->first)); + BOOST_CONTAINER_TRY{ + dtl::construct_type(dtl::addressof(p->second)); + } + BOOST_CONTAINER_CATCH(...) { + typedef typename T::first_type first_type; + dtl::addressof(p->first)->~first_type(); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END +} + + +template +inline +typename dtl::enable_if_c + < dtl::is_pair::value + , void >::type +construct_type(T* p, U &u) +{ + dtl::construct_type(dtl::addressof(p->first), u.first); + BOOST_CONTAINER_TRY{ + dtl::construct_type(dtl::addressof(p->second), u.second); + } + BOOST_CONTAINER_CATCH(...) { + typedef typename T::first_type first_type; + dtl::addressof(p->first)->~first_type(); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END +} + +template +inline +typename dtl::enable_if_c + < dtl::is_pair::type>::value && + !boost::move_detail::is_reference::value //This is needed for MSVC10 and ambiguous overloads + , void >::type +construct_type(T* p, BOOST_RV_REF(U) u) +{ + dtl::construct_type(dtl::addressof(p->first), ::boost::move(u.first)); + BOOST_CONTAINER_TRY{ + dtl::construct_type(dtl::addressof(p->second), ::boost::move(u.second)); + } + BOOST_CONTAINER_CATCH(...) { + typedef typename T::first_type first_type; + dtl::addressof(p->first)->~first_type(); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END +} + +template +inline +typename dtl::enable_if, void >::type +construct_type(T* p, BOOST_FWD_REF(U) x, BOOST_FWD_REF(V) y) +{ + dtl::construct_type(dtl::addressof(p->first), ::boost::forward(x)); + BOOST_CONTAINER_TRY{ + dtl::construct_type(dtl::addressof(p->second), ::boost::forward(y)); + } + BOOST_CONTAINER_CATCH(...) { + typedef typename T::first_type first_type; + dtl::addressof(p->first)->~first_type(); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END +} + +} //namespace dtl + +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +template +class small_vector_allocator; + +namespace allocator_traits_detail { + +BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_max_size, max_size) +BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_select_on_container_copy_construction, select_on_container_copy_construction) + +} //namespace allocator_traits_detail { + +namespace dtl { + +//workaround needed for C++03 compilers with no construct() +//supporting rvalue references +template +struct is_std_allocator +{ BOOST_STATIC_CONSTEXPR bool value = false; }; + +template +struct is_std_allocator< std::allocator > +{ BOOST_STATIC_CONSTEXPR bool value = true; }; + +template +struct is_std_allocator< small_vector_allocator, Options > > +{ BOOST_STATIC_CONSTEXPR bool value = true; }; + +template +struct is_not_std_allocator +{ BOOST_STATIC_CONSTEXPR bool value = !is_std_allocator::value; }; + +BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(pointer) +BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(const_pointer) +BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(reference) +BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(const_reference) +BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(void_pointer) +BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(const_void_pointer) +BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(size_type) +BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(propagate_on_container_copy_assignment) +BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(propagate_on_container_move_assignment) +BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(propagate_on_container_swap) +BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(is_always_equal) +BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type) +BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(is_partially_propagable) + +} //namespace dtl { + +#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +//! The class template allocator_traits supplies a uniform interface to all allocator types. +//! This class is a C++03-compatible implementation of std::allocator_traits +template +struct allocator_traits +{ + //allocator_type + typedef Allocator allocator_type; + //value_type + typedef typename allocator_type::value_type value_type; + + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + //! Allocator::pointer if such a type exists; otherwise, value_type* + //! + typedef unspecified pointer; + //! Allocator::const_pointer if such a type exists ; otherwise, pointer_traits::rebind::rebind. + //! + typedef see_documentation void_pointer; + //! Allocator::const_void_pointer if such a type exists ; otherwise, pointer_traits::rebind::difference_type. + //! + typedef see_documentation difference_type; + //! Allocator::size_type if such a type exists ; otherwise, make_unsigned::type + //! + typedef see_documentation size_type; + //! Allocator::propagate_on_container_copy_assignment if such a type exists, otherwise a type + //! with an internal constant static boolean member value == false. + typedef see_documentation propagate_on_container_copy_assignment; + //! Allocator::propagate_on_container_move_assignment if such a type exists, otherwise a type + //! with an internal constant static boolean member value == false. + typedef see_documentation propagate_on_container_move_assignment; + //! Allocator::propagate_on_container_swap if such a type exists, otherwise a type + //! with an internal constant static boolean member value == false. + typedef see_documentation propagate_on_container_swap; + //! Allocator::is_always_equal if such a type exists, otherwise a type + //! with an internal constant static boolean member value == is_empty::value + typedef see_documentation is_always_equal; + //! Allocator::is_partially_propagable if such a type exists, otherwise a type + //! with an internal constant static boolean member value == false + //! Note: Non-standard extension used to implement `small_vector_allocator`. + typedef see_documentation is_partially_propagable; + //! Defines an allocator: Allocator::rebind::other if such a type exists; otherwise, Allocator + //! if Allocator is a class template instantiation of the form Allocator, where Args is zero or + //! more type arguments ; otherwise, the instantiation of rebind_alloc is ill-formed. + //! + //! In C++03 compilers rebind_alloc is a struct derived from an allocator + //! deduced by previously detailed rules. + template using rebind_alloc = see_documentation; + + //! In C++03 compilers rebind_traits is a struct derived from + //! allocator_traits, where OtherAlloc is + //! the allocator deduced by rules explained in rebind_alloc. + template using rebind_traits = allocator_traits >; + + //! Non-standard extension: Portable allocator rebind for C++03 and C++11 compilers. + //! type is an allocator related to Allocator deduced deduced by rules explained in rebind_alloc. + template + struct portable_rebind_alloc + { typedef see_documentation type; }; + #else + //pointer + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator, + pointer, value_type*) + pointer; + //const_pointer + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::dtl::, Allocator, + const_pointer, typename boost::intrusive::pointer_traits::template + rebind_pointer) + const_pointer; + //reference + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator, + reference, typename dtl::unvoid_ref::type) + reference; + //const_reference + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator, + const_reference, typename dtl::unvoid_ref::type) + const_reference; + //void_pointer + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::dtl::, Allocator, + void_pointer, typename boost::intrusive::pointer_traits::template + rebind_pointer) + void_pointer; + //const_void_pointer + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::dtl::, Allocator, + const_void_pointer, typename boost::intrusive::pointer_traits::template + rebind_pointer) + const_void_pointer; + //difference_type + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator, + difference_type, std::ptrdiff_t) + difference_type; + //size_type + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator, + size_type, std::size_t) + size_type; + //propagate_on_container_copy_assignment + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator, + propagate_on_container_copy_assignment, dtl::false_type) + propagate_on_container_copy_assignment; + //propagate_on_container_move_assignment + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator, + propagate_on_container_move_assignment, dtl::false_type) + propagate_on_container_move_assignment; + //propagate_on_container_swap + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator, + propagate_on_container_swap, dtl::false_type) + propagate_on_container_swap; + //is_always_equal + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator, + is_always_equal, dtl::is_empty) + is_always_equal; + //is_partially_propagable + typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator, + is_partially_propagable, dtl::false_type) + is_partially_propagable; + + //rebind_alloc & rebind_traits + #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + //C++11 + template using rebind_alloc = typename boost::intrusive::pointer_rebind::type; + template using rebind_traits = allocator_traits< rebind_alloc >; + #else // #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + //Some workaround for C++03 or C++11 compilers with no template aliases + template + struct rebind_alloc : boost::intrusive::pointer_rebind::type + { + typedef typename boost::intrusive::pointer_rebind::type Base; + #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + template + rebind_alloc(BOOST_FWD_REF(Args)... args) : Base(boost::forward(args)...) {} + #else // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + #define BOOST_CONTAINER_ALLOCATOR_TRAITS_REBIND_ALLOC(N) \ + BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\ + explicit rebind_alloc(BOOST_MOVE_UREF##N) : Base(BOOST_MOVE_FWD##N){}\ + // + BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_ALLOCATOR_TRAITS_REBIND_ALLOC) + #undef BOOST_CONTAINER_ALLOCATOR_TRAITS_REBIND_ALLOC + #endif // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + }; + + template + struct rebind_traits + : allocator_traits::type> + {}; + #endif // #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + + //portable_rebind_alloc + template + struct portable_rebind_alloc + { typedef typename boost::intrusive::pointer_rebind::type type; }; + #endif //BOOST_CONTAINER_DOXYGEN_INVOKED + + //! Returns: a.allocate(n) + //! + inline static pointer allocate(Allocator &a, size_type n) + { return a.allocate(n); } + + //! Returns: a.deallocate(p, n) + //! + //! Throws: Nothing + inline static void deallocate(Allocator &a, pointer p, size_type n) + { a.deallocate(p, n); } + + //! Effects: calls a.allocate(n, p) if that call is well-formed; + //! otherwise, invokes a.allocate(n) + inline static pointer allocate(Allocator &a, size_type n, const_void_pointer p) + { + const bool value = boost::container::dtl:: + has_member_function_callable_with_allocate + ::value; + dtl::bool_ flag; + return allocator_traits::priv_allocate(flag, a, n, p); + } + + //! Effects: calls a.destroy(p) if that call is well-formed; + //! otherwise, invokes p->~T(). + template + inline static void destroy(Allocator &a, T*p) BOOST_NOEXCEPT_OR_NOTHROW + { + typedef T* destroy_pointer; + const bool value = boost::container::dtl:: + has_member_function_callable_with_destroy + ::value; + dtl::bool_ flag; + allocator_traits::priv_destroy(flag, a, p); + } + + //! Returns: a.max_size() if that expression is well-formed; otherwise, + //! numeric_limits::max(). + inline static size_type max_size(const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW + { + const bool value = allocator_traits_detail::has_max_size::value; + dtl::bool_ flag; + return allocator_traits::priv_max_size(flag, a); + } + + //! Returns: a.select_on_container_copy_construction() if that expression is well-formed; + //! otherwise, a. + inline static BOOST_CONTAINER_DOC1ST(Allocator, + typename dtl::if_c + < allocator_traits_detail::has_select_on_container_copy_construction::value + BOOST_MOVE_I Allocator BOOST_MOVE_I const Allocator & >::type) + select_on_container_copy_construction(const Allocator &a) + { + const bool value = allocator_traits_detail::has_select_on_container_copy_construction + ::value; + dtl::bool_ flag; + return allocator_traits::priv_select_on_container_copy_construction(flag, a); + } + + #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + //! Effects: calls a.construct(p, std::forward(args)...) if that call is well-formed; + //! otherwise, invokes `placement new` (static_cast(p)) T(std::forward(args)...) + template + inline static void construct(Allocator & a, T* p, BOOST_FWD_REF(Args)... args) + { + BOOST_STATIC_CONSTEXPR bool value = ::boost::move_detail::and_ + < dtl::is_not_std_allocator + , boost::container::dtl::has_member_function_callable_with_construct + < Allocator, T*, Args... > + >::value; + dtl::bool_ flag; + allocator_traits::priv_construct(flag, a, p, ::boost::forward(args)...); + } + #endif + + //! Returns: a.storage_is_unpropagable(p) if is_partially_propagable::value is true; otherwise, + //! false. + inline static bool storage_is_unpropagable(const Allocator &a, pointer p) BOOST_NOEXCEPT_OR_NOTHROW + { + dtl::bool_ flag; + return allocator_traits::priv_storage_is_unpropagable(flag, a, p); + } + + //! Returns: true if is_always_equal::value == true, otherwise, + //! a == b. + inline static bool equal(const Allocator &a, const Allocator &b) BOOST_NOEXCEPT_OR_NOTHROW + { + dtl::bool_ flag; + return allocator_traits::priv_equal(flag, a, b); + } + + #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + private: + inline static pointer priv_allocate(dtl::true_type, Allocator &a, size_type n, const_void_pointer p) + { return a.allocate(n, p); } + + inline static pointer priv_allocate(dtl::false_type, Allocator &a, size_type n, const_void_pointer) + { return a.allocate(n); } + + template + inline static void priv_destroy(dtl::true_type, Allocator &a, T* p) BOOST_NOEXCEPT_OR_NOTHROW + { a.destroy(p); } + + template + inline static void priv_destroy(dtl::false_type, Allocator &, T* p) BOOST_NOEXCEPT_OR_NOTHROW + { p->~T(); (void)p; } + + inline static size_type priv_max_size(dtl::true_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW + { return a.max_size(); } + + inline static size_type priv_max_size(dtl::false_type, const Allocator &) BOOST_NOEXCEPT_OR_NOTHROW + { return size_type(-1)/sizeof(value_type); } + + inline static Allocator priv_select_on_container_copy_construction(dtl::true_type, const Allocator &a) + { return a.select_on_container_copy_construction(); } + + inline static const Allocator &priv_select_on_container_copy_construction(dtl::false_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW + { return a; } + + #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + template + inline static void priv_construct(dtl::true_type, Allocator &a, T *p, BOOST_FWD_REF(Args) ...args) + { a.construct( p, ::boost::forward(args)...); } + + template + inline static void priv_construct(dtl::false_type, Allocator &, T *p, BOOST_FWD_REF(Args) ...args) + { dtl::construct_type(p, ::boost::forward(args)...); } + #else // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + public: + + #define BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_IMPL(N) \ + template\ + inline static void construct(Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\ + {\ + BOOST_STATIC_CONSTEXPR bool value = ::boost::move_detail::and_ \ + < dtl::is_not_std_allocator \ + , boost::container::dtl::has_member_function_callable_with_construct \ + < Allocator, T* BOOST_MOVE_I##N BOOST_MOVE_FWD_T##N > \ + >::value; \ + dtl::bool_ flag;\ + (priv_construct)(flag, a, p BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\ + }\ + // + BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_IMPL) + #undef BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_IMPL + + private: + ///////////////////////////////// + // priv_construct + ///////////////////////////////// + #define BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL(N) \ + template\ + inline static void priv_construct(dtl::true_type, Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\ + { a.construct( p BOOST_MOVE_I##N BOOST_MOVE_FWD##N ); }\ + \ + template\ + inline static void priv_construct(dtl::false_type, Allocator &, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\ + { dtl::construct_type(p BOOST_MOVE_I##N BOOST_MOVE_FWD##N); }\ + // + BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL) + #undef BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL + + #endif // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + + template + inline static void priv_construct(dtl::false_type, Allocator &, T *p, const ::boost::container::default_init_t&) + { ::new((void*)p, boost_container_new_t()) T; } + + inline static bool priv_storage_is_unpropagable(dtl::true_type, const Allocator &a, pointer p) + { return a.storage_is_unpropagable(p); } + + inline static bool priv_storage_is_unpropagable(dtl::false_type, const Allocator &, pointer) + { return false; } + + inline static bool priv_equal(dtl::true_type, const Allocator &, const Allocator &) + { return true; } + + inline static bool priv_equal(dtl::false_type, const Allocator &a, const Allocator &b) + { return a == b; } + + #endif //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) +}; + +#if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + +template +struct real_allocator +{ + typedef AllocatorOrVoid type; +}; + +template +struct real_allocator +{ + typedef new_allocator type; +}; + +#endif //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + +} //namespace container { +} //namespace boost { + +#include + +#endif // ! defined(BOOST_CONTAINER_ALLOCATOR_ALLOCATOR_TRAITS_HPP) diff --git a/boost/include/boost/container/container_fwd.hpp b/boost/include/boost/container/container_fwd.hpp new file mode 100644 index 00000000..2525b7d2 --- /dev/null +++ b/boost/include/boost/container/container_fwd.hpp @@ -0,0 +1,390 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2005-2014. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_CONTAINER_CONTAINER_FWD_HPP +#define BOOST_CONTAINER_CONTAINER_FWD_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#include + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +//! \file +//! This header file forward declares the following containers: +//! - boost::container::vector +//! - boost::container::stable_vector +//! - boost::container::static_vector +//! - boost::container::small_vector_base +//! - boost::container::small_vector +//! - boost::container::devector +//! - boost::container::slist +//! - boost::container::list +//! - boost::container::set +//! - boost::container::multiset +//! - boost::container::map +//! - boost::container::multimap +//! - boost::container::flat_set +//! - boost::container::flat_multiset +//! - boost::container::flat_map +//! - boost::container::flat_multimap +//! - boost::container::basic_string +//! - boost::container::string +//! - boost::container::wstring +//! +//! Forward declares the following allocators: +//! - boost::container::allocator +//! - boost::container::node_allocator +//! - boost::container::adaptive_pool +//! +//! Forward declares the following polymorphic resource classes: +//! - boost::container::pmr::memory_resource +//! - boost::container::pmr::polymorphic_allocator +//! - boost::container::pmr::monotonic_buffer_resource +//! - boost::container::pmr::pool_options +//! - boost::container::pmr::unsynchronized_pool_resource +//! - boost::container::pmr::synchronized_pool_resource +//! +//! And finally it defines the following types + +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +//Std forward declarations +#ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP + #include +#endif + +namespace boost{ +namespace intrusive{ +namespace detail{ + //Create namespace to avoid compilation errors +}}} + +namespace boost{ namespace container{ namespace dtl{ + namespace bi = boost::intrusive; + namespace bid = boost::intrusive::detail; +}}} + +namespace boost{ namespace container{ namespace pmr{ + namespace bi = boost::intrusive; + namespace bid = boost::intrusive::detail; +}}} + +#include + +#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +////////////////////////////////////////////////////////////////////////////// +// Containers +////////////////////////////////////////////////////////////////////////////// + +namespace boost { +namespace container { + +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +template +class new_allocator; + +template +class vector; + +template +class stable_vector; + +template < class T + , std::size_t Capacity + , class Options = void> +class static_vector; + +template < class T + , class Allocator = void + , class Options = void > +class small_vector_base; + +template < class T + , std::size_t N + , class Allocator = void + , class Options = void > +class small_vector; + +template +class devector; + +template +class deque; + +template +class list; + +template +class slist; + +template + ,class Allocator = void + ,class Options = void> +class set; + +template + ,class Allocator = void + ,class Options = void > +class multiset; + +template + ,class Allocator = void + ,class Options = void > +class map; + +template + ,class Allocator = void + ,class Options = void > +class multimap; + +template + ,class Allocator = void > +class flat_set; + +template + ,class Allocator = void > +class flat_multiset; + +template + ,class Allocator = void > +class flat_map; + +template + ,class Allocator = void > +class flat_multimap; + +#ifndef BOOST_NO_CXX11_TEMPLATE_ALIASES + +//! Alias templates for small_flat_[multi]{set|map} using small_vector as container + +template < class Key + , std::size_t N + , class Compare = std::less + , class SmallVectorAllocator = void + , class SmallVectorOptions = void > +using small_flat_set = flat_set>; + +template < class Key + , std::size_t N + , class Compare = std::less + , class SmallVectorAllocator = void + , class SmallVectorOptions = void > +using small_flat_multiset = flat_multiset>; + +template < class Key + , class T + , std::size_t N + , class Compare = std::less + , class SmallVectorAllocator = void + , class SmallVectorOptions = void > +using small_flat_map = flat_map, N, SmallVectorAllocator, SmallVectorOptions>>; + +template < class Key + , class T + , std::size_t N + , class Compare = std::less + , class SmallVectorAllocator = void + , class SmallVectorOptions = void > +using small_flat_multimap = flat_multimap, N, SmallVectorAllocator, SmallVectorOptions>>; + +#endif // #ifndef BOOST_NO_CXX11_TEMPLATE_ALIASES + + +//! A portable metafunction to obtain a small_flat_set +template < class Key + , std::size_t N + , class Compare = std::less + , class SmallVectorAllocator = void + , class SmallVectorOptions = void > +struct small_flat_set_of +{ + typedef flat_set > type; +}; + +//! A portable metafunction to obtain a small_flat_multiset +template < class Key + , std::size_t N + , class Compare = std::less + , class SmallVectorAllocator = void + , class SmallVectorOptions = void > +struct small_flat_multiset_of +{ + typedef flat_multiset > type; +}; + +//! A portable metafunction to obtain a small_flat_map +template < class Key + , class T + , std::size_t N + , class Compare = std::less + , class SmallVectorAllocator = void + , class SmallVectorOptions = void > +struct small_flat_map_of +{ + typedef flat_map, N, SmallVectorAllocator, SmallVectorOptions> > type; +}; + +//! A portable metafunction to obtain a small_flat_multimap +template < class Key + , class T + , std::size_t N + , class Compare = std::less + , class SmallVectorAllocator = void + , class SmallVectorOptions = void > +struct small_flat_multimap_of +{ + typedef flat_multimap, N, SmallVectorAllocator, SmallVectorOptions> > type; +}; + +template + ,class Allocator = void > +class basic_string; + +typedef basic_string string; +typedef basic_string wstring; + +BOOST_STATIC_CONSTEXPR std::size_t ADP_nodes_per_block = 256u; +BOOST_STATIC_CONSTEXPR std::size_t ADP_max_free_blocks = 2u; +BOOST_STATIC_CONSTEXPR std::size_t ADP_overhead_percent = 1u; +BOOST_STATIC_CONSTEXPR std::size_t ADP_only_alignment = 0u; + +template < class T + , std::size_t NodesPerBlock = ADP_nodes_per_block + , std::size_t MaxFreeBlocks = ADP_max_free_blocks + , std::size_t OverheadPercent = ADP_overhead_percent + , unsigned Version = 2 + > +class adaptive_pool; + +template < class T + , unsigned Version = 2 + , unsigned int AllocationDisableMask = 0> +class allocator; + +BOOST_STATIC_CONSTEXPR std::size_t NodeAlloc_nodes_per_block = 256u; + +template + < class T + , std::size_t NodesPerBlock = NodeAlloc_nodes_per_block + , std::size_t Version = 2> +class node_allocator; + +namespace pmr { + +class memory_resource; + +template +class polymorphic_allocator; + +class monotonic_buffer_resource; + +struct pool_options; + +template +class resource_adaptor_imp; + +class unsynchronized_pool_resource; + +class synchronized_pool_resource; + +} //namespace pmr { + +#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +//! Type used to tag that the input range is +//! guaranteed to be ordered +struct ordered_range_t +{}; + +//! Value used to tag that the input range is +//! guaranteed to be ordered +BOOST_CONTAINER_CONSTANT_VAR ordered_range_t ordered_range = ordered_range_t(); + +//! Type used to tag that the input range is +//! guaranteed to be ordered and unique +struct ordered_unique_range_t + : public ordered_range_t +{}; + +//! Value used to tag that the input range is +//! guaranteed to be ordered and unique +BOOST_CONTAINER_CONSTANT_VAR ordered_unique_range_t ordered_unique_range = ordered_unique_range_t(); + +//! Type used to tag that the inserted values +//! should be default initialized +struct default_init_t +{}; + +//! Value used to tag that the inserted values +//! should be default initialized +BOOST_CONTAINER_CONSTANT_VAR default_init_t default_init = default_init_t(); +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +//! Type used to tag that the inserted values +//! should be value initialized +struct value_init_t +{}; + +//! Value used to tag that the inserted values +//! should be value initialized +BOOST_CONTAINER_CONSTANT_VAR value_init_t value_init = value_init_t(); + +namespace container_detail_really_deep_namespace { + +//Otherwise, gcc issues a warning of previously defined +//anonymous_instance and unique_instance +struct dummy +{ + dummy() + { + (void)ordered_range; + (void)ordered_unique_range; + (void)default_init; + } +}; + +} //detail_really_deep_namespace { + +typedef const std::piecewise_construct_t & piecewise_construct_t; + +#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +}} //namespace boost { namespace container { + +#endif //#ifndef BOOST_CONTAINER_CONTAINER_FWD_HPP diff --git a/boost/include/boost/container/deque.hpp b/boost/include/boost/container/deque.hpp new file mode 100644 index 00000000..da24ad0d --- /dev/null +++ b/boost/include/boost/container/deque.hpp @@ -0,0 +1,2883 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2005-2015. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// +#ifndef BOOST_CONTAINER_DEQUE_HPP +#define BOOST_CONTAINER_DEQUE_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include +// container +#include +#include +#include //new_allocator +#include +#include +// container/detail +#include +#include //algo_equal(), algo_lexicographical_compare +#include +#include +#include +#include +#include +#include +#include +#include +#include +// move +#include +#include +#include +#include +// move/detail +#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) +#include +#endif +#include +// other +#include +// std +#include + +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) +#include +#endif + +namespace boost { +namespace container { + +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED +template +class deque; + +template +struct deque_value_traits +{ + typedef T value_type; + BOOST_STATIC_CONSTEXPR bool trivial_dctr = dtl::is_trivially_destructible::value; + BOOST_STATIC_CONSTEXPR bool trivial_dctr_after_move = ::boost::has_trivial_destructor_after_move::value; +}; + +template +struct deque_block_size +{ + BOOST_CONTAINER_STATIC_ASSERT_MSG(!(BlockBytes && BlockSize), "BlockBytes and BlockSize can't be specified at the same time"); + BOOST_STATIC_CONSTEXPR std::size_t block_bytes = BlockBytes ? BlockBytes : 512u; + BOOST_STATIC_CONSTEXPR std::size_t value = BlockSize ? BlockSize : (sizeof(T) < block_bytes ? (block_bytes/sizeof(T)) : std::size_t(1)); +}; + +namespace dtl { + +// Class invariants: +// For any nonsingular iterator i: +// i.node is the address of an element in the map array. The +// contents of i.node is a pointer to the beginning of a node. +// i.first == //(i.node) +// i.last == i.first + node_size +// i.cur is a pointer in the range [i.first, i.last). NOTE: +// the implication of this is that i.cur is always a dereferenceable +// pointer, even if i is a past-the-end iterator. +// Start and Finish are always nonsingular iterators. NOTE: this means +// that an empty deque must have one node, and that a deque +// with N elements, where N is the buffer size, must have two nodes. +// For every node other than start.node and finish.node, every element +// in the node is an initialized object. If start.node == finish.node, +// then [start.cur, finish.cur) are initialized objects, and +// the elements outside that range are uninitialized storage. Otherwise, +// [start.cur, start.last) and [finish.first, finish.cur) are initialized +// objects, and [start.first, start.cur) and [finish.cur, finish.last) +// are uninitialized storage. +// [map, map + map_size) is a valid, non-empty range. +// [start.node, finish.node] is a valid range contained within +// [map, map + map_size). +// A pointer in the range [map, map + map_size) points to an allocated node +// if and only if the pointer is in the range [start.node, finish.node]. + +#define BOOST_CONTAINER_DEQUE_LIGHTER_ITERATOR_LEVEL 0 + +#if BOOST_CONTAINER_DEQUE_LIGHTER_ITERATOR_LEVEL == 0 +template +class deque_iterator +{ + public: + typedef std::random_access_iterator_tag iterator_category; + typedef typename boost::intrusive::pointer_traits::element_type value_type; + typedef typename boost::intrusive::pointer_traits::difference_type difference_type; + typedef typename boost::intrusive::pointer_traits::size_type size_type; + typedef typename if_c + < IsConst + , typename boost::intrusive::pointer_traits::template + rebind_pointer::type + , Pointer + >::type pointer; + typedef typename if_c + < IsConst + , const value_type& + , value_type& + >::type reference; + + class nat; + typedef typename dtl::if_c< IsConst + , deque_iterator + , nat>::type nonconst_iterator; + + typedef Pointer val_alloc_ptr; + typedef typename boost::intrusive::pointer_traits:: + template rebind_pointer::type index_pointer; + + Pointer m_cur; + Pointer m_first; + Pointer m_last; + index_pointer m_node; + + public: + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_cur() const { return m_cur; } + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_first() const { return m_first; } + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_last() const { return m_last; } + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline index_pointer get_node() const { return m_node; } + + inline deque_iterator(val_alloc_ptr x, index_pointer y, difference_type block_size) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(x), m_first(*y), m_last(*y + block_size), m_node(y) + {} + + inline deque_iterator(val_alloc_ptr x, index_pointer y, size_type block_size) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(x), m_first(*y), m_last(*y + difference_type(block_size)), m_node(y) + {} + + inline deque_iterator() BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(), m_first(), m_last(), m_node() //Value initialization to achieve "null iterators" (N3644) + {} + + inline deque_iterator(const deque_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(x.get_cur()), m_first(x.get_first()), m_last(x.get_last()), m_node(x.get_node()) + {} + + inline deque_iterator(const nonconst_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(x.get_cur()), m_first(x.get_first()), m_last(x.get_last()), m_node(x.get_node()) + {} + + inline deque_iterator(Pointer cur, Pointer first, Pointer last, index_pointer node) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(cur), m_first(first), m_last(last), m_node(node) + {} + + inline deque_iterator& operator=(const deque_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW + { m_cur = x.get_cur(); m_first = x.get_first(); m_last = x.get_last(); m_node = x.get_node(); return *this; } + + inline deque_iterator unconst() const BOOST_NOEXCEPT_OR_NOTHROW + { + return deque_iterator(this->get_cur(), this->get_first(), this->get_last(), this->get_node()); + } + + inline reference operator*() const BOOST_NOEXCEPT_OR_NOTHROW + { return *this->m_cur; } + + inline pointer operator->() const BOOST_NOEXCEPT_OR_NOTHROW + { return this->m_cur; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD difference_type operator-(const deque_iterator& x) const BOOST_NOEXCEPT_OR_NOTHROW + { + if(!this->m_cur && !x.m_cur){ + return 0; + } + const difference_type block_size = m_last - m_first; + BOOST_ASSERT(block_size); + return block_size * (this->m_node - x.m_node - 1) + + (this->m_cur - this->m_first) + (x.m_last - x.m_cur); + } + + deque_iterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(!!m_cur); + ++this->m_cur; + if (this->m_cur == this->m_last) { + const difference_type block_size = m_last - m_first; + BOOST_ASSERT(block_size); + this->priv_set_node(this->m_node + 1, block_size); + this->m_cur = this->m_first; + } + return *this; + } + + inline deque_iterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW + { + deque_iterator tmp(*this); + ++*this; + return tmp; + } + + deque_iterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(!!m_cur); + if (this->m_cur == this->m_first) { + const difference_type block_size = m_last - m_first; + BOOST_ASSERT(block_size); + this->priv_set_node(this->m_node - 1, block_size); + this->m_cur = this->m_last; + } + --this->m_cur; + return *this; + } + + inline deque_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW + { + deque_iterator tmp(*this); + --*this; + return tmp; + } + + deque_iterator& operator+=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW + { + if (!n) + return *this; + BOOST_ASSERT(!!m_cur); + const difference_type offset = n + (this->m_cur - this->m_first); + const difference_type block_size = m_last - m_first; + BOOST_ASSERT(block_size); + if (offset >= 0 && offset < block_size) + this->m_cur += difference_type(n); + else { + const difference_type node_offset = + offset > 0 ? (offset / block_size) + : (-difference_type((-offset - 1) / block_size) - 1); + this->priv_set_node(this->m_node + node_offset, size_type(block_size)); + this->m_cur = this->m_first + + (offset - node_offset * block_size); + } + return *this; + } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + deque_iterator operator+(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW + { deque_iterator tmp(*this); return tmp += n; } + + inline + deque_iterator& operator-=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW + { return *this += -n; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + deque_iterator operator-(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW + { deque_iterator tmp(*this); return tmp -= n; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + reference operator[](difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW + { return *(*this + n); } + + //Comparisons + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator==(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return l.m_cur == r.m_cur; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator!=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return l.m_cur != r.m_cur; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator<(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return (l.m_node == r.m_node) ? (l.m_cur < r.m_cur) : (l.m_node < r.m_node); } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator>(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return r < l; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator<=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return !(r < l); } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator>=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return !(l < r); } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend deque_iterator operator+(difference_type n, deque_iterator x) BOOST_NOEXCEPT_OR_NOTHROW + { return x += n; } + + inline void priv_set_node(index_pointer new_node, size_type block_size) BOOST_NOEXCEPT_OR_NOTHROW + { return this->priv_set_node(new_node, difference_type(block_size)); } + + inline void priv_set_node(index_pointer new_node, difference_type block_size) BOOST_NOEXCEPT_OR_NOTHROW + { + this->m_node = new_node; + this->m_first = *new_node; + this->m_last = this->m_first + block_size; + } +}; + +#elif BOOST_CONTAINER_DEQUE_LIGHTER_ITERATOR_LEVEL == 1 + +template +class deque_iterator +{ + public: + typedef std::random_access_iterator_tag iterator_category; + typedef typename boost::intrusive::pointer_traits::element_type value_type; + typedef typename boost::intrusive::pointer_traits::difference_type difference_type; + typedef typename boost::intrusive::pointer_traits::size_type size_type; + typedef typename if_c + < IsConst + , typename boost::intrusive::pointer_traits::template + rebind_pointer::type + , Pointer + >::type pointer; + typedef typename if_c + < IsConst + , const value_type& + , value_type& + >::type reference; + + BOOST_CONSTEXPR inline static size_type get_block_size() BOOST_NOEXCEPT_OR_NOTHROW + { return deque_block_size::value; } + + BOOST_CONSTEXPR inline static difference_type get_block_ssize() BOOST_NOEXCEPT_OR_NOTHROW + { return difference_type((get_block_size())); } + + class nat; + typedef typename dtl::if_c< IsConst + , deque_iterator + , nat>::type nonconst_iterator; + + typedef Pointer val_alloc_ptr; + typedef typename boost::intrusive::pointer_traits:: + template rebind_pointer::type index_pointer; + + Pointer m_cur; + Pointer m_first; + index_pointer m_node; + + public: + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_cur() const { return m_cur; } + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_first() const { return m_first; } + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_last() const { return m_first + get_block_ssize(); } + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline index_pointer get_node() const { return m_node; } + + inline deque_iterator(val_alloc_ptr x, index_pointer y, difference_type ) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(x), m_first(*y), m_node(y) + {} + + inline deque_iterator(val_alloc_ptr x, index_pointer y, size_type ) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(x), m_first(*y), m_node(y) + {} + + inline deque_iterator() BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(), m_first(), m_node() //Value initialization to achieve "null iterators" (N3644) + {} + + inline deque_iterator(const deque_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(x.get_cur()), m_first(x.get_first()), m_node(x.get_node()) + {} + + inline deque_iterator(const nonconst_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(x.get_cur()), m_first(x.get_first()), m_node(x.get_node()) + {} + + inline deque_iterator(Pointer cur, Pointer first, index_pointer node) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(cur), m_first(first), m_node(node) + {} + + inline deque_iterator& operator=(const deque_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW + { m_cur = x.get_cur(); m_first = x.get_first(); m_node = x.get_node(); return *this; } + + inline nonconst_iterator unconst() const BOOST_NOEXCEPT_OR_NOTHROW + { + return nonconst_iterator(this->get_cur(), this->get_first(), this->get_node()); + } + + inline reference operator*() const BOOST_NOEXCEPT_OR_NOTHROW + { return *this->m_cur; } + + inline pointer operator->() const BOOST_NOEXCEPT_OR_NOTHROW + { return this->m_cur; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD difference_type operator-(const deque_iterator& x) const BOOST_NOEXCEPT_OR_NOTHROW + { + if(!this->m_cur && !x.m_cur){ + return 0; + } + const difference_type block_size = get_block_ssize(); + BOOST_ASSERT(block_size); + return block_size * (this->m_node - x.m_node - 1) + + (this->m_cur - this->m_first) + ((x.m_first+block_size) - x.m_cur); + } + + deque_iterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(!!m_cur); + ++this->m_cur; + const difference_type block_size = get_block_ssize(); + if (this->m_cur == (this->m_first+block_size)) { + + BOOST_ASSERT(block_size); + ++this->m_node; + this->m_first = *this->m_node; + this->m_cur = this->m_first; + } + return *this; + } + + inline deque_iterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW + { + deque_iterator tmp(*this); + ++*this; + return tmp; + } + + deque_iterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(!!m_cur); + if (this->m_cur == this->m_first) { + --this->m_node; + this->m_first = *this->m_node; + this->m_cur = this->m_first + get_block_ssize(); + } + --this->m_cur; + return *this; + } + + inline deque_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW + { + deque_iterator tmp(*this); + --*this; + return tmp; + } + + deque_iterator& operator+=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW + { + if (!n) + return *this; + BOOST_ASSERT(!!m_cur); + const difference_type offset = n + (this->m_cur - this->m_first); + const difference_type block_size = get_block_ssize(); + BOOST_ASSERT(block_size); + if (offset >= 0 && offset < block_size) + this->m_cur += difference_type(n); + else { + const difference_type node_offset = + offset > 0 ? (offset / block_size) + : (-difference_type((-offset - 1) / block_size) - 1); + this->m_node += node_offset; + this->m_first = *this->m_node; + this->m_cur = this->m_first + (offset - node_offset * block_size); + } + return *this; + } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + deque_iterator operator+(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW + { deque_iterator tmp(*this); return tmp += n; } + + inline + deque_iterator& operator-=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW + { return *this += -n; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + deque_iterator operator-(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW + { deque_iterator tmp(*this); return tmp -= n; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + reference operator[](difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW + { return *(*this + n); } + + //Comparisons + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator==(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return l.m_cur == r.m_cur; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator!=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return l.m_cur != r.m_cur; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator<(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return (l.m_node == r.m_node) ? (l.m_cur < r.m_cur) : (l.m_node < r.m_node); } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator>(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return r < l; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator<=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return !(r < l); } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator>=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return !(l < r); } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend deque_iterator operator+(difference_type n, deque_iterator x) BOOST_NOEXCEPT_OR_NOTHROW + { return x += n; } + + inline void priv_set_node(index_pointer new_node, size_type ) BOOST_NOEXCEPT_OR_NOTHROW + { return this->priv_set_node(new_node, difference_type()); } + + inline void priv_set_node(index_pointer new_node, difference_type) BOOST_NOEXCEPT_OR_NOTHROW + { + this->m_node = new_node; + this->m_first = *new_node; + } +}; + +#elif BOOST_CONTAINER_DEQUE_LIGHTER_ITERATOR_LEVEL == 2 + +template +class deque_iterator +{ + public: + typedef std::random_access_iterator_tag iterator_category; + typedef typename boost::intrusive::pointer_traits::element_type value_type; + typedef typename boost::intrusive::pointer_traits::difference_type difference_type; + typedef typename boost::intrusive::pointer_traits::size_type size_type; + typedef typename if_c + < IsConst + , typename boost::intrusive::pointer_traits::template + rebind_pointer::type + , Pointer + >::type pointer; + typedef typename if_c + < IsConst + , const value_type& + , value_type& + >::type reference; + + BOOST_CONSTEXPR inline static size_type get_block_size() BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_CONTAINER_STATIC_ASSERT((deque_block_size::value)); + return deque_block_size::value; + } + + BOOST_CONSTEXPR inline static difference_type get_block_ssize() BOOST_NOEXCEPT_OR_NOTHROW + { return difference_type((get_block_size())); } + + class nat; + typedef typename dtl::if_c< IsConst + , deque_iterator + , nat>::type nonconst_iterator; + + typedef Pointer val_alloc_ptr; + typedef typename boost::intrusive::pointer_traits:: + template rebind_pointer::type index_pointer; + + Pointer m_cur; + index_pointer m_node; + + public: + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_cur() const { return m_cur; } + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_first() const { return *m_node; } + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_last() const { return *m_node + get_block_ssize(); } + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline index_pointer get_node() const { return m_node; } + + inline deque_iterator(val_alloc_ptr x, index_pointer y, difference_type ) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(x), m_node(y) + {} + + inline deque_iterator(val_alloc_ptr x, index_pointer y, size_type ) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(x), m_node(y) + {} + + inline deque_iterator() BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(), m_node() //Value initialization to achieve "null iterators" (N3644) + {} + + inline deque_iterator(const deque_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(x.get_cur()), m_node(x.get_node()) + {} + + inline deque_iterator(const nonconst_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(x.get_cur()), m_node(x.get_node()) + {} + + inline deque_iterator(Pointer cur, index_pointer node) BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(cur), m_node(node) + {} + + inline deque_iterator& operator=(const deque_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW + { m_cur = x.get_cur(); m_node = x.get_node(); return *this; } + + inline nonconst_iterator unconst() const BOOST_NOEXCEPT_OR_NOTHROW + { + return nonconst_iterator(this->get_cur(), this->get_node()); + } + + inline reference operator*() const BOOST_NOEXCEPT_OR_NOTHROW + { return *this->m_cur; } + + inline pointer operator->() const BOOST_NOEXCEPT_OR_NOTHROW + { return this->m_cur; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD difference_type operator-(const deque_iterator& x) const BOOST_NOEXCEPT_OR_NOTHROW + { + if(!this->m_cur && !x.m_cur){ + return 0; + } + const difference_type block_size = get_block_ssize(); + BOOST_ASSERT(block_size); + return block_size * (this->m_node - x.m_node - 1) + + (this->m_cur - this->get_first()) + (x.get_last() - x.m_cur); + } + + deque_iterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(!!m_cur); + ++this->m_cur; + if (this->m_cur == (this->get_last())) { + + ++this->m_node; + this->m_cur = *this->m_node; + } + return *this; + } + + inline deque_iterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW + { + deque_iterator tmp(*this); + ++*this; + return tmp; + } + + deque_iterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(!!m_cur); + if (this->m_cur == this->get_first()) { + --this->m_node; + this->m_cur = this->get_last(); + } + --this->m_cur; + return *this; + } + + inline deque_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW + { + deque_iterator tmp(*this); + --*this; + return tmp; + } + + deque_iterator& operator+=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW + { + if (!n) + return *this; + BOOST_ASSERT(!!m_cur); + const difference_type offset = n + (this->m_cur - this->get_first()); + const difference_type block_size = get_block_ssize(); + BOOST_ASSERT(block_size); + if (offset >= 0 && offset < block_size) + this->m_cur += difference_type(n); + else { + const difference_type node_offset = + offset > 0 ? (offset / block_size) + : (-difference_type((-offset - 1) / block_size) - 1); + this->m_node += node_offset; + this->m_cur = this->get_first() + (offset - node_offset * block_size); + } + return *this; + } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + deque_iterator operator+(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW + { deque_iterator tmp(*this); return tmp += n; } + + inline + deque_iterator& operator-=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW + { return *this += -n; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + deque_iterator operator-(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW + { deque_iterator tmp(*this); return tmp -= n; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + reference operator[](difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(!!m_cur); + const difference_type offset = n + (this->m_cur - this->get_first()); + const difference_type block_size = get_block_ssize(); + if (offset >= 0 && offset < block_size) + return this->m_cur[difference_type(n)]; + else { + const difference_type node_offset = offset > 0 + ? (offset / block_size) + : (-difference_type((-offset - 1) / block_size) - 1); + return (this->m_node[node_offset]) [offset - node_offset * block_size]; + } + } + + //Comparisons + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator==(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return l.m_cur == r.m_cur; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator!=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return l.m_cur != r.m_cur; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator<(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return (l.m_node == r.m_node) ? (l.m_cur < r.m_cur) : (l.m_node < r.m_node); } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator>(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return r < l; } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator<=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return !(r < l); } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator>=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW + { return !(l < r); } + + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend deque_iterator operator+(difference_type n, deque_iterator x) BOOST_NOEXCEPT_OR_NOTHROW + { return x += n; } + + inline void priv_set_node(index_pointer new_node, size_type ) BOOST_NOEXCEPT_OR_NOTHROW + { return this->priv_set_node(new_node, difference_type()); } + + inline void priv_set_node(index_pointer new_node, difference_type) BOOST_NOEXCEPT_OR_NOTHROW + { + this->m_node = new_node; + } +}; + +#else + +#error "Invalid BOOST_CONTAINER_DEQUE_LIGHTER_ITERATOR_LEVEL" + +#endif +} //namespace dtl { + +template +struct get_deque_opt +{ + typedef Options type; +}; + +template<> +struct get_deque_opt +{ + typedef deque_null_opt type; +}; + +// Deque base class. It has two purposes. First, its constructor +// and destructor allocate (but don't initialize) storage. This makes +// exception safety easier. +template +class deque_base +{ + BOOST_COPYABLE_AND_MOVABLE(deque_base) + public: + typedef allocator_traits val_alloc_traits_type; + typedef typename val_alloc_traits_type::value_type val_alloc_val; + typedef typename val_alloc_traits_type::pointer val_alloc_ptr; + typedef typename val_alloc_traits_type::const_pointer val_alloc_cptr; + typedef typename val_alloc_traits_type::reference val_alloc_ref; + typedef typename val_alloc_traits_type::const_reference val_alloc_cref; + typedef typename val_alloc_traits_type::difference_type val_alloc_diff; + typedef typename val_alloc_traits_type::size_type val_alloc_size; + typedef typename val_alloc_traits_type::template + portable_rebind_alloc::type ptr_alloc_t; + typedef allocator_traits ptr_alloc_traits_type; + typedef typename ptr_alloc_traits_type::value_type ptr_alloc_val; + typedef typename ptr_alloc_traits_type::pointer ptr_alloc_ptr; + typedef typename ptr_alloc_traits_type::const_pointer ptr_alloc_cptr; + typedef typename ptr_alloc_traits_type::reference ptr_alloc_ref; + typedef typename ptr_alloc_traits_type::const_reference ptr_alloc_cref; + typedef Allocator allocator_type; + typedef allocator_type stored_allocator_type; + typedef val_alloc_size size_type; + typedef val_alloc_diff difference_type; + + private: + typedef typename get_deque_opt::type options_type; + + protected: + #if BOOST_CONTAINER_DEQUE_LIGHTER_ITERATOR_LEVEL == 0 + typedef dtl::deque_iterator iterator; + typedef dtl::deque_iterator const_iterator; + #else + typedef dtl::deque_iterator iterator; + typedef dtl::deque_iterator const_iterator; + #endif + + BOOST_CONSTEXPR inline static val_alloc_diff get_block_ssize() BOOST_NOEXCEPT_OR_NOTHROW + { return val_alloc_diff((get_block_size())); } + + BOOST_CONSTEXPR inline static size_type get_block_size() BOOST_NOEXCEPT_OR_NOTHROW + { return deque_block_size::value; } + + typedef deque_value_traits traits_t; + typedef ptr_alloc_t map_allocator_type; + + inline val_alloc_ptr priv_allocate_node() + { return this->alloc().allocate(get_block_size()); } + + inline void priv_deallocate_node(val_alloc_ptr p) BOOST_NOEXCEPT_OR_NOTHROW + { this->alloc().deallocate(p, get_block_size()); } + + inline ptr_alloc_ptr priv_allocate_map(size_type n) + { return this->ptr_alloc().allocate(n); } + + inline void priv_deallocate_map(ptr_alloc_ptr p, size_type n) BOOST_NOEXCEPT_OR_NOTHROW + { this->ptr_alloc().deallocate(p, n); } + + inline deque_base(size_type num_elements, const allocator_type& a) + : members_(a) + { this->priv_initialize_map(num_elements); } + + inline explicit deque_base(const allocator_type& a) + : members_(a) + {} + + inline deque_base() + : members_() + {} + + inline explicit deque_base(BOOST_RV_REF(deque_base) x) + : members_( boost::move(x.ptr_alloc()) + , boost::move(x.alloc()) ) + {} + + ~deque_base() + { + if (this->members_.m_map) { + this->priv_destroy_nodes(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1); + this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size); + } + } + + private: + deque_base(const deque_base&); + + protected: + + void swap_members(deque_base &x) BOOST_NOEXCEPT_OR_NOTHROW + { + ::boost::adl_move_swap(this->members_.m_start, x.members_.m_start); + ::boost::adl_move_swap(this->members_.m_finish, x.members_.m_finish); + ::boost::adl_move_swap(this->members_.m_map, x.members_.m_map); + ::boost::adl_move_swap(this->members_.m_map_size, x.members_.m_map_size); + } + + void priv_initialize_map(size_type num_elements) + { +// if(num_elements){ + size_type num_nodes = num_elements / get_block_size() + 1; + + this->members_.m_map_size = dtl::max_value((size_type) InitialMapSize, num_nodes + 2); + this->members_.m_map = this->priv_allocate_map(this->members_.m_map_size); + + ptr_alloc_ptr nstart = this->members_.m_map + difference_type(this->members_.m_map_size - num_nodes) / 2; + ptr_alloc_ptr nfinish = nstart + difference_type(num_nodes); + + BOOST_CONTAINER_TRY { + this->priv_create_nodes(nstart, nfinish); + } + BOOST_CONTAINER_CATCH(...){ + this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size); + this->members_.m_map = 0; + this->members_.m_map_size = 0; + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + + this->members_.m_start.priv_set_node(nstart, get_block_size()); + this->members_.m_finish.priv_set_node(nfinish - 1, get_block_size()); + this->members_.m_start.m_cur = this->members_.m_start.get_first(); + this->members_.m_finish.m_cur = this->members_.m_finish.get_first() + difference_type(num_elements % get_block_size()); +// } + } + + void priv_create_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish) + { + ptr_alloc_ptr cur = nstart; + BOOST_CONTAINER_TRY { + for (; cur < nfinish; ++cur) + *cur = this->priv_allocate_node(); + } + BOOST_CONTAINER_CATCH(...){ + this->priv_destroy_nodes(nstart, cur); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + } + + void priv_destroy_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish) BOOST_NOEXCEPT_OR_NOTHROW + { + for (ptr_alloc_ptr n = nstart; n < nfinish; ++n) + this->priv_deallocate_node(*n); + } + + void priv_clear_map() BOOST_NOEXCEPT_OR_NOTHROW + { + if (this->members_.m_map) { + this->priv_destroy_nodes(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1); + this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size); + this->members_.m_map = 0; + this->members_.m_map_size = 0; + this->members_.m_start = iterator(); + this->members_.m_finish = this->members_.m_start; + } + } + + enum { InitialMapSize = 8 }; + + protected: + struct members_holder + : public ptr_alloc_t + , public allocator_type + { + members_holder() + : map_allocator_type(), allocator_type() + , m_map(0), m_map_size(0) + , m_start(), m_finish(m_start) + {} + + explicit members_holder(const allocator_type &a) + : map_allocator_type(a), allocator_type(a) + , m_map(0), m_map_size(0) + , m_start(), m_finish(m_start) + {} + + template + members_holder(BOOST_FWD_REF(PtrAllocConvertible) pa, BOOST_FWD_REF(ValAllocConvertible) va) + : map_allocator_type(boost::forward(pa)) + , allocator_type (boost::forward(va)) + , m_map(0), m_map_size(0) + , m_start(), m_finish(m_start) + {} + + ptr_alloc_ptr m_map; + val_alloc_size m_map_size; + iterator m_start; + iterator m_finish; + } members_; + + inline ptr_alloc_t &ptr_alloc() BOOST_NOEXCEPT_OR_NOTHROW + { return members_; } + + inline const ptr_alloc_t &ptr_alloc() const BOOST_NOEXCEPT_OR_NOTHROW + { return members_; } + + inline allocator_type &alloc() BOOST_NOEXCEPT_OR_NOTHROW + { return members_; } + + inline const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW + { return members_; } +}; +#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED +//! A double-ended queue is a sequence that supports random access to elements, constant time insertion +//! and removal of elements at the end of the sequence, and linear time insertion and removal of elements in the middle. +//! +//! \tparam T The type of object that is stored in the deque +//! \tparam A The allocator used for all internal memory management, use void +//! for the default allocator +//! \tparam Options A type produced from \c boost::container::deque_options. +template +#else +template +#endif +class deque : protected deque_base::type, Options> +{ + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + private: + typedef deque_base::type, Options> Base; + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + typedef typename real_allocator::type ValAllocator; + typedef constant_iterator c_it; + + public: + + ////////////////////////////////////////////// + // + // types + // + ////////////////////////////////////////////// + + typedef T value_type; + typedef ValAllocator allocator_type; + typedef typename ::boost::container::allocator_traits::pointer pointer; + typedef typename ::boost::container::allocator_traits::const_pointer const_pointer; + typedef typename ::boost::container::allocator_traits::reference reference; + typedef typename ::boost::container::allocator_traits::const_reference const_reference; + typedef typename ::boost::container::allocator_traits::size_type size_type; + typedef typename ::boost::container::allocator_traits::difference_type difference_type; + typedef BOOST_CONTAINER_IMPDEF(allocator_type) stored_allocator_type; + typedef BOOST_CONTAINER_IMPDEF(typename Base::iterator) iterator; + typedef BOOST_CONTAINER_IMPDEF(typename Base::const_iterator) const_iterator; + typedef BOOST_CONTAINER_IMPDEF(boost::container::reverse_iterator) reverse_iterator; + typedef BOOST_CONTAINER_IMPDEF(boost::container::reverse_iterator) const_reverse_iterator; + + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + + private: // Internal typedefs + BOOST_COPYABLE_AND_MOVABLE(deque) + typedef typename Base::ptr_alloc_ptr index_pointer; + typedef allocator_traits allocator_traits_type; + + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + + using Base::get_block_ssize; + + public: + + using Base::get_block_size; + + + ////////////////////////////////////////////// + // + // construct/copy/destroy + // + ////////////////////////////////////////////// + + //! Effects: Default constructors a deque. + //! + //! Throws: If allocator_type's default constructor throws. + //! + //! Complexity: Constant. + inline deque() + BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible::value) + : Base() + {} + + //! Effects: Constructs a deque taking the allocator as parameter. + //! + //! Throws: Nothing + //! + //! Complexity: Constant. + inline explicit deque(const allocator_type& a) BOOST_NOEXCEPT_OR_NOTHROW + : Base(a) + {} + + //! Effects: Constructs a deque + //! and inserts n value initialized values. + //! + //! Throws: If allocator_type's default constructor + //! throws or T's value initialization throws. + //! + //! Complexity: Linear to n. + inline explicit deque(size_type n) + : Base(n, allocator_type()) + { + dtl::insert_value_initialized_n_proxy proxy; + proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n); + //deque_base will deallocate in case of exception... + } + + //! Effects: Constructs a deque + //! and inserts n default initialized values. + //! + //! Throws: If allocator_type's default constructor + //! throws or T's default initialization or copy constructor throws. + //! + //! Complexity: Linear to n. + //! + //! Note: Non-standard extension + inline deque(size_type n, default_init_t) + : Base(n, allocator_type()) + { + dtl::insert_default_initialized_n_proxy proxy; + proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n); + //deque_base will deallocate in case of exception... + } + + //! Effects: Constructs a deque that will use a copy of allocator a + //! and inserts n value initialized values. + //! + //! Throws: If allocator_type's default constructor + //! throws or T's value initialization throws. + //! + //! Complexity: Linear to n. + inline explicit deque(size_type n, const allocator_type &a) + : Base(n, a) + { + dtl::insert_value_initialized_n_proxy proxy; + proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n); + //deque_base will deallocate in case of exception... + } + + //! Effects: Constructs a deque that will use a copy of allocator a + //! and inserts n default initialized values. + //! + //! Throws: If allocator_type's default constructor + //! throws or T's default initialization or copy constructor throws. + //! + //! Complexity: Linear to n. + //! + //! Note: Non-standard extension + inline deque(size_type n, default_init_t, const allocator_type &a) + : Base(n, a) + { + dtl::insert_default_initialized_n_proxy proxy; + proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n); + //deque_base will deallocate in case of exception... + } + + //! Effects: Constructs a deque that will use a copy of allocator a + //! and inserts n copies of value. + //! + //! Throws: If allocator_type's default constructor + //! throws or T's copy constructor throws. + //! + //! Complexity: Linear to n. + inline deque(size_type n, const value_type& value) + : Base(n, allocator_type()) + { this->priv_fill_initialize(value); } + + //! Effects: Constructs a deque that will use a copy of allocator a + //! and inserts n copies of value. + //! + //! Throws: If allocator_type's default constructor + //! throws or T's copy constructor throws. + //! + //! Complexity: Linear to n. + inline deque(size_type n, const value_type& value, const allocator_type& a) + : Base(n, a) + { this->priv_fill_initialize(value); } + + //! Effects: Constructs a deque that will use a copy of allocator a + //! and inserts a copy of the range [first, last) in the deque. + //! + //! Throws: If allocator_type's default constructor + //! throws or T's constructor taking a dereferenced InIt throws. + //! + //! Complexity: Linear to the range [first, last). + template + inline deque(InIt first, InIt last + #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + , typename dtl::disable_if_convertible + ::type * = 0 + #endif + ) + : Base(allocator_type()) + { + this->priv_range_initialize(first, last); + } + + //! Effects: Constructs a deque that will use a copy of allocator a + //! and inserts a copy of the range [first, last) in the deque. + //! + //! Throws: If allocator_type's default constructor + //! throws or T's constructor taking a dereferenced InIt throws. + //! + //! Complexity: Linear to the range [first, last). + template + inline deque(InIt first, InIt last, const allocator_type& a + #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + , typename dtl::disable_if_convertible + ::type * = 0 + #endif + ) + : Base(a) + { + this->priv_range_initialize(first, last); + } + +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! Effects: Constructs a deque that will use a copy of allocator a + //! and inserts a copy of the range [il.begin(), il.end()) in the deque. + //! + //! Throws: If allocator_type's default constructor + //! throws or T's constructor taking a dereferenced std::initializer_list iterator throws. + //! + //! Complexity: Linear to the range [il.begin(), il.end()). + inline deque(std::initializer_list il, const allocator_type& a = allocator_type()) + : Base(a) + { + this->priv_range_initialize(il.begin(), il.end()); + } +#endif + + //! Effects: Copy constructs a deque. + //! + //! Postcondition: x == *this. + //! + //! Complexity: Linear to the elements x contains. + inline deque(const deque& x) + : Base(allocator_traits_type::select_on_container_copy_construction(x.alloc())) + { + if(x.size()){ + this->priv_initialize_map(x.size()); + boost::container::uninitialized_copy_alloc + (this->alloc(), x.begin(), x.end(), this->members_.m_start); + } + } + + //! Effects: Move constructor. Moves x's resources to *this. + //! + //! Throws: If allocator_type's copy constructor throws. + //! + //! Complexity: Constant. + inline deque(BOOST_RV_REF(deque) x) BOOST_NOEXCEPT_OR_NOTHROW + : Base(BOOST_MOVE_BASE(Base, x)) + { this->swap_members(x); } + + //! Effects: Copy constructs a vector using the specified allocator. + //! + //! Postcondition: x == *this. + //! + //! Throws: If allocation + //! throws or T's copy constructor throws. + //! + //! Complexity: Linear to the elements x contains. + deque(const deque& x, const allocator_type &a) + : Base(a) + { + if(x.size()){ + this->priv_initialize_map(x.size()); + boost::container::uninitialized_copy_alloc + (this->alloc(), x.begin(), x.end(), this->members_.m_start); + } + } + + //! Effects: Move constructor using the specified allocator. + //! Moves x's resources to *this if a == allocator_type(). + //! Otherwise copies values from x to *this. + //! + //! Throws: If allocation or T's copy constructor throws. + //! + //! Complexity: Constant if a == x.get_allocator(), linear otherwise. + deque(BOOST_RV_REF(deque) x, const allocator_type &a) + : Base(a) + { + if(x.alloc() == a){ + this->swap_members(x); + } + else{ + if(x.size()){ + this->priv_initialize_map(x.size()); + boost::container::uninitialized_copy_alloc + ( this->alloc(), boost::make_move_iterator(x.begin()) + , boost::make_move_iterator(x.end()), this->members_.m_start); + } + } + } + + //! Effects: Destroys the deque. All stored values are destroyed + //! and used memory is deallocated. + //! + //! Throws: Nothing. + //! + //! Complexity: Linear to the number of elements. + inline ~deque() BOOST_NOEXCEPT_OR_NOTHROW + { + this->priv_destroy_range(this->members_.m_start, this->members_.m_finish); + } + + //! Effects: Makes *this contain the same elements as x. + //! + //! Postcondition: this->size() == x.size(). *this contains a copy + //! of each of x's elements. + //! + //! Throws: If memory allocation throws or T's copy constructor throws. + //! + //! Complexity: Linear to the number of elements in x. + deque& operator= (BOOST_COPY_ASSIGN_REF(deque) x) + { + if (BOOST_LIKELY(&x != this)){ + allocator_type &this_alloc = this->alloc(); + const allocator_type &x_alloc = x.alloc(); + dtl::bool_ flag; + if(flag && this_alloc != x_alloc){ + this->clear(); + this->shrink_to_fit(); + } + dtl::assign_alloc(this->alloc(), x.alloc(), flag); + dtl::assign_alloc(this->ptr_alloc(), x.ptr_alloc(), flag); + this->assign(x.cbegin(), x.cend()); + } + return *this; + } + + //! Effects: Move assignment. All x's values are transferred to *this. + //! + //! Throws: If allocator_traits_type::propagate_on_container_move_assignment + //! is false and (allocation throws or value_type's move constructor throws) + //! + //! Complexity: Constant if allocator_traits_type:: + //! propagate_on_container_move_assignment is true or + //! this->get>allocator() == x.get_allocator(). Linear otherwise. + deque& operator= (BOOST_RV_REF(deque) x) + BOOST_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_move_assignment::value + || allocator_traits_type::is_always_equal::value) + { + if (BOOST_LIKELY(this != &x)) { + //We know resources can be transferred at comiple time if both allocators are + //always equal or the allocator is going to be propagated + const bool can_steal_resources_alloc + = allocator_traits_type::propagate_on_container_move_assignment::value + || allocator_traits_type::is_always_equal::value; + dtl::bool_ flag; + this->priv_move_assign(boost::move(x), flag); + } + return *this; + } + +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! Effects: Makes *this contain the same elements as il. + //! + //! Postcondition: this->size() == il.size(). *this contains a copy + //! of each of x's elements. + //! + //! Throws: If memory allocation throws or T's copy constructor throws. + //! + //! Complexity: Linear to the number of elements in il. + inline deque& operator=(std::initializer_list il) + { + this->assign(il.begin(), il.end()); + return *this; + } +#endif + + //! Effects: Assigns the n copies of val to *this. + //! + //! Throws: If memory allocation throws or T's copy constructor throws. + //! + //! Complexity: Linear to n. + inline void assign(size_type n, const T& val) + { + this->assign(c_it(val, n), c_it()); + } + + //! Effects: Assigns the the range [first, last) to *this. + //! + //! Throws: If memory allocation throws or + //! T's constructor from dereferencing InIt throws. + //! + //! Complexity: Linear to n. + template + void assign(InIt first, InIt last + #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + , typename dtl::disable_if_or + < void + , dtl::is_convertible + , dtl::is_not_input_iterator + >::type * = 0 + #endif + ) + { + iterator cur = this->begin(); + for ( ; first != last && cur != end(); ++cur, ++first){ + *cur = *first; + } + if (first == last){ + this->erase(cur, this->cend()); + } + else{ + this->insert(this->cend(), first, last); + } + } + + #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + template + void assign(FwdIt first, FwdIt last + , typename dtl::disable_if_or + < void + , dtl::is_convertible + , dtl::is_input_iterator + >::type * = 0 + ) + { + const size_type len = boost::container::iterator_udistance(first, last); + if (len > size()) { + FwdIt mid = first; + boost::container::iterator_uadvance(mid, this->size()); + boost::container::copy(first, mid, begin()); + this->insert(this->cend(), mid, last); + } + else{ + this->erase(boost::container::copy(first, last, this->begin()), cend()); + } + } + #endif + +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! Effects: Assigns the the range [il.begin(), il.end()) to *this. + //! + //! Throws: If memory allocation throws or + //! T's constructor from dereferencing std::initializer_list iterator throws. + //! + //! Complexity: Linear to il.size(). + inline void assign(std::initializer_list il) + { this->assign(il.begin(), il.end()); } +#endif + + //! Effects: Returns a copy of the internal allocator. + //! + //! Throws: If allocator's copy constructor throws. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW + { return Base::alloc(); } + + //! Effects: Returns a reference to the internal allocator. + //! + //! Throws: Nothing + //! + //! Complexity: Constant. + //! + //! Note: Non-standard extension. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const stored_allocator_type &get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW + { return Base::alloc(); } + + ////////////////////////////////////////////// + // + // iterators + // + ////////////////////////////////////////////// + + //! Effects: Returns a reference to the internal allocator. + //! + //! Throws: Nothing + //! + //! Complexity: Constant. + //! + //! Note: Non-standard extension. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + stored_allocator_type &get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW + { return Base::alloc(); } + + //! Effects: Returns an iterator to the first element contained in the deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + iterator begin() BOOST_NOEXCEPT_OR_NOTHROW + { return this->members_.m_start; } + + //! Effects: Returns a const_iterator to the first element contained in the deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW + { return this->members_.m_start; } + + //! Effects: Returns an iterator to the end of the deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + iterator end() BOOST_NOEXCEPT_OR_NOTHROW + { return this->members_.m_finish; } + + //! Effects: Returns a const_iterator to the end of the deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW + { return this->members_.m_finish; } + + //! Effects: Returns a reverse_iterator pointing to the beginning + //! of the reversed deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW + { return reverse_iterator(this->members_.m_finish); } + + //! Effects: Returns a const_reverse_iterator pointing to the beginning + //! of the reversed deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW + { return const_reverse_iterator(this->members_.m_finish); } + + //! Effects: Returns a reverse_iterator pointing to the end + //! of the reversed deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW + { return reverse_iterator(this->members_.m_start); } + + //! Effects: Returns a const_reverse_iterator pointing to the end + //! of the reversed deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW + { return const_reverse_iterator(this->members_.m_start); } + + //! Effects: Returns a const_iterator to the first element contained in the deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW + { return this->members_.m_start; } + + //! Effects: Returns a const_iterator to the end of the deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW + { return this->members_.m_finish; } + + //! Effects: Returns a const_reverse_iterator pointing to the beginning + //! of the reversed deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW + { return const_reverse_iterator(this->members_.m_finish); } + + //! Effects: Returns a const_reverse_iterator pointing to the end + //! of the reversed deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW + { return const_reverse_iterator(this->members_.m_start); } + + ////////////////////////////////////////////// + // + // capacity + // + ////////////////////////////////////////////// + + //! Effects: Returns true if the deque contains no elements. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + bool empty() const BOOST_NOEXCEPT_OR_NOTHROW + { return this->members_.m_finish == this->members_.m_start; } + + //! Effects: Returns the number of the elements contained in the deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + size_type size() const BOOST_NOEXCEPT_OR_NOTHROW + { return size_type(this->members_.m_finish - this->members_.m_start); } + + //! Effects: Returns the largest possible size of the deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW + { return allocator_traits_type::max_size(this->alloc()); } + + //! Effects: Inserts or erases elements at the end such that + //! the size becomes n. New elements are value initialized. + //! + //! Throws: If memory allocation throws, or T's constructor throws. + //! + //! Complexity: Linear to the difference between size() and new_size. + void resize(size_type new_size) + { + const size_type len = size(); + if (new_size < len) + this->priv_erase_last_n(len - new_size); + else{ + const size_type n = new_size - this->size(); + dtl::insert_value_initialized_n_proxy proxy; + priv_insert_back_aux_impl(n, proxy); + } + } + + //! Effects: Inserts or erases elements at the end such that + //! the size becomes n. New elements are default initialized. + //! + //! Throws: If memory allocation throws, or T's constructor throws. + //! + //! Complexity: Linear to the difference between size() and new_size. + //! + //! Note: Non-standard extension + void resize(size_type new_size, default_init_t) + { + const size_type len = size(); + if (new_size < len) + this->priv_erase_last_n(len - new_size); + else{ + const size_type n = new_size - this->size(); + dtl::insert_default_initialized_n_proxy proxy; + priv_insert_back_aux_impl(n, proxy); + } + } + + //! Effects: Inserts or erases elements at the end such that + //! the size becomes n. New elements are copy constructed from x. + //! + //! Throws: If memory allocation throws, or T's copy constructor throws. + //! + //! Complexity: Linear to the difference between size() and new_size. + void resize(size_type new_size, const value_type& x) + { + const size_type len = size(); + if (new_size < len) + this->erase(this->members_.m_start + difference_type(new_size), this->members_.m_finish); + else + this->insert(this->members_.m_finish, new_size - len, x); + } + + //! Effects: Tries to deallocate the excess of memory created + //! with previous allocations. The size of the deque is unchanged + //! + //! Throws: If memory allocation throws. + //! + //! Complexity: Constant. + void shrink_to_fit() + { + //This deque implementation already + //deallocates excess nodes when erasing + //so there is nothing to do except for + //empty deque + if(this->empty()){ + this->priv_clear_map(); + } + } + + ////////////////////////////////////////////// + // + // element access + // + ////////////////////////////////////////////// + + //! Requires: !empty() + //! + //! Effects: Returns a reference to the first + //! element of the container. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + reference front() BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(!this->empty()); + return *this->members_.m_start; + } + + //! Requires: !empty() + //! + //! Effects: Returns a const reference to the first element + //! from the beginning of the container. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_reference front() const BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(!this->empty()); + return *this->members_.m_start; + } + + //! Requires: !empty() + //! + //! Effects: Returns a reference to the last + //! element of the container. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + reference back() BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(!this->empty()); + return *(end()-1); + } + + //! Requires: !empty() + //! + //! Effects: Returns a const reference to the last + //! element of the container. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_reference back() const BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(!this->empty()); + return *(cend()-1); + } + + //! Requires: size() > n. + //! + //! Effects: Returns a reference to the nth element + //! from the beginning of the container. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + reference operator[](size_type n) BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(this->size() > n); + return this->members_.m_start[difference_type(n)]; + } + + //! Requires: size() > n. + //! + //! Effects: Returns a const reference to the nth element + //! from the beginning of the container. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_reference operator[](size_type n) const BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(this->size() > n); + return this->members_.m_start[difference_type(n)]; + } + + //! Requires: size() >= n. + //! + //! Effects: Returns an iterator to the nth element + //! from the beginning of the container. Returns end() + //! if n == size(). + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + //! + //! Note: Non-standard extension + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(this->size() >= n); + return iterator(this->begin()+difference_type(n)); + } + + //! Requires: size() >= n. + //! + //! Effects: Returns a const_iterator to the nth element + //! from the beginning of the container. Returns end() + //! if n == size(). + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + //! + //! Note: Non-standard extension + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(this->size() >= n); + return const_iterator(this->cbegin()+difference_type(n)); + } + + //! Requires: begin() <= p <= end(). + //! + //! Effects: Returns the index of the element pointed by p + //! and size() if p == end(). + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + //! + //! Note: Non-standard extension + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW + { + //Range checked priv_index_of + return this->priv_index_of(p); + } + + //! Requires: begin() <= p <= end(). + //! + //! Effects: Returns the index of the element pointed by p + //! and size() if p == end(). + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + //! + //! Note: Non-standard extension + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW + { + //Range checked priv_index_of + return this->priv_index_of(p); + } + + //! Requires: size() > n. + //! + //! Effects: Returns a reference to the nth element + //! from the beginning of the container. + //! + //! Throws: range_error if n >= size() + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + reference at(size_type n) + { + this->priv_throw_if_out_of_range(n); + return (*this)[n]; + } + + //! Requires: size() > n. + //! + //! Effects: Returns a const reference to the nth element + //! from the beginning of the container. + //! + //! Throws: range_error if n >= size() + //! + //! Complexity: Constant. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + const_reference at(size_type n) const + { + this->priv_throw_if_out_of_range(n); + return (*this)[n]; + } + + ////////////////////////////////////////////// + // + // modifiers + // + ////////////////////////////////////////////// + + #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + + //! Effects: Inserts an object of type T constructed with + //! std::forward(args)... in the beginning of the deque. + //! + //! Returns: A reference to the created object. + //! + //! Throws: If memory allocation throws or the in-place constructor throws. + //! + //! Complexity: Amortized constant time + template + reference emplace_front(BOOST_FWD_REF(Args)... args) + { + if(this->priv_push_front_simple_available()){ + reference r = *this->priv_push_front_simple_pos(); + allocator_traits_type::construct + ( this->alloc() + , this->priv_push_front_simple_pos() + , boost::forward(args)...); + this->priv_push_front_simple_commit(); + return r; + } + else{ + typedef dtl::insert_nonmovable_emplace_proxy type; + return *this->priv_insert_front_aux_impl(1, type(boost::forward(args)...)); + } + } + + //! Effects: Inserts an object of type T constructed with + //! std::forward(args)... in the end of the deque. + //! + //! Returns: A reference to the created object. + //! + //! Throws: If memory allocation throws or the in-place constructor throws. + //! + //! Complexity: Amortized constant time + template + reference emplace_back(BOOST_FWD_REF(Args)... args) + { + if(this->priv_push_back_simple_available()){ + reference r = *this->priv_push_back_simple_pos(); + allocator_traits_type::construct + ( this->alloc() + , this->priv_push_back_simple_pos() + , boost::forward(args)...); + this->priv_push_back_simple_commit(); + return r; + } + else{ + typedef dtl::insert_nonmovable_emplace_proxy type; + return *this->priv_insert_back_aux_impl(1, type(boost::forward(args)...)); + } + } + + //! Requires: p must be a valid iterator of *this. + //! + //! Effects: Inserts an object of type T constructed with + //! std::forward(args)... before p + //! + //! Throws: If memory allocation throws or the in-place constructor throws. + //! + //! Complexity: If p is end(), amortized constant time + //! Linear time otherwise. + template + iterator emplace(const_iterator p, BOOST_FWD_REF(Args)... args) + { + BOOST_ASSERT(this->priv_in_range_or_end(p)); + if(p == this->cbegin()){ + this->emplace_front(boost::forward(args)...); + return this->begin(); + } + else if(p == this->cend()){ + this->emplace_back(boost::forward(args)...); + return (this->end()-1); + } + else{ + typedef dtl::insert_emplace_proxy type; + return this->priv_insert_aux_impl(p, 1, type(boost::forward(args)...)); + } + } + + #else //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + + #define BOOST_CONTAINER_DEQUE_EMPLACE_CODE(N) \ + BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\ + reference emplace_front(BOOST_MOVE_UREF##N)\ + {\ + if(priv_push_front_simple_available()){\ + reference r = *this->priv_push_front_simple_pos();\ + allocator_traits_type::construct\ + ( this->alloc(), this->priv_push_front_simple_pos() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\ + priv_push_front_simple_commit();\ + return r;\ + }\ + else{\ + typedef dtl::insert_nonmovable_emplace_proxy##N\ + type;\ + return *priv_insert_front_aux_impl(1, type(BOOST_MOVE_FWD##N));\ + }\ + }\ + \ + BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\ + reference emplace_back(BOOST_MOVE_UREF##N)\ + {\ + if(priv_push_back_simple_available()){\ + reference r = *this->priv_push_back_simple_pos();\ + allocator_traits_type::construct\ + ( this->alloc(), this->priv_push_back_simple_pos() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\ + priv_push_back_simple_commit();\ + return r;\ + }\ + else{\ + typedef dtl::insert_nonmovable_emplace_proxy##N\ + type;\ + return *priv_insert_back_aux_impl(1, type(BOOST_MOVE_FWD##N));\ + }\ + }\ + \ + BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\ + iterator emplace(const_iterator p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\ + {\ + BOOST_ASSERT(this->priv_in_range_or_end(p));\ + if(p == this->cbegin()){\ + this->emplace_front(BOOST_MOVE_FWD##N);\ + return this->begin();\ + }\ + else if(p == cend()){\ + this->emplace_back(BOOST_MOVE_FWD##N);\ + return (--this->end());\ + }\ + else{\ + typedef dtl::insert_emplace_proxy_arg##N\ + type;\ + return this->priv_insert_aux_impl(p, 1, type(BOOST_MOVE_FWD##N));\ + }\ + } + // + BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DEQUE_EMPLACE_CODE) + #undef BOOST_CONTAINER_DEQUE_EMPLACE_CODE + + #endif // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + //! Effects: Inserts a copy of x at the front of the deque. + //! + //! Throws: If memory allocation throws or + //! T's copy constructor throws. + //! + //! Complexity: Amortized constant time. + void push_front(const T &x); + + //! Effects: Constructs a new element in the front of the deque + //! and moves the resources of x to this new element. + //! + //! Throws: If memory allocation throws. + //! + //! Complexity: Amortized constant time. + void push_front(T &&x); + #else + BOOST_MOVE_CONVERSION_AWARE_CATCH(push_front, T, void, priv_push_front) + #endif + + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + //! Effects: Inserts a copy of x at the end of the deque. + //! + //! Throws: If memory allocation throws or + //! T's copy constructor throws. + //! + //! Complexity: Amortized constant time. + void push_back(const T &x); + + //! Effects: Constructs a new element in the end of the deque + //! and moves the resources of x to this new element. + //! + //! Throws: If memory allocation throws. + //! + //! Complexity: Amortized constant time. + void push_back(T &&x); + #else + BOOST_MOVE_CONVERSION_AWARE_CATCH(push_back, T, void, priv_push_back) + #endif + + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + + //! Requires: p must be a valid iterator of *this. + //! + //! Effects: Insert a copy of x before p. + //! + //! Returns: an iterator to the inserted element. + //! + //! Throws: If memory allocation throws or x's copy constructor throws. + //! + //! Complexity: If p is end(), amortized constant time + //! Linear time otherwise. + iterator insert(const_iterator p, const T &x); + + //! Requires: p must be a valid iterator of *this. + //! + //! Effects: Insert a new element before p with x's resources. + //! + //! Returns: an iterator to the inserted element. + //! + //! Throws: If memory allocation throws. + //! + //! Complexity: If p is end(), amortized constant time + //! Linear time otherwise. + iterator insert(const_iterator p, T &&x); + #else + BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, T, iterator, priv_insert, const_iterator, const_iterator) + #endif + + //! Requires: pos must be a valid iterator of *this. + //! + //! Effects: Insert n copies of x before pos. + //! + //! Returns: an iterator to the first inserted element or pos if n is 0. + //! + //! Throws: If memory allocation throws or T's copy constructor throws. + //! + //! Complexity: Linear to n. + inline iterator insert(const_iterator pos, size_type n, const value_type& x) + { + //Range check of p is done by insert() + return this->insert(pos, c_it(x, n), c_it()); + } + + //! Requires: pos must be a valid iterator of *this. + //! + //! Effects: Insert a copy of the [first, last) range before pos. + //! + //! Returns: an iterator to the first inserted element or pos if first == last. + //! + //! Throws: If memory allocation throws, T's constructor from a + //! dereferenced InIt throws or T's copy constructor throws. + //! + //! Complexity: Linear to distance [first, last). + template + iterator insert(const_iterator pos, InIt first, InIt last + #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + , typename dtl::disable_if_or + < void + , dtl::is_convertible + , dtl::is_not_input_iterator + >::type * = 0 + #endif + ) + { + BOOST_ASSERT(this->priv_in_range_or_end(pos)); + size_type n = 0; + iterator it(pos.unconst()); + for(;first != last; ++first, ++n){ + it = this->emplace(it, *first); + ++it; + } + it -= difference_type(n); + return it; + } + +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! Requires: pos must be a valid iterator of *this. + //! + //! Effects: Insert a copy of the [il.begin(), il.end()) range before pos. + //! + //! Returns: an iterator to the first inserted element or pos if il.begin() == il.end(). + //! + //! Throws: If memory allocation throws, T's constructor from a + //! dereferenced std::initializer_list throws or T's copy constructor throws. + //! + //! Complexity: Linear to distance [il.begin(), il.end()). + inline iterator insert(const_iterator pos, std::initializer_list il) + { + //Range check os pos is done in insert() + return insert(pos, il.begin(), il.end()); + } +#endif + + #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + template + inline iterator insert(const_iterator p, FwdIt first, FwdIt last + #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + , typename dtl::disable_if_or + < void + , dtl::is_convertible + , dtl::is_input_iterator + >::type * = 0 + #endif + ) + { + BOOST_ASSERT(this->priv_in_range_or_end(p)); + dtl::insert_range_proxy proxy(first); + return priv_insert_aux_impl(p, boost::container::iterator_udistance(first, last), proxy); + } + #endif + + //! Effects: Removes the first element from the deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant time. + void pop_front() BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(!this->empty()); + if (this->members_.m_start.m_cur != this->members_.m_start.get_last() - 1) { + allocator_traits_type::destroy + ( this->alloc() + , boost::movelib::to_raw_pointer(this->members_.m_start.m_cur) + ); + ++this->members_.m_start.m_cur; + } + else + this->priv_pop_front_aux(); + } + + //! Effects: Removes the last element from the deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant time. + void pop_back() BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(!this->empty()); + if (this->members_.m_finish.m_cur != this->members_.m_finish.get_first()) { + --this->members_.m_finish.m_cur; + allocator_traits_type::destroy + ( this->alloc() + , boost::movelib::to_raw_pointer(this->members_.m_finish.m_cur) + ); + } + else + this->priv_pop_back_aux(); + } + + //! Effects: Erases the element at p. + //! + //! Throws: Nothing. + //! + //! Complexity: Linear to the elements between pos and the + //! last element (if pos is near the end) or the first element + //! if(pos is near the beginning). + //! Constant if pos is the first or the last element. + iterator erase(const_iterator pos) BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(this->priv_in_range(pos)); + iterator next = pos.unconst(); + ++next; + size_type index = size_type(pos - this->members_.m_start); + if (index < (this->size()/2)) { + boost::container::move_backward(this->begin(), pos.unconst(), next); + pop_front(); + } + else { + boost::container::move(next, this->end(), pos.unconst()); + pop_back(); + } + return this->members_.m_start + difference_type(index); + } + + //! Effects: Erases the elements pointed by [first, last). + //! + //! Throws: Nothing. + //! + //! Complexity: Linear to the distance between first and + //! last plus the elements between pos and the + //! last element (if pos is near the end) or the first element + //! if(pos is near the beginning). + iterator erase(const_iterator first, const_iterator last) BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(first == last || + (first < last && this->priv_in_range(first) && this->priv_in_range_or_end(last))); + if (first == this->members_.m_start && last == this->members_.m_finish) { + this->clear(); + return this->members_.m_finish; + } + else { + const size_type n = static_cast(last - first); + const size_type elems_before = static_cast(first - this->members_.m_start); + if (elems_before < (this->size() - n) - elems_before) { + boost::container::move_backward(begin(), first.unconst(), last.unconst()); + iterator new_start = this->members_.m_start + difference_type(n); + this->priv_destroy_range(this->members_.m_start, new_start); + this->priv_destroy_nodes(this->members_.m_start.m_node, new_start.m_node); + this->members_.m_start = new_start; + } + else { + boost::container::move(last.unconst(), end(), first.unconst()); + iterator new_finish = this->members_.m_finish - difference_type(n); + this->priv_destroy_range(new_finish, this->members_.m_finish); + this->priv_destroy_nodes(new_finish.m_node + 1, this->members_.m_finish.m_node + 1); + this->members_.m_finish = new_finish; + } + return this->members_.m_start + difference_type(elems_before); + } + } + + //! Effects: Swaps the contents of *this and x. + //! + //! Throws: Nothing. + //! + //! Complexity: Constant. + inline void swap(deque &x) + BOOST_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_swap::value + || allocator_traits_type::is_always_equal::value) + { + this->swap_members(x); + dtl::bool_ flag; + dtl::swap_alloc(this->alloc(), x.alloc(), flag); + dtl::swap_alloc(this->ptr_alloc(), x.ptr_alloc(), flag); + } + + //! Effects: Erases all the elements of the deque. + //! + //! Throws: Nothing. + //! + //! Complexity: Linear to the number of elements in the deque. + void clear() BOOST_NOEXCEPT_OR_NOTHROW + { + if (this->members_.m_finish != this->members_.m_start) { + + for (index_pointer node = this->members_.m_start.m_node + 1; + node < this->members_.m_finish.m_node; + ++node) { + this->priv_destroy_range(*node, *node + get_block_ssize()); + this->priv_deallocate_node(*node); + } + + if (this->members_.m_start.m_node != this->members_.m_finish.m_node) { + this->priv_destroy_range(this->members_.m_start.m_cur, this->members_.m_start.get_last()); + this->priv_destroy_range(this->members_.m_finish.get_first(), this->members_.m_finish.m_cur); + this->priv_deallocate_node(this->members_.m_finish.get_first()); + } + else + this->priv_destroy_range(this->members_.m_start.m_cur, this->members_.m_finish.m_cur); + + this->members_.m_finish = this->members_.m_start; + } + } + + //! Effects: Returns true if x and y are equal + //! + //! Complexity: Linear to the number of elements in the container. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator==(const deque& x, const deque& y) + { return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin()); } + + //! Effects: Returns true if x and y are unequal + //! + //! Complexity: Linear to the number of elements in the container. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator!=(const deque& x, const deque& y) + { return !(x == y); } + + //! Effects: Returns true if x is less than y + //! + //! Complexity: Linear to the number of elements in the container. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator<(const deque& x, const deque& y) + { return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); } + + //! Effects: Returns true if x is greater than y + //! + //! Complexity: Linear to the number of elements in the container. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator>(const deque& x, const deque& y) + { return y < x; } + + //! Effects: Returns true if x is equal or less than y + //! + //! Complexity: Linear to the number of elements in the container. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator<=(const deque& x, const deque& y) + { return !(y < x); } + + //! Effects: Returns true if x is equal or greater than y + //! + //! Complexity: Linear to the number of elements in the container. + BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline + friend bool operator>=(const deque& x, const deque& y) + { return !(x < y); } + + //! Effects: x.swap(y) + //! + //! Complexity: Constant. + inline friend void swap(deque& x, deque& y) + BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT(x.swap(y))) + { x.swap(y); } + + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + private: + + void priv_move_assign(BOOST_RV_REF(deque) x, dtl::bool_ /*steal_resources*/) + { + //Destroy objects but retain memory in case x reuses it in the future + this->clear(); + //Move allocator if needed + dtl::bool_ flag; + dtl::move_alloc(this->alloc(), x.alloc(), flag); + dtl::move_alloc(this->ptr_alloc(), x.ptr_alloc(), flag); + //Nothrow swap + this->swap_members(x); + } + + void priv_move_assign(BOOST_RV_REF(deque) x, dtl::bool_ /*steal_resources*/) + { + //We can't guarantee a compile-time equal allocator or propagation so fallback to runtime + //Resources can be transferred if both allocators are equal + if (this->alloc() == x.alloc()) { + this->priv_move_assign(boost::move(x), dtl::true_()); + } + else { + this->assign(boost::make_move_iterator(x.begin()), boost::make_move_iterator(x.end())); + } + } + + inline size_type priv_index_of(const_iterator p) const + { + BOOST_ASSERT(this->cbegin() <= p); + BOOST_ASSERT(p <= this->cend()); + return static_cast(p - this->cbegin()); + } + + void priv_erase_last_n(size_type n) + { + if(n == this->size()) { + this->clear(); + } + else { + iterator new_finish = this->members_.m_finish - difference_type(n); + this->priv_destroy_range(new_finish, this->members_.m_finish); + this->priv_destroy_nodes(new_finish.m_node + 1, this->members_.m_finish.m_node + 1); + this->members_.m_finish = new_finish; + } + } + + void priv_throw_if_out_of_range(size_type n) const + { + if (n >= this->size()) + throw_out_of_range("deque::at out of range"); + } + + inline bool priv_in_range(const_iterator pos) const + { + return (this->begin() <= pos) && (pos < this->end()); + } + + inline bool priv_in_range_or_end(const_iterator pos) const + { + return (this->begin() <= pos) && (pos <= this->end()); + } + + template + iterator priv_insert(const_iterator p, BOOST_FWD_REF(U) x) + { + BOOST_ASSERT(this->priv_in_range_or_end(p)); + if (p == cbegin()){ + this->push_front(::boost::forward(x)); + return begin(); + } + else if (p == cend()){ + this->push_back(::boost::forward(x)); + return --end(); + } + else { + return priv_insert_aux_impl + ( p, (size_type)1 + , dtl::get_insert_value_proxy(::boost::forward(x))); + } + } + + template + void priv_push_front(BOOST_FWD_REF(U) x) + { + if(this->priv_push_front_simple_available()){ + allocator_traits_type::construct + ( this->alloc(), this->priv_push_front_simple_pos(), ::boost::forward(x)); + this->priv_push_front_simple_commit(); + } + else{ + priv_insert_aux_impl + ( this->cbegin(), (size_type)1 + , dtl::get_insert_value_proxy(::boost::forward(x))); + } + } + + template + void priv_push_back(BOOST_FWD_REF(U) x) + { + if(this->priv_push_back_simple_available()){ + allocator_traits_type::construct + ( this->alloc(), this->priv_push_back_simple_pos(), ::boost::forward(x)); + this->priv_push_back_simple_commit(); + } + else{ + priv_insert_aux_impl + ( this->cend(), (size_type)1 + , dtl::get_insert_value_proxy(::boost::forward(x))); + } + } + + inline bool priv_push_back_simple_available() const + { + return this->members_.m_map && + (this->members_.m_finish.m_cur != (this->members_.m_finish.get_last() - 1)); + } + + inline T *priv_push_back_simple_pos() const + { + return boost::movelib::to_raw_pointer(this->members_.m_finish.m_cur); + } + + inline void priv_push_back_simple_commit() + { + ++this->members_.m_finish.m_cur; + } + + inline bool priv_push_front_simple_available() const + { + return this->members_.m_map && + (this->members_.m_start.m_cur != this->members_.m_start.get_first()); + } + + inline T *priv_push_front_simple_pos() const + { return boost::movelib::to_raw_pointer(this->members_.m_start.m_cur) - 1; } + + inline void priv_push_front_simple_commit() + { --this->members_.m_start.m_cur; } + + void priv_destroy_range(iterator p, iterator p2) + { + (void)p; (void)p2; + BOOST_IF_CONSTEXPR(!Base::traits_t::trivial_dctr){ + for(;p != p2; ++p){ + allocator_traits_type::destroy(this->alloc(), boost::movelib::iterator_to_raw_pointer(p)); + } + } + } + + void priv_destroy_range(pointer p, pointer p2) + { + (void)p; (void)p2; + BOOST_IF_CONSTEXPR(!Base::traits_t::trivial_dctr){ + for(;p != p2; ++p){ + allocator_traits_type::destroy(this->alloc(), boost::movelib::iterator_to_raw_pointer(p)); + } + } + } + + template + iterator priv_insert_middle_aux_impl(const_iterator p, const size_type elemsbefore, const size_type length, const size_type n, InsertProxy proxy) + { + if (!this->members_.m_map) { + this->priv_initialize_map(0); + p = this->cbegin(); + } + + iterator pos(p.unconst()); + const size_type pos_n = size_type(p - this->cbegin()); + + if (elemsbefore < length / 2) { + const iterator new_start = this->priv_reserve_elements_at_front(n); + const iterator old_start = this->members_.m_start; + pos = this->members_.m_start + difference_type(elemsbefore); + if (elemsbefore >= n) { + const iterator start_n = this->members_.m_start + difference_type(n); + BOOST_CONTAINER_TRY { + ::boost::container::uninitialized_move_alloc + (this->alloc(), this->members_.m_start, start_n, new_start); + } + BOOST_CONTAINER_CATCH(...) { + this->priv_destroy_nodes(new_start.m_node, this->members_.m_start.m_node); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + this->members_.m_start = new_start; + boost::container::move(start_n, pos, old_start); + proxy.copy_n_and_update(this->alloc(), pos - difference_type(n), n); + } + else { + const size_type mid_count = n - elemsbefore; + const iterator mid_start = old_start - difference_type(mid_count); + BOOST_CONTAINER_TRY { + proxy.uninitialized_copy_n_and_update(this->alloc(), mid_start, mid_count); + this->members_.m_start = mid_start; + ::boost::container::uninitialized_move_alloc(this->alloc(), old_start, pos, new_start); + } + BOOST_CONTAINER_CATCH(...) { + this->priv_destroy_nodes(new_start.m_node, this->members_.m_start.m_node); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + this->members_.m_start = new_start; + proxy.copy_n_and_update(this->alloc(), old_start, elemsbefore); + } + } + else { + const iterator new_finish = this->priv_reserve_elements_at_back(n); + const iterator old_finish = this->members_.m_finish; + const size_type elemsafter = length - elemsbefore; + + pos = old_finish - difference_type(elemsafter); + if (elemsafter >= n) { + iterator finish_n = old_finish - difference_type(n); + BOOST_CONTAINER_TRY { + ::boost::container::uninitialized_move_alloc(this->alloc(), finish_n, old_finish, old_finish); + } + BOOST_CONTAINER_CATCH(...) { + this->priv_destroy_nodes(this->members_.m_finish.m_node + 1, new_finish.m_node + 1); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + + this->members_.m_finish = new_finish; + boost::container::move_backward(pos, finish_n, old_finish); + proxy.copy_n_and_update(this->alloc(), pos, n); + } + else { + const size_type raw_gap = n - elemsafter; + BOOST_CONTAINER_TRY{ + ::boost::container::uninitialized_move_alloc + (this->alloc(), pos, old_finish, old_finish + difference_type(raw_gap)); + BOOST_CONTAINER_TRY{ + proxy.copy_n_and_update(this->alloc(), pos, elemsafter); + proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, raw_gap); + } + BOOST_CONTAINER_CATCH(...) { + this->priv_destroy_range(old_finish, old_finish + difference_type(elemsafter)); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + } + BOOST_CONTAINER_CATCH(...) { + this->priv_destroy_nodes(this->members_.m_finish.m_node + 1, new_finish.m_node + 1); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + this->members_.m_finish = new_finish; + } + } + return this->begin() + difference_type(pos_n); + } + + template + iterator priv_insert_aux_impl(const_iterator p, size_type n, InsertProxy proxy) + { + iterator pos(p.unconst()); + const size_type elemsbefore = static_cast(pos - this->members_.m_start); + const size_type length = this->size(); + + if (!elemsbefore) { + return this->priv_insert_front_aux_impl(n, proxy); + } + else if (elemsbefore == length) { + return this->priv_insert_back_aux_impl(n, proxy); + } + else { + return this->priv_insert_middle_aux_impl(p, elemsbefore, length, n, proxy); + } + } + + template + iterator priv_insert_back_aux_impl(size_type n, InsertProxy proxy) + { + if(!this->members_.m_map){ + this->priv_initialize_map(0); + } + + iterator new_finish = this->priv_reserve_elements_at_back(n); + BOOST_CONTAINER_TRY{ + proxy.uninitialized_copy_n_and_update(this->alloc(), this->members_.m_finish, n); + } + BOOST_CONTAINER_CATCH(...) { + this->priv_destroy_nodes(this->members_.m_finish.m_node + 1, new_finish.m_node + 1); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + this->members_.m_finish = new_finish; + return iterator(this->members_.m_finish - difference_type(n)); + } + + template + iterator priv_insert_front_aux_impl(size_type n, InsertProxy proxy) + { + if(!this->members_.m_map){ + this->priv_initialize_map(0); + } + + iterator new_start = this->priv_reserve_elements_at_front(n); + BOOST_CONTAINER_TRY{ + proxy.uninitialized_copy_n_and_update(this->alloc(), new_start, n); + } + BOOST_CONTAINER_CATCH(...) { + this->priv_destroy_nodes(new_start.m_node, this->members_.m_start.m_node); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + + this->members_.m_start = new_start; + return new_start; + } + + inline iterator priv_fill_insert(const_iterator pos, size_type n, const value_type& x) + { + return this->insert(pos, c_it(x, n), c_it()); + } + + // Precondition: this->members_.m_start and this->members_.m_finish have already been initialized, + // but none of the deque's elements have yet been constructed. + void priv_fill_initialize(const value_type& value) + { + index_pointer cur = this->members_.m_start.m_node; + BOOST_CONTAINER_TRY { + for ( ; cur < this->members_.m_finish.m_node; ++cur){ + boost::container::uninitialized_fill_alloc + (this->alloc(), *cur, *cur + get_block_ssize(), value); + } + boost::container::uninitialized_fill_alloc + (this->alloc(), this->members_.m_finish.get_first(), this->members_.m_finish.m_cur, value); + } + BOOST_CONTAINER_CATCH(...){ + this->priv_destroy_range(this->members_.m_start, iterator(*cur, cur, get_block_size())); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + } + + template + void priv_range_initialize(InIt first, InIt last, typename iterator_enable_if_tag::type* =0) + { + this->priv_initialize_map(0); + BOOST_CONTAINER_TRY { + for ( ; first != last; ++first) + this->emplace_back(*first); + } + BOOST_CONTAINER_CATCH(...){ + this->clear(); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + } + + template + void priv_range_initialize(FwdIt first, FwdIt last, typename iterator_disable_if_tag::type* =0) + { + size_type n = 0; + n = boost::container::iterator_udistance(first, last); + this->priv_initialize_map(n); + + index_pointer cur_node = this->members_.m_start.m_node; + BOOST_CONTAINER_TRY { + for (; cur_node < this->members_.m_finish.m_node; ++cur_node) { + FwdIt mid = first; + boost::container::iterator_uadvance(mid, get_block_size()); + ::boost::container::uninitialized_copy_alloc(this->alloc(), first, mid, *cur_node); + first = mid; + } + ::boost::container::uninitialized_copy_alloc(this->alloc(), first, last, this->members_.m_finish.get_first()); + } + BOOST_CONTAINER_CATCH(...){ + this->priv_destroy_range(this->members_.m_start, iterator(*cur_node, cur_node, get_block_size())); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + } + + // Called only if this->members_.m_finish.m_cur == this->members_.m_finish.get_first(). + void priv_pop_back_aux() BOOST_NOEXCEPT_OR_NOTHROW + { + this->priv_deallocate_node(this->members_.m_finish.get_first()); + this->members_.m_finish.priv_set_node(this->members_.m_finish.m_node - 1, get_block_size()); + this->members_.m_finish.m_cur = this->members_.m_finish.get_last() - 1; + allocator_traits_type::destroy + ( this->alloc() + , boost::movelib::to_raw_pointer(this->members_.m_finish.m_cur) + ); + } + + // Called only if this->members_.m_start.m_cur == this->members_.m_start.get_last() - 1. Note that + // if the deque has at least one element (a precondition for this member + // function), and if this->members_.m_start.m_cur == this->members_.m_start.get_last(), then the deque + // must have at least two nodes. + void priv_pop_front_aux() BOOST_NOEXCEPT_OR_NOTHROW + { + allocator_traits_type::destroy + ( this->alloc() + , boost::movelib::to_raw_pointer(this->members_.m_start.m_cur) + ); + this->priv_deallocate_node(this->members_.m_start.get_first()); + this->members_.m_start.priv_set_node(this->members_.m_start.m_node + 1, get_block_size()); + this->members_.m_start.m_cur = this->members_.m_start.get_first(); + } + + iterator priv_reserve_elements_at_front(size_type n) + { + size_type vacancies = size_type(this->members_.m_start.m_cur - this->members_.m_start.get_first()); + if (n > vacancies){ + size_type new_elems = n-vacancies; + size_type new_nodes = (new_elems + get_block_size() - 1u) / get_block_size(); + size_type s = (size_type)(this->members_.m_start.m_node - this->members_.m_map); + if (new_nodes > s){ + this->priv_reallocate_map(new_nodes, true); + } + size_type i = 1; + BOOST_CONTAINER_TRY { + for (; i <= new_nodes; ++i) + *(this->members_.m_start.m_node - difference_type(i)) = this->priv_allocate_node(); + } + BOOST_CONTAINER_CATCH(...) { + for (size_type j = 1; j < i; ++j) + this->priv_deallocate_node(*(this->members_.m_start.m_node - difference_type(j))); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + } + return this->members_.m_start - difference_type(n); + } + + iterator priv_reserve_elements_at_back(size_type n) + { + size_type vacancies = size_type(this->members_.m_finish.get_last() - this->members_.m_finish.m_cur - 1); + if (n > vacancies){ + size_type new_elems = size_type(n - vacancies); + size_type new_nodes = size_type(new_elems + get_block_size() - 1u)/get_block_size(); + size_type s = (size_type)(this->members_.m_map_size - size_type(this->members_.m_finish.m_node - this->members_.m_map)); + if (new_nodes + 1 > s){ + this->priv_reallocate_map(new_nodes, false); + } + size_type i = 1; + BOOST_CONTAINER_TRY { + for (; i <= new_nodes; ++i) + *(this->members_.m_finish.m_node + difference_type(i)) = this->priv_allocate_node(); + } + BOOST_CONTAINER_CATCH(...) { + for (size_type j = 1; j < i; ++j) + this->priv_deallocate_node(*(this->members_.m_finish.m_node + difference_type(j))); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + } + return this->members_.m_finish + difference_type(n); + } + + void priv_reallocate_map(size_type nodes_to_add, bool add_at_front) + { + size_type old_num_nodes = size_type(this->members_.m_finish.m_node - this->members_.m_start.m_node + 1); + size_type new_num_nodes = old_num_nodes + nodes_to_add; + + index_pointer new_nstart; + if (this->members_.m_map_size > 2 * new_num_nodes) { + new_nstart = this->members_.m_map + difference_type(this->members_.m_map_size - new_num_nodes) / 2 + + difference_type(add_at_front ? nodes_to_add : 0u); + if (new_nstart < this->members_.m_start.m_node) + boost::container::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart); + else + boost::container::move_backward + (this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart + difference_type(old_num_nodes)); + } + else { + size_type new_map_size = + this->members_.m_map_size + dtl::max_value(this->members_.m_map_size, nodes_to_add) + 2; + + index_pointer new_map = this->priv_allocate_map(new_map_size); + new_nstart = new_map + difference_type(new_map_size - new_num_nodes) / 2 + + difference_type(add_at_front ? nodes_to_add : 0u); + boost::container::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart); + this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size); + + this->members_.m_map = new_map; + this->members_.m_map_size = new_map_size; + } + + this->members_.m_start.priv_set_node(new_nstart, get_block_size()); + this->members_.m_finish.priv_set_node(new_nstart + difference_type(old_num_nodes - 1u), get_block_size()); + } + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED +}; + +#ifndef BOOST_CONTAINER_NO_CXX17_CTAD +template +deque(InputIterator, InputIterator) -> deque::value_type>; +template +deque(InputIterator, InputIterator, Allocator const&) -> deque::value_type, Allocator>; +#endif + +} //namespace container +} //namespace boost + +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +namespace boost { + +//!has_trivial_destructor_after_move<> == true_type +//!specialization for optimizations +template +struct has_trivial_destructor_after_move > +{ + typedef typename boost::container::deque::allocator_type allocator_type; + typedef typename ::boost::container::allocator_traits::pointer pointer; + BOOST_STATIC_CONSTEXPR bool value = ::boost::has_trivial_destructor_after_move::value && + ::boost::has_trivial_destructor_after_move::value; +}; + +} + +#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + +#include + +#endif // #ifndef BOOST_CONTAINER_DEQUE_HPP diff --git a/boost/include/boost/container/detail/adaptive_node_pool.hpp b/boost/include/boost/container/detail/adaptive_node_pool.hpp new file mode 100644 index 00000000..816b95d1 --- /dev/null +++ b/boost/include/boost/container/detail/adaptive_node_pool.hpp @@ -0,0 +1,169 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2005-2013. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_HPP +#define BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + + +namespace boost { +namespace container { +namespace dtl { + +//!Pooled memory allocator using an smart adaptive pool. Includes +//!a reference count but the class does not delete itself, this is +//!responsibility of user classes. Node size (NodeSize) and the number of +//!nodes allocated per block (NodesPerBlock) are known at compile time. +template< std::size_t NodeSize + , std::size_t NodesPerBlock + , std::size_t MaxFreeBlocks + , std::size_t OverheadPercent + > +class private_adaptive_node_pool + : public private_adaptive_node_pool_impl_ct + < fake_segment_manager + , MaxFreeBlocks + , NodeSize + , NodesPerBlock + , OverheadPercent + , unsigned(OverheadPercent == 0)*::boost::container::adaptive_pool_flag::align_only + | ::boost::container::adaptive_pool_flag::size_ordered + | ::boost::container::adaptive_pool_flag::address_ordered + > +{ + typedef private_adaptive_node_pool_impl_ct + < fake_segment_manager + , MaxFreeBlocks + , NodeSize + , NodesPerBlock + , OverheadPercent + , unsigned(OverheadPercent == 0)*::boost::container::adaptive_pool_flag::align_only + | ::boost::container::adaptive_pool_flag::size_ordered + | ::boost::container::adaptive_pool_flag::address_ordered + > base_t; + + //Non-copyable + private_adaptive_node_pool(const private_adaptive_node_pool &); + private_adaptive_node_pool &operator=(const private_adaptive_node_pool &); + + public: + BOOST_STATIC_CONSTEXPR std::size_t nodes_per_block = NodesPerBlock; + + //!Constructor. Never throws + private_adaptive_node_pool() + : base_t(0) + {} +}; + +//!Pooled memory allocator using adaptive pool. Includes +//!a reference count but the class does not delete itself, this is +//!responsibility of user classes. Node size (NodeSize) and the number of +//!nodes allocated per block (NodesPerBlock) are known at compile time +template< std::size_t NodeSize + , std::size_t NodesPerBlock + , std::size_t MaxFreeBlocks + , std::size_t OverheadPercent + > +class shared_adaptive_node_pool + : public private_adaptive_node_pool + +{ + private: + typedef private_adaptive_node_pool + private_node_allocator_t; + public: + typedef typename private_node_allocator_t::multiallocation_chain multiallocation_chain; + + //!Constructor. Never throws + shared_adaptive_node_pool() + : private_node_allocator_t(){} + + //!Destructor. Deallocates all allocated blocks. Never throws + ~shared_adaptive_node_pool() + {} + + //!Allocates array of count elements. Can throw bad_alloc + void *allocate_node() + { + //----------------------- + scoped_lock guard(mutex_); + //----------------------- + return private_node_allocator_t::allocate_node(); + } + + //!Deallocates an array pointed by ptr. Never throws + void deallocate_node(void *ptr) + { + //----------------------- + scoped_lock guard(mutex_); + //----------------------- + private_node_allocator_t::deallocate_node(ptr); + } + + //!Allocates a singly linked list of n nodes ending in null pointer. + //!can throw bad_alloc + void allocate_nodes(const std::size_t n, multiallocation_chain &chain) + { + //----------------------- + scoped_lock guard(mutex_); + //----------------------- + return private_node_allocator_t::allocate_nodes(n, chain); + } + + void deallocate_nodes(multiallocation_chain &chain) + { + //----------------------- + scoped_lock guard(mutex_); + //----------------------- + private_node_allocator_t::deallocate_nodes(chain); + } + + //!Deallocates all the free blocks of memory. Never throws + void deallocate_free_blocks() + { + //----------------------- + scoped_lock guard(mutex_); + //----------------------- + private_node_allocator_t::deallocate_free_blocks(); + } + + private: + default_mutex mutex_; +}; + +} //namespace dtl { +} //namespace container { +} //namespace boost { + +#include + +#endif //#ifndef BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_HPP diff --git a/boost/include/boost/container/detail/adaptive_node_pool_impl.hpp b/boost/include/boost/container/detail/adaptive_node_pool_impl.hpp new file mode 100644 index 00000000..119b5b61 --- /dev/null +++ b/boost/include/boost/container/detail/adaptive_node_pool_impl.hpp @@ -0,0 +1,1260 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2005-2013. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_IMPL_HPP +#define BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_IMPL_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include + +// container +#include +#include +// container/detail +#include +#include +#include +#include +#include +#include +#include +#include +#include +// intrusive +#include +#include +#include +#include +// other +#include +#include + +namespace boost { +namespace container { + +namespace adaptive_pool_flag { + +BOOST_CONTAINER_CONSTANT_VAR unsigned int none = 0u; +BOOST_CONTAINER_CONSTANT_VAR unsigned int align_only = 1u << 0u; +BOOST_CONTAINER_CONSTANT_VAR unsigned int size_ordered = 1u << 1u; +BOOST_CONTAINER_CONSTANT_VAR unsigned int address_ordered = 1u << 2u; + +} //namespace adaptive_pool_flag{ + +namespace dtl { + +template +struct hdr_offset_holder_t +{ + hdr_offset_holder_t(size_type offset = 0) + : hdr_offset(offset) + {} + size_type hdr_offset; +}; + +template +struct less_func; + +template +struct less_func +{ + static bool less(SizeType, SizeType, const void *, const void *) + { return true; } +}; + +template +struct less_func +{ + static bool less(SizeType ls, SizeType rs, const void *, const void *) + { return ls < rs; } +}; + +template +struct less_func +{ + static bool less(SizeType, SizeType, const void *la, const void *ra) + { return la < ra; } +}; + +template +struct less_func +{ + static bool less(SizeType ls, SizeType rs, const void *la, const void *ra) + { return (ls < rs) || ((ls == rs) && (la < ra)); } +}; + +template +struct block_container_traits +{ + typedef typename bi::make_set_base_hook + < bi::void_pointer + , bi::optimize_size + , bi::link_mode >::type hook_t; + + template + struct container + { + typedef typename bi::make_multiset + , bi::size_type >::type type; + }; + + template + static void reinsert_was_used(Container &container, typename Container::reference v, bool) + { + typedef typename Container::const_iterator const_block_iterator; + typedef typename Container::iterator block_iterator; + typedef typename Container::value_compare value_compare; + + const block_iterator this_block(Container::s_iterator_to(v)); + const const_block_iterator cendit(container.cend()); + block_iterator next_block(this_block); + + if(++next_block != cendit && value_compare()(*next_block, v)){ + const_block_iterator next2_block(next_block); + //Test if v should be swapped with next (optimization) + if(++next2_block == cendit || !value_compare()(*next2_block, v)){ + v.swap_nodes(*next_block); + BOOST_ASSERT(++next_block == this_block); + } + else{ + container.erase(this_block); + container.insert(v); + } + } + } + + template + static void insert_was_empty(Container &container, typename Container::value_type &v, bool) + { + container.insert(v); + } + + template + static void erase_first(Container &container) + { + container.erase(container.cbegin()); + } + + template + static void erase_last(Container &container) + { + container.erase(--container.cend()); + } +}; + +template +struct block_container_traits +{ + typedef typename bi::make_list_base_hook + < bi::void_pointer + , bi::link_mode >::type hook_t; + + template + struct container + { + typedef typename bi::make_list + , bi::size_type, bi::constant_time_size >::type type; + }; + + template + static void reinsert_was_used(Container &container, typename Container::value_type &v, bool is_full) + { + if(is_full){ + container.erase(Container::s_iterator_to(v)); + container.push_back(v); + } + } + + template + static void insert_was_empty(Container &container, typename Container::value_type &v, bool is_full) + { + if(is_full){ + container.push_back(v); + } + else{ + container.push_front(v); + } + } + + template + static void erase_first(Container &container) + { + container.pop_front(); + } + + template + static void erase_last(Container &container) + { + container.pop_back(); + } +}; + +///////////////////////////// +// +// adaptive_pool_types +// +///////////////////////////// +template +struct adaptive_pool_types +{ + typedef VoidPointer void_pointer; + BOOST_STATIC_CONSTEXPR unsigned ordered = (Flags & (adaptive_pool_flag::size_ordered | adaptive_pool_flag::address_ordered)); + typedef block_container_traits block_container_traits_t; + typedef typename block_container_traits_t::hook_t hook_t; + typedef hdr_offset_holder_t hdr_offset_holder; + BOOST_STATIC_CONSTEXPR unsigned int order_flags = Flags & (adaptive_pool_flag::size_ordered | adaptive_pool_flag::address_ordered); + typedef MultiallocationChain free_nodes_t; + + struct block_info_t + : public hdr_offset_holder, + public hook_t + { + //An intrusive list of free node from this block + free_nodes_t free_nodes; + friend bool operator <(const block_info_t &l, const block_info_t &r) + { + return less_func:: + less(l.free_nodes.size(), r.free_nodes.size(), &l , &r); + } + + friend bool operator ==(const block_info_t &l, const block_info_t &r) + { return &l == &r; } + }; + typedef typename block_container_traits_t:: template container::type block_container_t; +}; + + +///////////////////////////////////////////// +// +// candidate_power_of_2_ct +// +///////////////////////////////////////////// +template< std::size_t alignment + , std::size_t real_node_size + , std::size_t payload_per_allocation + , std::size_t min_elements_per_block + , std::size_t hdr_size + , std::size_t hdr_offset_size + , std::size_t overhead_percent> +struct candidate_power_of_2_ct_helper +{ + BOOST_STATIC_CONSTEXPR std::size_t hdr_subblock_elements_alone = (alignment - hdr_size - payload_per_allocation)/real_node_size; + BOOST_STATIC_CONSTEXPR std::size_t hdr_subblock_elements_first = (alignment - hdr_size - payload_per_allocation)/real_node_size; + BOOST_STATIC_CONSTEXPR std::size_t elements_per_b_subblock_mid = (alignment - hdr_offset_size)/real_node_size; + BOOST_STATIC_CONSTEXPR std::size_t elements_per_b_subblock_end = (alignment - hdr_offset_size - payload_per_allocation)/real_node_size; + BOOST_STATIC_CONSTEXPR std::size_t num_b_subblock = + hdr_subblock_elements_alone >= min_elements_per_block + ? 0 + : ( ((hdr_subblock_elements_first + elements_per_b_subblock_end) >= min_elements_per_block) + ? 1 + : 2 + (min_elements_per_block - hdr_subblock_elements_first - elements_per_b_subblock_end - 1)/elements_per_b_subblock_mid + ) + ; + + BOOST_STATIC_CONSTEXPR std::size_t num_b_subblock_mid = (num_b_subblock > 1) ? (num_b_subblock - 1) : 0; + + BOOST_STATIC_CONSTEXPR std::size_t total_nodes = (num_b_subblock == 0) + ? hdr_subblock_elements_alone + : ( (num_b_subblock == 1) + ? (hdr_subblock_elements_first + elements_per_b_subblock_end) + : (hdr_subblock_elements_first + num_b_subblock_mid*elements_per_b_subblock_mid + elements_per_b_subblock_end) + ) + ; + BOOST_STATIC_CONSTEXPR std::size_t total_data = total_nodes*real_node_size; + BOOST_STATIC_CONSTEXPR std::size_t total_size = alignment*(num_b_subblock+1); + BOOST_STATIC_CONSTEXPR bool overhead_satisfied = (total_size - total_data)*100/total_size < overhead_percent; +}; + +template< std::size_t initial_alignment + , std::size_t real_node_size + , std::size_t payload_per_allocation + , std::size_t min_elements_per_block + , std::size_t hdr_size + , std::size_t hdr_offset_size + , std::size_t overhead_percent + , bool Loop = true> +struct candidate_power_of_2_ct +{ + typedef candidate_power_of_2_ct_helper + < initial_alignment + , real_node_size + , payload_per_allocation + , min_elements_per_block + , hdr_size + , hdr_offset_size + , overhead_percent> helper_t; + + BOOST_STATIC_CONSTEXPR std::size_t candidate_power_of_2 = initial_alignment << std::size_t(!helper_t::overhead_satisfied); + + typedef typename candidate_power_of_2_ct + < candidate_power_of_2 + , real_node_size + , payload_per_allocation + , min_elements_per_block + , hdr_size + , hdr_offset_size + , overhead_percent + , !helper_t::overhead_satisfied + >::type type; + + BOOST_STATIC_CONSTEXPR std::size_t alignment = type::alignment; + BOOST_STATIC_CONSTEXPR std::size_t num_subblocks = type::num_subblocks; + BOOST_STATIC_CONSTEXPR std::size_t real_num_node = type::real_num_node; +}; + +template< std::size_t initial_alignment + , std::size_t real_node_size + , std::size_t payload_per_allocation + , std::size_t min_elements_per_block + , std::size_t hdr_size + , std::size_t hdr_offset_size + , std::size_t overhead_percent + > +struct candidate_power_of_2_ct + < initial_alignment + , real_node_size + , payload_per_allocation + , min_elements_per_block + , hdr_size + , hdr_offset_size + , overhead_percent + , false> +{ + typedef candidate_power_of_2_ct + < initial_alignment + , real_node_size + , payload_per_allocation + , min_elements_per_block + , hdr_size + , hdr_offset_size + , overhead_percent + , false> type; + + typedef candidate_power_of_2_ct_helper + < initial_alignment + , real_node_size + , payload_per_allocation + , min_elements_per_block + , hdr_size + , hdr_offset_size + , overhead_percent> helper_t; + + BOOST_STATIC_CONSTEXPR std::size_t alignment = initial_alignment; + BOOST_STATIC_CONSTEXPR std::size_t num_subblocks = helper_t::num_b_subblock+1; + BOOST_STATIC_CONSTEXPR std::size_t real_num_node = helper_t::total_nodes; +}; + +///////////////////////////////////////////// +// +// candidate_power_of_2_rt +// +///////////////////////////////////////////// +inline void candidate_power_of_2_rt ( std::size_t initial_alignment + , std::size_t real_node_size + , std::size_t payload_per_allocation + , std::size_t min_elements_per_block + , std::size_t hdr_size + , std::size_t hdr_offset_size + , std::size_t overhead_percent + , std::size_t &alignment + , std::size_t &num_subblocks + , std::size_t &real_num_node) +{ + bool overhead_satisfied = false; + std::size_t num_b_subblock = 0; + std::size_t total_nodes = 0; + + while(!overhead_satisfied) + { + std::size_t hdr_subblock_elements_alone = (initial_alignment - hdr_size - payload_per_allocation)/real_node_size; + std::size_t hdr_subblock_elements_first = (initial_alignment - hdr_size - payload_per_allocation)/real_node_size; + std::size_t elements_per_b_subblock_mid = (initial_alignment - hdr_offset_size)/real_node_size; + std::size_t elements_per_b_subblock_end = (initial_alignment - hdr_offset_size - payload_per_allocation)/real_node_size; + + num_b_subblock = + hdr_subblock_elements_alone >= min_elements_per_block + ? 0 + : ( ((hdr_subblock_elements_first + elements_per_b_subblock_end) >= min_elements_per_block) + ? 1 + : 2 + (min_elements_per_block - hdr_subblock_elements_first - elements_per_b_subblock_end - 1)/elements_per_b_subblock_mid + ) + ; + + std::size_t num_b_subblock_mid = (num_b_subblock > 1) ? (num_b_subblock - 1) : 0; + + total_nodes = (num_b_subblock == 0) + ? hdr_subblock_elements_alone + : ( (num_b_subblock == 1) + ? (hdr_subblock_elements_first + elements_per_b_subblock_end) + : (hdr_subblock_elements_first + num_b_subblock_mid*elements_per_b_subblock_mid + elements_per_b_subblock_end) + ) + ; + std::size_t total_data = total_nodes*real_node_size; + std::size_t total_size = initial_alignment*(num_b_subblock+1); + overhead_satisfied = (total_size - total_data)*100/total_size < overhead_percent; + initial_alignment = initial_alignment << std::size_t(!overhead_satisfied); + } + alignment = initial_alignment; + num_subblocks = num_b_subblock+1; + real_num_node = total_nodes; +} + +///////////////////////////////////////////// +// +// private_adaptive_node_pool_impl_common +// +///////////////////////////////////////////// +template< class SegmentManagerBase, unsigned int Flags> +class private_adaptive_node_pool_impl_common +{ + public: + //!Segment manager typedef + typedef SegmentManagerBase segment_manager_base_type; + typedef typename SegmentManagerBase::multiallocation_chain multiallocation_chain; + typedef typename SegmentManagerBase::size_type size_type; + //Flags + //align_only + BOOST_STATIC_CONSTEXPR bool AlignOnly = (Flags & adaptive_pool_flag::align_only) != 0; + typedef bool_ IsAlignOnly; + typedef true_ AlignOnlyTrue; + typedef false_ AlignOnlyFalse; + + typedef typename SegmentManagerBase::void_pointer void_pointer; + BOOST_STATIC_CONSTEXPR typename SegmentManagerBase:: + size_type PayloadPerAllocation = SegmentManagerBase::PayloadPerAllocation; + + typedef typename boost::intrusive::pointer_traits + ::template rebind_pointer::type segment_mngr_base_ptr_t; + + protected: + typedef adaptive_pool_types + adaptive_pool_types_t; + typedef typename adaptive_pool_types_t::free_nodes_t free_nodes_t; + typedef typename adaptive_pool_types_t::block_info_t block_info_t; + typedef typename adaptive_pool_types_t::block_container_t block_container_t; + typedef typename adaptive_pool_types_t::block_container_traits_t block_container_traits_t; + typedef typename block_container_t::iterator block_iterator; + typedef typename block_container_t::const_iterator const_block_iterator; + typedef typename adaptive_pool_types_t::hdr_offset_holder hdr_offset_holder; + typedef private_adaptive_node_pool_impl_common this_type; + + BOOST_STATIC_CONSTEXPR size_type MaxAlign = alignment_of::value; + BOOST_STATIC_CONSTEXPR size_type HdrSize = ((sizeof(block_info_t)-1)/MaxAlign+1)*MaxAlign; + BOOST_STATIC_CONSTEXPR size_type HdrOffsetSize = ((sizeof(hdr_offset_holder)-1)/MaxAlign+1)*MaxAlign; + + segment_mngr_base_ptr_t mp_segment_mngr_base; //Segment manager + block_container_t m_block_container; //Intrusive block list + size_type m_totally_free_blocks; //Free blocks + + class block_destroyer; + friend class block_destroyer; + + class block_destroyer + { + public: + block_destroyer(const this_type *impl, multiallocation_chain &chain, const size_type num_subblocks, const size_type real_block_alignment, const size_type real_num_node) + : mp_impl(impl), m_chain(chain), m_num_subblocks(num_subblocks), m_real_block_alignment(real_block_alignment), m_real_num_node(real_num_node) + {} + + void operator()(typename block_container_t::pointer to_deallocate) + { return this->do_destroy(to_deallocate, IsAlignOnly()); } + + private: + void do_destroy(typename block_container_t::pointer to_deallocate, AlignOnlyTrue) + { + BOOST_ASSERT(to_deallocate->free_nodes.size() == m_real_num_node); + m_chain.push_back(to_deallocate); + } + + void do_destroy(typename block_container_t::pointer to_deallocate, AlignOnlyFalse) + { + BOOST_ASSERT(to_deallocate->free_nodes.size() == m_real_num_node); + BOOST_ASSERT(0 == to_deallocate->hdr_offset); + hdr_offset_holder *hdr_off_holder = + mp_impl->priv_first_subblock_from_block(boost::movelib::to_raw_pointer(to_deallocate), m_num_subblocks, m_real_block_alignment); + m_chain.push_back(hdr_off_holder); + } + + const this_type *mp_impl; + multiallocation_chain &m_chain; + const size_type m_num_subblocks; + const size_type m_real_block_alignment; + const size_type m_real_num_node; + }; + + //This macro will activate invariant checking. Slow, but helpful for debugging the code. + //#define BOOST_CONTAINER_ADAPTIVE_NODE_POOL_CHECK_INVARIANTS + void priv_invariants(const size_type real_num_node, const size_type num_subblocks, const size_type real_block_alignment) const + { + (void)real_num_node; (void)num_subblocks; (void)real_block_alignment; + #ifdef BOOST_CONTAINER_ADAPTIVE_NODE_POOL_CHECK_INVARIANTS + //Check that the total totally free blocks are correct + BOOST_ASSERT(m_block_container.size() >= m_totally_free_blocks); + + const const_block_iterator itend(m_block_container.cend()); + const const_block_iterator itbeg(m_block_container.cbegin()); + + { //Try to do checks in a single iteration + const_block_iterator it(itbeg); + size_type total_free_nodes = 0; + size_type total_free_blocks = 0u; + for(; it != itend; ++it){ + if(it != itbeg){ + //Check order invariant + const_block_iterator prev(it); + --prev; + BOOST_ASSERT(!(m_block_container.key_comp()(*it, *prev))); + (void)prev; (void)it; + } + + //free_nodes invariant + const size_type free_nodes = it->free_nodes.size(); + BOOST_ASSERT(free_nodes <= real_num_node); + BOOST_ASSERT(free_nodes != 0); + + //Acummulate total_free_nodes and total_free_blocks + total_free_nodes += free_nodes; + total_free_blocks += it->free_nodes.size() == real_num_node; + + if (!AlignOnly) { + //Check that header offsets are correct + hdr_offset_holder *hdr_off_holder = this->priv_first_subblock_from_block(const_cast(&*it), num_subblocks, real_block_alignment); + for (size_type i = 0, max = num_subblocks; i < max; ++i) { + const size_type offset = size_type(reinterpret_cast(const_cast(&*it)) - reinterpret_cast(hdr_off_holder)); + (void)offset; + BOOST_ASSERT(hdr_off_holder->hdr_offset == offset); + BOOST_ASSERT(0 == (reinterpret_cast(hdr_off_holder) & (real_block_alignment - 1))); + BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (real_block_alignment - 1))); + hdr_off_holder = move_detail::force_ptr(reinterpret_cast(hdr_off_holder) + real_block_alignment); + } + } + } + BOOST_ASSERT(total_free_blocks == m_totally_free_blocks); + BOOST_ASSERT(total_free_nodes >= m_totally_free_blocks*real_num_node); + } + #endif + } + + void priv_deallocate_free_blocks( const size_type max_free_blocks, const size_type real_num_node + , const size_type num_subblocks, const size_type real_block_alignment) + { //Trampoline function to ease inlining + if(m_totally_free_blocks > max_free_blocks){ + this->priv_deallocate_free_blocks_impl(max_free_blocks, real_num_node, num_subblocks, real_block_alignment); + } + } + + hdr_offset_holder *priv_first_subblock_from_block(block_info_t *block, const size_type num_subblocks, const size_type real_block_alignment) const + { return this->priv_first_subblock_from_block(block, num_subblocks, real_block_alignment, IsAlignOnly()); } + + hdr_offset_holder *priv_first_subblock_from_block(block_info_t *block, const size_type num_subblocks, const size_type real_block_alignment, AlignOnlyFalse) const + { + hdr_offset_holder *const hdr_off_holder = move_detail::force_ptr + (reinterpret_cast(block) - (num_subblocks-1)*real_block_alignment); + BOOST_ASSERT(hdr_off_holder->hdr_offset == size_type(reinterpret_cast(block) - reinterpret_cast(hdr_off_holder))); + BOOST_ASSERT(0 == ((std::size_t)hdr_off_holder & (real_block_alignment - 1))); + BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (real_block_alignment - 1))); + return hdr_off_holder; + } + + hdr_offset_holder *priv_first_subblock_from_block(block_info_t *block, const size_type num_subblocks, const size_type real_block_alignment, AlignOnlyTrue) const + { + (void)num_subblocks; (void)real_block_alignment; + return move_detail::force_ptr(block); + } + + void priv_deallocate_free_blocks_impl( const size_type max_free_blocks, const size_type real_num_node + , const size_type num_subblocks, const size_type real_block_alignment) + { + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + //Now check if we've reached the free nodes limit + //and check if we have free blocks. If so, deallocate as much + //as we can to stay below the limit + multiallocation_chain chain; + { + if(Flags & adaptive_pool_flag::size_ordered){ + const_block_iterator it = m_block_container.cend(); + --it; + size_type totally_free_blocks = m_totally_free_blocks; + + for( ; totally_free_blocks > max_free_blocks; --totally_free_blocks){ + BOOST_ASSERT(it->free_nodes.size() == real_num_node); + void *addr = priv_first_subblock_from_block(const_cast(&*it), num_subblocks, real_block_alignment); + --it; + block_container_traits_t::erase_last(m_block_container); + chain.push_front(void_pointer(addr)); + } + } + else{ + const_block_iterator it = m_block_container.cend(); + size_type totally_free_blocks = m_totally_free_blocks; + + while(totally_free_blocks > max_free_blocks){ + --it; + if(it->free_nodes.size() == real_num_node){ + void *addr = priv_first_subblock_from_block(const_cast(&*it), num_subblocks, real_block_alignment); + it = m_block_container.erase(it); + chain.push_front(void_pointer(addr)); + --totally_free_blocks; + } + } + } + BOOST_ASSERT((m_totally_free_blocks - max_free_blocks) == chain.size()); + m_totally_free_blocks = max_free_blocks; + } + this->mp_segment_mngr_base->deallocate_many(chain); + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + } + + void priv_fill_chain_remaining_to_block + ( multiallocation_chain &chain, size_type target_elem_in_chain, block_info_t &c_info + , char *mem_address, size_type max_node_in_mem + , const size_type real_node_size) + { + BOOST_ASSERT(chain.size() <= target_elem_in_chain); + + //First add all possible nodes to the chain + const size_type left = target_elem_in_chain - chain.size(); + const size_type add_to_chain = (max_node_in_mem < left) ? max_node_in_mem : left; + char *free_mem_address = static_cast(boost::movelib::to_raw_pointer + (chain.incorporate_after(chain.last(), void_pointer(mem_address), real_node_size, add_to_chain))); + //Now store remaining nodes in the free list + if(const size_type free = max_node_in_mem - add_to_chain){ + free_nodes_t & free_nodes = c_info.free_nodes; + free_nodes.incorporate_after(free_nodes.last(), void_pointer(free_mem_address), real_node_size, free); + } + } + + //!Allocates a several blocks of nodes. Can throw + void priv_append_from_new_blocks( size_type min_elements, multiallocation_chain &chain + , const size_type max_free_blocks + , const size_type real_block_alignment, const size_type real_node_size + , const size_type real_num_node, const size_type num_subblocks + , AlignOnlyTrue) + { + (void)num_subblocks; + BOOST_ASSERT(m_block_container.empty()); + BOOST_ASSERT(min_elements > 0); + const size_type n = (min_elements - 1)/real_num_node + 1; + const size_type real_block_size = real_block_alignment - PayloadPerAllocation; + const size_type target_elem_in_chain = chain.size() + min_elements; + for(size_type i = 0; i != n; ++i){ + //We allocate a new NodeBlock and put it the last + //element of the tree + char *mem_address = static_cast + (mp_segment_mngr_base->allocate_aligned(real_block_size, real_block_alignment)); + if(!mem_address){ + //In case of error, free memory deallocating all nodes (the new ones allocated + //in this function plus previously stored nodes in chain). + this->priv_deallocate_nodes(chain, max_free_blocks, real_num_node, num_subblocks, real_block_alignment); + throw_bad_alloc(); + } + block_info_t &c_info = *new(mem_address, boost_container_new_t())block_info_t(); + mem_address += HdrSize; + this->priv_fill_chain_remaining_to_block(chain, target_elem_in_chain, c_info, mem_address, real_num_node, real_node_size); + const size_type free_nodes = c_info.free_nodes.size(); + if(free_nodes){ + const bool is_full = free_nodes == real_num_node; + BOOST_ASSERT(free_nodes < real_num_node); + m_totally_free_blocks += static_cast(is_full); + block_container_traits_t::insert_was_empty(m_block_container, c_info, is_full); + } + } + } + + void priv_append_from_new_blocks( size_type min_elements, multiallocation_chain &chain + , const size_type max_free_blocks + , const size_type real_block_alignment, const size_type real_node_size + , const size_type real_num_node, const size_type num_subblocks + , AlignOnlyFalse) + { + BOOST_ASSERT(m_block_container.empty()); + BOOST_ASSERT(min_elements > 0); + const size_type n = (min_elements - 1)/real_num_node + 1; + const size_type real_block_size = real_block_alignment*num_subblocks - PayloadPerAllocation; + const size_type elements_per_subblock_mid = (real_block_alignment - HdrOffsetSize)/real_node_size; + const size_type elements_per_subblock_end = (real_block_alignment - HdrOffsetSize - PayloadPerAllocation) / real_node_size; + const size_type hdr_subblock_elements = (real_block_alignment - HdrSize - PayloadPerAllocation)/real_node_size; + const size_type target_elem_in_chain = chain.size() + min_elements; + + for(size_type i = 0; i != n; ++i){ + //We allocate a new NodeBlock and put it the last + //element of the tree + char *mem_address = static_cast + (mp_segment_mngr_base->allocate_aligned(real_block_size, real_block_alignment)); + if(!mem_address){ + //In case of error, free memory deallocating all nodes (the new ones allocated + //in this function plus previously stored nodes in chain). + this->priv_deallocate_nodes(chain, max_free_blocks, real_num_node, num_subblocks, real_block_alignment); + throw_bad_alloc(); + } + //First initialize header information on the last subblock + char *hdr_addr = mem_address + real_block_alignment*(num_subblocks-1); + block_info_t &c_info = *new(hdr_addr, boost_container_new_t())block_info_t(); + //Some structural checks + BOOST_ASSERT(static_cast(&static_cast(c_info).hdr_offset) == + static_cast(&c_info)); (void)c_info; + for( size_type subblock = 0, maxsubblock = num_subblocks - 1 + ; subblock < maxsubblock + ; ++subblock, mem_address += real_block_alignment){ + //Initialize header offset mark + new(mem_address, boost_container_new_t()) hdr_offset_holder(size_type(hdr_addr - mem_address)); + const size_type elements_per_subblock = (subblock != (maxsubblock - 1)) ? elements_per_subblock_mid : elements_per_subblock_end; + this->priv_fill_chain_remaining_to_block + (chain, target_elem_in_chain, c_info, mem_address + HdrOffsetSize, elements_per_subblock, real_node_size); + } + this->priv_fill_chain_remaining_to_block + (chain, target_elem_in_chain, c_info, hdr_addr + HdrSize, hdr_subblock_elements, real_node_size); + m_totally_free_blocks += static_cast(c_info.free_nodes.size() == real_num_node); + if (c_info.free_nodes.size()) + m_block_container.push_front(c_info); + } + } + + //!Allocates array of count elements. Can throw + void *priv_allocate_node( const size_type max_free_blocks, const size_type real_block_alignment, const size_type real_node_size + , const size_type real_num_node, const size_type num_subblocks) + { + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + //If there are no free nodes we allocate a new block + if(!m_block_container.empty()){ + //We take the first free node the multiset can't be empty + free_nodes_t &free_nodes = m_block_container.begin()->free_nodes; + BOOST_ASSERT(!free_nodes.empty()); + const size_type free_nodes_count = free_nodes.size(); + void *first_node = boost::movelib::to_raw_pointer(free_nodes.pop_front()); + if(free_nodes.empty()){ + block_container_traits_t::erase_first(m_block_container); + } + m_totally_free_blocks -= static_cast(free_nodes_count == real_num_node); + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + return first_node; + } + else{ + multiallocation_chain chain; + this->priv_append_from_new_blocks + (1, chain, max_free_blocks, real_block_alignment, real_node_size, real_num_node, num_subblocks, IsAlignOnly()); + void *node = boost::movelib::to_raw_pointer(chain.pop_front()); + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + return node; + } + } + + void priv_allocate_nodes( const size_type n, multiallocation_chain &chain + , const size_type max_free_blocks, const size_type real_block_alignment, const size_type real_node_size + , const size_type real_num_node, const size_type num_subblocks) + { + size_type i = 0; + BOOST_CONTAINER_TRY{ + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + while(i != n){ + //If there are no free nodes we allocate all needed blocks + if (m_block_container.empty()){ + this->priv_append_from_new_blocks + (n - i, chain, max_free_blocks, real_block_alignment, real_node_size, real_num_node, num_subblocks, IsAlignOnly()); + BOOST_ASSERT(m_block_container.empty() || (++m_block_container.cbegin() == m_block_container.cend())); + BOOST_ASSERT(chain.size() == n); + break; + } + free_nodes_t &free_nodes = m_block_container.begin()->free_nodes; + const size_type free_nodes_count_before = free_nodes.size(); + m_totally_free_blocks -= static_cast(free_nodes_count_before == real_num_node); + const size_type num_left = n-i; + const size_type num_elems = (num_left < free_nodes_count_before) ? num_left : free_nodes_count_before; + typedef typename free_nodes_t::iterator free_nodes_iterator; + + if(num_left < free_nodes_count_before){ + const free_nodes_iterator it_bbeg(free_nodes.before_begin()); + free_nodes_iterator it_bend(it_bbeg); + for(size_type j = 0; j != num_elems; ++j){ + ++it_bend; + } + free_nodes_iterator it_end = it_bend; ++it_end; + free_nodes_iterator it_beg = it_bbeg; ++it_beg; + free_nodes.erase_after(it_bbeg, it_end, num_elems); + chain.incorporate_after(chain.last(), &*it_beg, &*it_bend, num_elems); + //chain.splice_after(chain.last(), free_nodes, it_bbeg, it_bend, num_elems); + BOOST_ASSERT(!free_nodes.empty()); + } + else{ + const free_nodes_iterator it_beg(free_nodes.begin()), it_bend(free_nodes.last()); + free_nodes.clear(); + chain.incorporate_after(chain.last(), &*it_beg, &*it_bend, num_elems); + block_container_traits_t::erase_first(m_block_container); + } + i += num_elems; + } + } + BOOST_CONTAINER_CATCH(...){ + this->priv_deallocate_nodes(chain, max_free_blocks, real_num_node, num_subblocks, real_block_alignment); + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + } + + //!Deallocates an array pointed by ptr. Never throws + void priv_deallocate_node( void *pElem + , const size_type max_free_blocks, const size_type real_num_node + , const size_type num_subblocks, const size_type real_block_alignment) + { + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + block_info_t &block_info = *this->priv_block_from_node(pElem, real_block_alignment); + const size_type prev_free_nodes = block_info.free_nodes.size(); + BOOST_ASSERT(block_info.free_nodes.size() < real_num_node); + + //We put the node at the beginning of the free node list + block_info.free_nodes.push_back(void_pointer(pElem)); + + //The loop reinserts all blocks except the last one + this->priv_reinsert_block(block_info, prev_free_nodes == 0, real_num_node); + this->priv_deallocate_free_blocks(max_free_blocks, real_num_node, num_subblocks, real_block_alignment); + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + } + + void priv_deallocate_nodes( multiallocation_chain &nodes + , const size_type max_free_blocks, const size_type real_num_node + , const size_type num_subblocks, const size_type real_block_alignment) + { + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + //To take advantage of node locality, wait until two + //nodes belong to different blocks. Only then reinsert + //the block of the first node in the block tree. + //Cache of the previous block + block_info_t *prev_block_info = 0; + + //If block was empty before this call, it's not already + //inserted in the block tree. + bool prev_block_was_empty = false; + typedef typename free_nodes_t::iterator free_nodes_iterator; + { + const free_nodes_iterator itbb(nodes.before_begin()), ite(nodes.end()); + free_nodes_iterator itf(nodes.begin()), itbf(itbb); + size_type splice_node_count = size_type(-1); + while(itf != ite){ + void *pElem = boost::movelib::to_raw_pointer(boost::movelib::iterator_to_raw_pointer(itf)); + block_info_t &block_info = *this->priv_block_from_node(pElem, real_block_alignment); + BOOST_ASSERT(block_info.free_nodes.size() < real_num_node); + ++splice_node_count; + + //If block change is detected calculate the cached block position in the tree + if(&block_info != prev_block_info){ + if(prev_block_info){ //Make sure we skip the initial "dummy" cache + free_nodes_iterator it(itbb); ++it; + nodes.erase_after(itbb, itf, splice_node_count); + prev_block_info->free_nodes.incorporate_after(prev_block_info->free_nodes.last(), &*it, &*itbf, splice_node_count); + this->priv_reinsert_block(*prev_block_info, prev_block_was_empty, real_num_node); + splice_node_count = 0; + } + //Update cache with new data + prev_block_was_empty = block_info.free_nodes.empty(); + prev_block_info = &block_info; + } + itbf = itf; + ++itf; + } + } + if(prev_block_info){ + //The loop reinserts all blocks except the last one + const free_nodes_iterator itfirst(nodes.begin()), itlast(nodes.last()); + const size_type splice_node_count = nodes.size(); + nodes.clear(); + prev_block_info->free_nodes.incorporate_after(prev_block_info->free_nodes.last(), &*itfirst, &*itlast, splice_node_count); + this->priv_reinsert_block(*prev_block_info, prev_block_was_empty, real_num_node); + this->priv_deallocate_free_blocks(max_free_blocks, real_num_node, num_subblocks, real_block_alignment); + } + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + } + + void priv_reinsert_block(block_info_t &prev_block_info, const bool prev_block_was_empty, const size_type real_num_node) + { + //Cache the free nodes from the block + const size_type this_block_free_nodes = prev_block_info.free_nodes.size(); + const bool is_full = this_block_free_nodes == real_num_node; + + //Update free block count + m_totally_free_blocks += static_cast(is_full); + if(prev_block_was_empty){ + block_container_traits_t::insert_was_empty(m_block_container, prev_block_info, is_full); + } + else{ + block_container_traits_t::reinsert_was_used(m_block_container, prev_block_info, is_full); + } + } + + block_info_t *priv_block_from_node(void *node, const size_type real_block_alignment, AlignOnlyFalse) const + { + hdr_offset_holder *hdr_off_holder = + reinterpret_cast((std::size_t)node & size_type(~(real_block_alignment - 1))); + BOOST_ASSERT(0 == ((std::size_t)hdr_off_holder & (real_block_alignment - 1))); + BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (real_block_alignment - 1))); + block_info_t *block = move_detail::force_ptr + (reinterpret_cast(hdr_off_holder) + hdr_off_holder->hdr_offset); + BOOST_ASSERT(block->hdr_offset == 0); + return block; + } + + block_info_t *priv_block_from_node(void *node, const size_type real_block_alignment, AlignOnlyTrue) const + { + return (block_info_t *)((std::size_t)node & std::size_t(~(real_block_alignment - 1))); + } + + block_info_t *priv_block_from_node(void *node, const size_type real_block_alignment) const + { return this->priv_block_from_node(node, real_block_alignment, IsAlignOnly()); } + + //!Deallocates all used memory. Never throws + void priv_clear(const size_type num_subblocks, const size_type real_block_alignment, const size_type real_num_node) + { + #ifndef NDEBUG + block_iterator it = m_block_container.begin(); + block_iterator itend = m_block_container.end(); + size_type n_free_nodes = 0; + for(; it != itend; ++it){ + //Check for memory leak + BOOST_ASSERT(it->free_nodes.size() == real_num_node); + ++n_free_nodes; + } + BOOST_ASSERT(n_free_nodes == m_totally_free_blocks); + #endif + //Check for memory leaks + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + multiallocation_chain chain; + m_block_container.clear_and_dispose(block_destroyer(this, chain, num_subblocks, real_block_alignment, real_num_node)); + this->mp_segment_mngr_base->deallocate_many(chain); + m_totally_free_blocks = 0; + this->priv_invariants(real_num_node, num_subblocks, real_block_alignment); + } + + public: + private_adaptive_node_pool_impl_common(segment_manager_base_type *segment_mngr_base) + //General purpose allocator + : mp_segment_mngr_base(segment_mngr_base) + , m_block_container() + , m_totally_free_blocks(0) + {} + + size_type num_free_nodes() + { + typedef typename block_container_t::const_iterator citerator; + size_type count = 0; + citerator it (m_block_container.begin()), itend(m_block_container.end()); + for(; it != itend; ++it){ + count += it->free_nodes.size(); + } + return count; + } + + void swap(private_adaptive_node_pool_impl_common &other) + { + std::swap(mp_segment_mngr_base, other.mp_segment_mngr_base); + std::swap(m_totally_free_blocks, other.m_totally_free_blocks); + m_block_container.swap(other.m_block_container); + } + + //!Returns the segment manager. Never throws + segment_manager_base_type* get_segment_manager_base()const + { return boost::movelib::to_raw_pointer(mp_segment_mngr_base); } +}; + +template< class SizeType + , std::size_t HdrSize + , std::size_t PayloadPerAllocation + , std::size_t RealNodeSize + , std::size_t NodesPerBlock + , std::size_t HdrOffsetSize + , std::size_t OverheadPercent + , bool AlignOnly> +struct calculate_alignment_ct +{ + BOOST_STATIC_CONSTEXPR std::size_t alignment = upper_power_of_2_ct::value; + BOOST_STATIC_CONSTEXPR std::size_t num_subblocks = 0; + BOOST_STATIC_CONSTEXPR std::size_t real_num_node = (alignment - PayloadPerAllocation - HdrSize)/RealNodeSize; +}; + +template< class SizeType + , std::size_t HdrSize + , std::size_t PayloadPerAllocation + , std::size_t RealNodeSize + , std::size_t NodesPerBlock + , std::size_t HdrOffsetSize + , std::size_t OverheadPercent> +struct calculate_alignment_ct + < SizeType + , HdrSize + , PayloadPerAllocation + , RealNodeSize + , NodesPerBlock + , HdrOffsetSize + , OverheadPercent + , false> +{ + typedef typename candidate_power_of_2_ct + < upper_power_of_2_ct::value + , RealNodeSize + , PayloadPerAllocation + , NodesPerBlock + , HdrSize + , HdrOffsetSize + , OverheadPercent + >::type type; + + BOOST_STATIC_CONSTEXPR std::size_t alignment = type::alignment; + BOOST_STATIC_CONSTEXPR std::size_t num_subblocks = type::num_subblocks; + BOOST_STATIC_CONSTEXPR std::size_t real_num_node = type::real_num_node; +}; + + +///////////////////////////////////////////// +// +// private_adaptive_node_pool_impl_ct +// +///////////////////////////////////////////// +template< class SegmentManagerBase + , std::size_t MaxFreeBlocks + , std::size_t NodeSize + , std::size_t NodesPerBlock + , std::size_t OverheadPercent + , unsigned int Flags> +class private_adaptive_node_pool_impl_ct + : public private_adaptive_node_pool_impl_common +{ + typedef private_adaptive_node_pool_impl_common base_t; + + //Non-copyable + private_adaptive_node_pool_impl_ct(); + private_adaptive_node_pool_impl_ct(const private_adaptive_node_pool_impl_ct &); + private_adaptive_node_pool_impl_ct &operator=(const private_adaptive_node_pool_impl_ct &); + + public: + typedef typename base_t::void_pointer void_pointer; + typedef typename base_t::size_type size_type; + typedef typename base_t::multiallocation_chain multiallocation_chain; + typedef typename base_t::segment_manager_base_type segment_manager_base_type; + + BOOST_STATIC_CONSTEXPR typename base_t::size_type PayloadPerAllocation = base_t::PayloadPerAllocation; + + //align_only + BOOST_STATIC_CONSTEXPR bool AlignOnly = base_t::AlignOnly; + + private: + BOOST_STATIC_CONSTEXPR size_type MaxAlign = base_t::MaxAlign; + BOOST_STATIC_CONSTEXPR size_type HdrSize = base_t::HdrSize; + BOOST_STATIC_CONSTEXPR size_type HdrOffsetSize = base_t::HdrOffsetSize; + + BOOST_STATIC_CONSTEXPR size_type RealNodeSize = lcm_ct::value>::value; + + typedef calculate_alignment_ct + < size_type, HdrSize, PayloadPerAllocation + , RealNodeSize, NodesPerBlock, HdrOffsetSize, OverheadPercent, AlignOnly> data_t; + + //Round the size to a power of two value. + //This is the total memory size (including payload) that we want to + //allocate from the general-purpose allocator + BOOST_STATIC_CONSTEXPR size_type NumSubBlocks = data_t::num_subblocks; + BOOST_STATIC_CONSTEXPR size_type RealNumNode = data_t::real_num_node; + BOOST_STATIC_CONSTEXPR size_type RealBlockAlignment = data_t::alignment; + + public: + + //!Constructor from a segment manager. Never throws + private_adaptive_node_pool_impl_ct(typename base_t::segment_manager_base_type *segment_mngr_base) + //General purpose allocator + : base_t(segment_mngr_base) + {} + + //!Destructor. Deallocates all allocated blocks. Never throws + ~private_adaptive_node_pool_impl_ct() + { this->priv_clear(NumSubBlocks, data_t::alignment, RealNumNode); } + + size_type get_real_num_node() const + { return RealNumNode; } + + //!Allocates array of count elements. Can throw + void *allocate_node() + { + return this->priv_allocate_node + (MaxFreeBlocks, data_t::alignment, RealNodeSize, RealNumNode, NumSubBlocks); + } + + //!Allocates n nodes. + //!Can throw + void allocate_nodes(const size_type n, multiallocation_chain &chain) + { + this->priv_allocate_nodes + (n, chain, MaxFreeBlocks, data_t::alignment, RealNodeSize, RealNumNode, NumSubBlocks); + } + + //!Deallocates an array pointed by ptr. Never throws + void deallocate_node(void *pElem) + { + this->priv_deallocate_node(pElem, MaxFreeBlocks, RealNumNode, NumSubBlocks, RealBlockAlignment); + } + + //!Deallocates a linked list of nodes. Never throws + void deallocate_nodes(multiallocation_chain &nodes) + { + this->priv_deallocate_nodes(nodes, MaxFreeBlocks, RealNumNode, NumSubBlocks, data_t::alignment); + } + + void deallocate_free_blocks() + { this->priv_deallocate_free_blocks(0, RealNumNode, NumSubBlocks, data_t::alignment); } + + //Deprecated, use deallocate_free_blocks + void deallocate_free_chunks() + { this->priv_deallocate_free_blocks(0, RealNumNode, NumSubBlocks, data_t::alignment); } +}; + +///////////////////////////////////////////// +// +// private_adaptive_node_pool_impl_rt +// +///////////////////////////////////////////// +template +struct private_adaptive_node_pool_impl_rt_data +{ + typedef SizeType size_type; + + private_adaptive_node_pool_impl_rt_data(size_type max_free_blocks, size_type real_node_size) + : m_max_free_blocks(max_free_blocks), m_real_node_size(real_node_size) + , m_real_block_alignment(), m_num_subblocks(), m_real_num_node() + {} + + const size_type m_max_free_blocks; + const size_type m_real_node_size; + //Round the size to a power of two value. + //This is the total memory size (including payload) that we want to + //allocate from the general-purpose allocator + size_type m_real_block_alignment; + size_type m_num_subblocks; + //This is the real number of nodes per block + size_type m_real_num_node; +}; + + +template +class private_adaptive_node_pool_impl_rt + : private private_adaptive_node_pool_impl_rt_data + , public private_adaptive_node_pool_impl_common +{ + typedef private_adaptive_node_pool_impl_common impl_t; + typedef private_adaptive_node_pool_impl_rt_data data_t; + + //Non-copyable + private_adaptive_node_pool_impl_rt(); + private_adaptive_node_pool_impl_rt(const private_adaptive_node_pool_impl_rt &); + private_adaptive_node_pool_impl_rt &operator=(const private_adaptive_node_pool_impl_rt &); + + protected: + + typedef typename impl_t::void_pointer void_pointer; + typedef typename impl_t::size_type size_type; + typedef typename impl_t::multiallocation_chain multiallocation_chain; + + BOOST_STATIC_CONSTEXPR typename impl_t::size_type PayloadPerAllocation = impl_t::PayloadPerAllocation; + + //Flags + //align_only + BOOST_STATIC_CONSTEXPR bool AlignOnly = impl_t::AlignOnly; + + BOOST_STATIC_CONSTEXPR size_type HdrSize = impl_t::HdrSize; + BOOST_STATIC_CONSTEXPR size_type HdrOffsetSize = impl_t::HdrOffsetSize; + + public: + + //!Segment manager typedef + typedef SegmentManagerBase segment_manager_base_type; + + //!Constructor from a segment manager. Never throws + private_adaptive_node_pool_impl_rt + ( segment_manager_base_type *segment_mngr_base + , size_type node_size + , size_type nodes_per_block + , size_type max_free_blocks + , unsigned char overhead_percent + ) + : data_t(max_free_blocks, lcm(node_size, size_type(alignment_of::value))) + , impl_t(segment_mngr_base) + { + if(AlignOnly){ + this->m_real_block_alignment = upper_power_of_2(HdrSize + this->m_real_node_size*nodes_per_block); + this->m_real_num_node = (this->m_real_block_alignment - PayloadPerAllocation - HdrSize)/this->m_real_node_size; + } + else{ + candidate_power_of_2_rt ( upper_power_of_2(HdrSize + PayloadPerAllocation + this->m_real_node_size) + , this->m_real_node_size + , PayloadPerAllocation + , nodes_per_block + , HdrSize + , HdrOffsetSize + , overhead_percent + , this->m_real_block_alignment + , this->m_num_subblocks + , this->m_real_num_node); + } + } + + //!Destructor. Deallocates all allocated blocks. Never throws + ~private_adaptive_node_pool_impl_rt() + { this->priv_clear(this->m_num_subblocks, this->m_real_block_alignment, this->m_real_num_node); } + + size_type get_real_num_node() const + { return this->m_real_num_node; } + + //!Allocates array of count elements. Can throw + void *allocate_node() + { + return this->priv_allocate_node + (this->m_max_free_blocks, this->m_real_block_alignment, this->m_real_node_size, this->m_real_num_node, this->m_num_subblocks); + } + + //!Allocates n nodes. + //!Can throw + void allocate_nodes(const size_type n, multiallocation_chain &chain) + { + + this->priv_allocate_nodes + (n, chain, this->m_max_free_blocks, this->m_real_block_alignment, this->m_real_node_size, this->m_real_num_node, this->m_num_subblocks); + } + + //!Deallocates an array pointed by ptr. Never throws + void deallocate_node(void *pElem) + { + this->priv_deallocate_node(pElem, this->m_max_free_blocks, this->m_real_num_node, this->m_num_subblocks, this->m_real_block_alignment); + } + + //!Deallocates a linked list of nodes. Never throws + void deallocate_nodes(multiallocation_chain &nodes) + { + this->priv_deallocate_nodes(nodes, this->m_max_free_blocks, this->m_real_num_node, this->m_num_subblocks, this->m_real_block_alignment); + } + + void deallocate_free_blocks() + { this->priv_deallocate_free_blocks(0, this->m_real_num_node, this->m_num_subblocks, this->m_real_block_alignment); } + + //Deprecated, use deallocate_free_blocks + void deallocate_free_chunks() + { this->priv_deallocate_free_blocks(0, this->m_real_num_node, this->m_num_subblocks, this->m_real_block_alignment); } +}; + +} //namespace dtl { +} //namespace container { +} //namespace boost { + +#include + +#endif //#ifndef BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_IMPL_HPP diff --git a/boost/include/boost/container/detail/addressof.hpp b/boost/include/boost/container/detail/addressof.hpp new file mode 100644 index 00000000..00679b8f --- /dev/null +++ b/boost/include/boost/container/detail/addressof.hpp @@ -0,0 +1,33 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2014-2015. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// +#ifndef BOOST_CONTAINER_DETAIL_ADDRESSOF_HPP +#define BOOST_CONTAINER_DETAIL_ADDRESSOF_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include + +namespace boost { +namespace container { +namespace dtl { + +using boost::move_detail::addressof; + +} //namespace dtl { +} //namespace container { +} //namespace boost { + +#endif //#ifndef BOOST_CONTAINER_DETAIL_ADDRESSOF_HPP diff --git a/boost/include/boost/container/detail/advanced_insert_int.hpp b/boost/include/boost/container/detail/advanced_insert_int.hpp new file mode 100644 index 00000000..e16082a7 --- /dev/null +++ b/boost/include/boost/container/detail/advanced_insert_int.hpp @@ -0,0 +1,543 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2008-2013. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP +#define BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include + +// container +#include +// container/detail +#include +#include +#include +#include +#include +#include +#include +#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) +#include +#endif +// move + +#include +#include +#include +// other +#include + +namespace boost { namespace container { namespace dtl { + +template +struct move_insert_range_proxy +{ + typedef typename allocator_traits::value_type value_type; + + inline explicit move_insert_range_proxy(FwdIt first) + : first_(first) + {} + + template + inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) + { + this->first_ = ::boost::container::uninitialized_move_alloc_n_source + (a, this->first_, n, p); + } + + template + inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) + { + this->first_ = ::boost::container::move_n_source(this->first_, n, p); + } + + FwdIt first_; +}; + + +template +struct insert_range_proxy +{ + typedef typename allocator_traits::value_type value_type; + + inline explicit insert_range_proxy(FwdIt first) + : first_(first) + {} + + template + inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) + { + this->first_ = ::boost::container::uninitialized_copy_alloc_n_source(a, this->first_, n, p); + } + + template + inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) + { + this->first_ = ::boost::container::copy_n_source(this->first_, n, p); + } + + FwdIt first_; +}; + + +template +struct insert_n_copies_proxy +{ + typedef typename allocator_traits::value_type value_type; + + inline explicit insert_n_copies_proxy(const value_type &v) + : v_(v) + {} + + template + inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const + { boost::container::uninitialized_fill_alloc_n(a, v_, n, p); } + + template + inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const + { + while (n){ + --n; + *p = v_; + ++p; + } + } + + const value_type &v_; +}; + +template +struct insert_value_initialized_n_proxy +{ + typedef ::boost::container::allocator_traits alloc_traits; + typedef typename allocator_traits::value_type value_type; + typedef typename dtl::aligned_storage::value>::type storage_t; + + template + inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const + { boost::container::uninitialized_value_init_alloc_n(a, n, p); } + + template + void copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const + { + while (n){ + --n; + storage_t v; + alloc_traits::construct(a, (value_type*)&v); + value_type *vp = move_detail::launder_cast(&v); + value_destructor on_exit(a, *vp); (void)on_exit; + *p = ::boost::move(*vp); + ++p; + } + } +}; + +template +struct insert_default_initialized_n_proxy +{ + typedef ::boost::container::allocator_traits alloc_traits; + typedef typename allocator_traits::value_type value_type; + typedef typename dtl::aligned_storage::value>::type storage_t; + + template + inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const + { boost::container::uninitialized_default_init_alloc_n(a, n, p); } + + template + void copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const + { + if(!is_pod::value){ + while (n){ + --n; + typename dtl::aligned_storage::value>::type v; + alloc_traits::construct(a, (value_type*)&v, default_init); + value_type *vp = move_detail::launder_cast(&v); + value_destructor on_exit(a, *vp); (void)on_exit; + *p = ::boost::move(*vp); + ++p; + } + } + } +}; + +template +struct insert_copy_proxy +{ + typedef boost::container::allocator_traits alloc_traits; + typedef typename alloc_traits::value_type value_type; + + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_copy_proxy(const value_type &v) + : v_(v) + {} + + template + inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const + { + BOOST_ASSERT(n == 1); (void)n; + alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), v_); + } + + template + inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const + { + BOOST_ASSERT(n == 1); (void)n; + *p = v_; + } + + const value_type &v_; +}; + + +template +struct insert_move_proxy +{ + typedef boost::container::allocator_traits alloc_traits; + typedef typename alloc_traits::value_type value_type; + + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_move_proxy(value_type &v) + : v_(v) + {} + + template + inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const + { + BOOST_ASSERT(n == 1); (void)n; + alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::move(v_) ); + } + + template + inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const + { + BOOST_ASSERT(n == 1); (void)n; + *p = ::boost::move(v_); + } + + value_type &v_; +}; + +template +inline insert_move_proxy get_insert_value_proxy(BOOST_RV_REF(typename boost::container::iterator_traits::value_type) v) +{ + return insert_move_proxy(v); +} + +template +inline insert_copy_proxy get_insert_value_proxy(const typename boost::container::iterator_traits::value_type &v) +{ + return insert_copy_proxy(v); +} + +}}} //namespace boost { namespace container { namespace dtl { + +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + +#include +#include + +namespace boost { +namespace container { +namespace dtl { + +template +struct insert_nonmovable_emplace_proxy +{ + typedef boost::container::allocator_traits alloc_traits; + typedef typename alloc_traits::value_type value_type; + typedef typename build_number_seq::type index_tuple_t; + + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_nonmovable_emplace_proxy(BOOST_FWD_REF(Args)... args) + : args_(args...) + {} + + template + inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) + { this->priv_uninitialized_copy_some_and_update(a, index_tuple_t(), p, n); } + + private: + template + inline void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple&, Iterator p, std::size_t n) + { + BOOST_ASSERT(n == 1); (void)n; + alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::forward(get(this->args_))... ); + } + + protected: + tuple args_; +}; + +template +struct insert_emplace_proxy + : public insert_nonmovable_emplace_proxy +{ + typedef insert_nonmovable_emplace_proxy base_t; + typedef boost::container::allocator_traits alloc_traits; + typedef typename base_t::value_type value_type; + typedef typename base_t::index_tuple_t index_tuple_t; + + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_emplace_proxy(BOOST_FWD_REF(Args)... args) + : base_t(::boost::forward(args)...) + {} + + template + inline void copy_n_and_update(Allocator &a, Iterator p, std::size_t n) + { this->priv_copy_some_and_update(a, index_tuple_t(), p, n); } + + private: + + template + inline void priv_copy_some_and_update(Allocator &a, const index_tuple&, Iterator p, std::size_t n) + { + BOOST_ASSERT(n ==1); (void)n; + typename dtl::aligned_storage::value>::type v; + alloc_traits::construct(a, (value_type*)&v, ::boost::forward(get(this->args_))...); + value_type *vp = move_detail::launder_cast(&v); + BOOST_CONTAINER_TRY{ + *p = ::boost::move(*vp); + } + BOOST_CONTAINER_CATCH(...){ + alloc_traits::destroy(a, vp); + BOOST_CONTAINER_RETHROW + } + BOOST_CONTAINER_CATCH_END + alloc_traits::destroy(a, vp); + } +}; + +//Specializations to avoid an unneeded temporary when emplacing from a single argument o type value_type +template +struct insert_emplace_proxy::value_type> + : public insert_move_proxy +{ + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_emplace_proxy(typename boost::container::allocator_traits::value_type &&v) + : insert_move_proxy(v) + {} +}; + +//We use "add_const" here as adding "const" only confuses MSVC12(and maybe later) provoking +//compiler error C2752 ("more than one partial specialization matches"). +//Any problem is solvable with an extra layer of indirection? ;-) +template +struct insert_emplace_proxy::value_type>::type + > + : public insert_copy_proxy +{ + + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits::value_type &v) + : insert_copy_proxy(v) + {} +}; + +template +struct insert_emplace_proxy::value_type &> + : public insert_copy_proxy +{ + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits::value_type &v) + : insert_copy_proxy(v) + {} +}; + +template +struct insert_emplace_proxy::value_type>::type & + > + : public insert_copy_proxy +{ + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits::value_type &v) + : insert_copy_proxy(v) + {} +}; + +}}} //namespace boost { namespace container { namespace dtl { + +#else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + +#include + +namespace boost { +namespace container { +namespace dtl { + +#define BOOST_CONTAINER_ADVANCED_INSERT_INT_CODE(N) \ +template< class Allocator BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\ +struct insert_nonmovable_emplace_proxy##N\ +{\ + typedef boost::container::allocator_traits alloc_traits;\ + typedef typename alloc_traits::value_type value_type;\ + \ + BOOST_STATIC_CONSTEXPR bool single_value = true;\ + \ + inline explicit insert_nonmovable_emplace_proxy##N(BOOST_MOVE_UREF##N)\ + BOOST_MOVE_COLON##N BOOST_MOVE_FWD_INIT##N {}\ + \ + template\ + inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\ + {\ + BOOST_ASSERT(n == 1); (void)n;\ + alloc_traits::construct(a, boost::movelib::iterator_to_raw_pointer(p) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\ + }\ + \ + template\ + inline void copy_n_and_update(Allocator &, Iterator, std::size_t)\ + { BOOST_ASSERT(false); }\ + \ + protected:\ + BOOST_MOVE_MREF##N\ +};\ +\ +template< class Allocator BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\ +struct insert_emplace_proxy_arg##N\ + : insert_nonmovable_emplace_proxy##N< Allocator BOOST_MOVE_I##N BOOST_MOVE_TARG##N >\ +{\ + typedef insert_nonmovable_emplace_proxy##N\ + < Allocator BOOST_MOVE_I##N BOOST_MOVE_TARG##N > base_t;\ + typedef typename base_t::value_type value_type;\ + typedef boost::container::allocator_traits alloc_traits;\ + \ + BOOST_STATIC_CONSTEXPR bool single_value = true;\ + \ + inline explicit insert_emplace_proxy_arg##N(BOOST_MOVE_UREF##N)\ + : base_t(BOOST_MOVE_FWD##N){}\ + \ + template\ + inline void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\ + {\ + BOOST_ASSERT(n == 1); (void)n;\ + typename dtl::aligned_storage::value>::type v;\ + alloc_traits::construct(a, (value_type*)&v BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\ + value_type *vp = move_detail::launder_cast(&v);\ + BOOST_CONTAINER_TRY{\ + *p = ::boost::move(*vp);\ + }\ + BOOST_CONTAINER_CATCH(...){\ + alloc_traits::destroy(a, vp);\ + BOOST_CONTAINER_RETHROW\ + }\ + BOOST_CONTAINER_CATCH_END\ + alloc_traits::destroy(a, vp);\ + }\ +};\ +// +BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_ADVANCED_INSERT_INT_CODE) +#undef BOOST_CONTAINER_ADVANCED_INSERT_INT_CODE + +#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + +//Specializations to avoid an unneeded temporary when emplacing from a single argument o type value_type +template +struct insert_emplace_proxy_arg1::value_type> > + : public insert_move_proxy +{ + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits::value_type &v) + : insert_move_proxy(v) + {} +}; + +template +struct insert_emplace_proxy_arg1::value_type> + : public insert_copy_proxy +{ + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits::value_type &v) + : insert_copy_proxy(v) + {} +}; + +#else //e.g. MSVC10 & MSVC11 + +//Specializations to avoid an unneeded temporary when emplacing from a single argument o type value_type +template +struct insert_emplace_proxy_arg1::value_type> + : public insert_move_proxy +{ + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits::value_type &&v) + : insert_move_proxy(v) + {} +}; + +//We use "add_const" here as adding "const" only confuses MSVC10&11 provoking +//compiler error C2752 ("more than one partial specialization matches"). +//Any problem is solvable with an extra layer of indirection? ;-) +template +struct insert_emplace_proxy_arg1::value_type>::type + > + : public insert_copy_proxy +{ + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits::value_type &v) + : insert_copy_proxy(v) + {} +}; + +template +struct insert_emplace_proxy_arg1::value_type &> + : public insert_copy_proxy +{ + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits::value_type &v) + : insert_copy_proxy(v) + {} +}; + +template +struct insert_emplace_proxy_arg1::value_type>::type & + > + : public insert_copy_proxy +{ + BOOST_STATIC_CONSTEXPR bool single_value = true; + + inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits::value_type &v) + : insert_copy_proxy(v) + {} +}; + +#endif + +}}} //namespace boost { namespace container { namespace dtl { + +#endif // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + +#include + +#endif //#ifndef BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP diff --git a/boost/include/boost/container/detail/algorithm.hpp b/boost/include/boost/container/detail/algorithm.hpp new file mode 100644 index 00000000..ce5582bc --- /dev/null +++ b/boost/include/boost/container/detail/algorithm.hpp @@ -0,0 +1,185 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2014-2014. +// +// 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_CONTAINER_DETAIL_ALGORITHM_HPP +#define BOOST_CONTAINER_DETAIL_ALGORITHM_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include + +namespace boost { +namespace container { + +using boost::intrusive::algo_equal; +using boost::intrusive::algo_lexicographical_compare; + +template +class binder1st +{ + public: + typedef typename Func::second_argument_type argument_type; + typedef typename Func::result_type result_type; + + binder1st(const Func& func, const typename Func::first_argument_type& arg) + : op(func), value(arg) + {} + + result_type operator()(const argument_type& arg) const + { return op(value, arg); } + + result_type operator()(argument_type& arg) const + { return op(value, arg); } + + private: + Func op; + typename Func::first_argument_type value; +}; + +template +inline binder1st bind1st(const Func& func, const T& arg) +{ return boost::container::binder1st(func, arg); } + +template +class binder2nd +{ + public: + typedef typename Func::first_argument_type argument_type; + typedef typename Func::result_type result_type; + + binder2nd(const Func& func, const typename Func::second_argument_type& arg) + : op(func), value(arg) + {} + + result_type operator()(const argument_type& arg) const + { return op(arg, value); } + + result_type operator()(argument_type& arg) const + { return op(arg, value); } + + private: + Func op; + typename Func::second_argument_type value; +}; + +template +inline binder2nd bind2nd(const Func& func, const T& arg) +{ + return (boost::container::binder2nd(func, arg)); +} + +template +class unary_negate +{ + public: + typedef typename Func::argument_type argument_type; + typedef typename Func::result_type result_type; + + explicit unary_negate(const Func& func) + : m_func(func) + {} + + bool operator()(const typename Func::argument_type& arg) const + { return !m_func(arg); } + + private: + Func m_func; +}; + +template inline +unary_negate not1(const Func& func) +{ + return boost::container::unary_negate(func); +} + +template +InputIt find_if(InputIt first, InputIt last, UnaryPredicate p) +{ + for (; first != last; ++first) { + if (p(*first)) { + return first; + } + } + return last; +} + +template + ForwardIt1 find_end (ForwardIt1 first1, ForwardIt1 last1 + ,ForwardIt2 first2, ForwardIt2 last2 + ,BinaryPredicate p) +{ + if (first2==last2) + return last1; // specified in C++11 + + ForwardIt1 ret = last1; + + while (first1!=last1) + { + ForwardIt1 it1 = first1; + ForwardIt2 it2 = first2; + while ( p(*it1, *it2) ) { + ++it1; ++it2; + if (it2==last2) { + ret=first1; + break; + } + if (it1==last1) + return ret; + } + ++first1; + } + return ret; +} + +template +InputIt find_first_of(InputIt first1, InputIt last1, ForwardIt first2, ForwardIt last2, BinaryPredicate p) +{ + for (; first1 != last1; ++first1) { + for (ForwardIt it = first2; it != last2; ++it) { + if (p(*first1, *it)) { + return first1; + } + } + } + return last1; +} + +template +ForwardIt1 search(ForwardIt1 first1, ForwardIt1 last1, + ForwardIt2 first2, ForwardIt2 last2, BinaryPredicate p) +{ + for (; ; ++first1) { + ForwardIt1 it = first1; + for (ForwardIt2 it2 = first2; ; ++it, ++it2) { + if (it2 == last2) { + return first1; + } + if (it == last1) { + return last1; + } + if (!p(*it, *it2)) { + break; + } + } + } +} + +} //namespace container { +} //namespace boost { + +#endif //#ifndef BOOST_CONTAINER_DETAIL_ALGORITHM_HPP diff --git a/boost/include/boost/container/detail/alloc_helpers.hpp b/boost/include/boost/container/detail/alloc_helpers.hpp new file mode 100644 index 00000000..57c59e46 --- /dev/null +++ b/boost/include/boost/container/detail/alloc_helpers.hpp @@ -0,0 +1,60 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2014-2015. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// +#ifndef BOOST_CONTAINER_DETAIL_ALLOC_TRAITS_HPP +#define BOOST_CONTAINER_DETAIL_ALLOC_TRAITS_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +// move +#include +#include + +namespace boost { +namespace container { +namespace dtl { + +template +inline void swap_alloc(AllocatorType &, AllocatorType &, dtl::false_type) + BOOST_NOEXCEPT_OR_NOTHROW +{} + +template +inline void swap_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type) +{ boost::adl_move_swap(l, r); } + +template +inline void assign_alloc(AllocatorType &, const AllocatorType &, dtl::false_type) + BOOST_NOEXCEPT_OR_NOTHROW +{} + +template +inline void assign_alloc(AllocatorType &l, const AllocatorType &r, dtl::true_type) +{ l = r; } + +template +inline void move_alloc(AllocatorType &, AllocatorType &, dtl::false_type) + BOOST_NOEXCEPT_OR_NOTHROW +{} + +template +inline void move_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type) +{ l = ::boost::move(r); } + +} //namespace dtl { +} //namespace container { +} //namespace boost { + +#endif //#ifndef BOOST_CONTAINER_DETAIL_ALLOC_TRAITS_HPP diff --git a/boost/include/boost/container/detail/alloc_lib.h b/boost/include/boost/container/detail/alloc_lib.h new file mode 100644 index 00000000..f5f505ca --- /dev/null +++ b/boost/include/boost/container/detail/alloc_lib.h @@ -0,0 +1,314 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2005-2013. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// +#ifndef BOOST_CONTAINER_ALLOC_LIB_EXT_H +#define BOOST_CONTAINER_ALLOC_LIB_EXT_H + +#include + +#ifdef _MSC_VER +#pragma warning (push) +#pragma warning (disable : 4127) +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/*!An forward iterator to traverse the elements of a memory chain container.*/ +typedef struct multialloc_node_impl +{ + struct multialloc_node_impl *next_node_ptr; +} boost_cont_memchain_node; + + +/*!An forward iterator to traverse the elements of a memory chain container.*/ +typedef struct multialloc_it_impl +{ + boost_cont_memchain_node *node_ptr; +} boost_cont_memchain_it; + +/*!Memory chain: A container holding memory portions allocated by boost_cont_multialloc_nodes + and boost_cont_multialloc_arrays functions.*/ +typedef struct boost_cont_memchain_impl +{ + size_t num_mem; + boost_cont_memchain_node root_node; + boost_cont_memchain_node *last_node_ptr; +} boost_cont_memchain; + +/*!Advances the iterator one position so that it points to the next element in the memory chain*/ +#define BOOST_CONTAINER_MEMIT_NEXT(IT) (IT.node_ptr = IT.node_ptr->next_node_ptr) + +/*!Returns the address of the memory chain currently pointed by the iterator*/ +#define BOOST_CONTAINER_MEMIT_ADDR(IT) ((void*)IT.node_ptr) + +/*!Initializer for an iterator pointing to the position before the first element*/ +#define BOOST_CONTAINER_MEMCHAIN_BEFORE_BEGIN_IT(PMEMCHAIN) { &((PMEMCHAIN)->root_node) } + +/*!Initializer for an iterator pointing to the first element*/ +#define BOOST_CONTAINER_MEMCHAIN_BEGIN_IT(PMEMCHAIN) {(PMEMCHAIN)->root_node.next_node_ptr } + +/*!Initializer for an iterator pointing to the last element*/ +#define BOOST_CONTAINER_MEMCHAIN_LAST_IT(PMEMCHAIN) {(PMEMCHAIN)->last_node_ptr } + +/*!Initializer for an iterator pointing to one past the last element (end iterator)*/ +#define BOOST_CONTAINER_MEMCHAIN_END_IT(PMEMCHAIN) {(boost_cont_memchain_node *)0 } + +/*!True if IT is the end iterator, false otherwise*/ +#define BOOST_CONTAINER_MEMCHAIN_IS_END_IT(PMEMCHAIN, IT) (!(IT).node_ptr) + +/*!The address of the first memory portion hold by the memory chain*/ +#define BOOST_CONTAINER_MEMCHAIN_FIRSTMEM(PMEMCHAIN)((void*)((PMEMCHAIN)->root_node.next_node_ptr)) + +/*!The address of the last memory portion hold by the memory chain*/ +#define BOOST_CONTAINER_MEMCHAIN_LASTMEM(PMEMCHAIN) ((void*)((PMEMCHAIN)->last_node_ptr)) + +/*!The number of memory portions hold by the memory chain*/ +#define BOOST_CONTAINER_MEMCHAIN_SIZE(PMEMCHAIN) ((PMEMCHAIN)->num_mem) + +/*!Initializes the memory chain from the first memory portion, the last memory + portion and number of portions obtained from another memory chain*/ +#define BOOST_CONTAINER_MEMCHAIN_INIT_FROM(PMEMCHAIN, FIRST, LAST, NUM)\ + (PMEMCHAIN)->last_node_ptr = (boost_cont_memchain_node *)(LAST), \ + (PMEMCHAIN)->root_node.next_node_ptr = (boost_cont_memchain_node *)(FIRST), \ + (PMEMCHAIN)->num_mem = (NUM);\ +/**/ + +/*!Default initializes a memory chain. Postconditions: begin iterator is end iterator, + the number of portions is zero.*/ +#define BOOST_CONTAINER_MEMCHAIN_INIT(PMEMCHAIN)\ + ((PMEMCHAIN)->root_node.next_node_ptr = 0, (PMEMCHAIN)->last_node_ptr = &((PMEMCHAIN)->root_node), (PMEMCHAIN)->num_mem = 0)\ +/**/ + +/*!True if the memory chain is empty (holds no memory portions*/ +#define BOOST_CONTAINER_MEMCHAIN_EMPTY(PMEMCHAIN)\ + ((PMEMCHAIN)->num_mem == 0)\ +/**/ + +/*!Inserts a new memory portions in the front of the chain*/ +#define BOOST_CONTAINER_MEMCHAIN_PUSH_BACK(PMEMCHAIN, MEM)\ + do{\ + boost_cont_memchain *____chain____ = (PMEMCHAIN);\ + boost_cont_memchain_node *____tmp_mem____ = (boost_cont_memchain_node *)(MEM);\ + ____chain____->last_node_ptr->next_node_ptr = ____tmp_mem____;\ + ____tmp_mem____->next_node_ptr = 0;\ + ____chain____->last_node_ptr = ____tmp_mem____;\ + ++____chain____->num_mem;\ + }while(0)\ +/**/ + +/*!Inserts a new memory portions in the back of the chain*/ +#define BOOST_CONTAINER_MEMCHAIN_PUSH_FRONT(PMEMCHAIN, MEM)\ + do{\ + boost_cont_memchain *____chain____ = (PMEMCHAIN);\ + boost_cont_memchain_node *____tmp_mem____ = (boost_cont_memchain_node *)(MEM);\ + boost_cont_memchain *____root____ = &((PMEMCHAIN)->root_node);\ + if(!____chain____->root_node.next_node_ptr){\ + ____chain____->last_node_ptr = ____tmp_mem____;\ + }\ + boost_cont_memchain_node *____old_first____ = ____root____->next_node_ptr;\ + ____tmp_mem____->next_node_ptr = ____old_first____;\ + ____root____->next_node_ptr = ____tmp_mem____;\ + ++____chain____->num_mem;\ + }while(0)\ +/**/ + +/*!Erases the memory portion after the portion pointed by BEFORE_IT from the memory chain*/ +/*!Precondition: BEFORE_IT must be a valid iterator of the memory chain and it can't be the end iterator*/ +#define BOOST_CONTAINER_MEMCHAIN_ERASE_AFTER(PMEMCHAIN, BEFORE_IT)\ + do{\ + boost_cont_memchain *____chain____ = (PMEMCHAIN);\ + boost_cont_memchain_node *____prev_node____ = (BEFORE_IT).node_ptr;\ + boost_cont_memchain_node *____erase_node____ = ____prev_node____->next_node_ptr;\ + if(____chain____->last_node_ptr == ____erase_node____){\ + ____chain____->last_node_ptr = &____chain____->root_node;\ + }\ + ____prev_node____->next_node_ptr = ____erase_node____->next_node_ptr;\ + --____chain____->num_mem;\ + }while(0)\ +/**/ + +/*!Erases the first portion from the memory chain. + Precondition: the memory chain must not be empty*/ +#define BOOST_CONTAINER_MEMCHAIN_POP_FRONT(PMEMCHAIN)\ + do{\ + boost_cont_memchain *____chain____ = (PMEMCHAIN);\ + boost_cont_memchain_node *____prev_node____ = &____chain____->root_node;\ + boost_cont_memchain_node *____erase_node____ = ____prev_node____->next_node_ptr;\ + if(____chain____->last_node_ptr == ____erase_node____){\ + ____chain____->last_node_ptr = &____chain____->root_node;\ + }\ + ____prev_node____->next_node_ptr = ____erase_node____->next_node_ptr;\ + --____chain____->num_mem;\ + }while(0)\ +/**/ + +/*!Joins two memory chains inserting the portions of the second chain at the back of the first chain*/ +/* +#define BOOST_CONTAINER_MEMCHAIN_SPLICE_BACK(PMEMCHAIN, PMEMCHAIN2)\ + do{\ + boost_cont_memchain *____chain____ = (PMEMCHAIN);\ + boost_cont_memchain *____chain2____ = (PMEMCHAIN2);\ + if(!____chain2____->root_node.next_node_ptr){\ + break;\ + }\ + else if(!____chain____->first_mem){\ + ____chain____->first_mem = ____chain2____->first_mem;\ + ____chain____->last_node_ptr = ____chain2____->last_node_ptr;\ + ____chain____->num_mem = ____chain2____->num_mem;\ + BOOST_CONTAINER_MEMCHAIN_INIT(*____chain2____);\ + }\ + else{\ + ____chain____->last_node_ptr->next_node_ptr = ____chain2____->first_mem;\ + ____chain____->last_node_ptr = ____chain2____->last_node_ptr;\ + ____chain____->num_mem += ____chain2____->num_mem;\ + }\ + }while(0)\*/ +/**/ + +/*!Joins two memory chains inserting the portions of the second chain at the back of the first chain*/ +#define BOOST_CONTAINER_MEMCHAIN_INCORPORATE_AFTER(PMEMCHAIN, BEFORE_IT, FIRST, BEFORELAST, NUM)\ + do{\ + boost_cont_memchain *____chain____ = (PMEMCHAIN);\ + boost_cont_memchain_node *____pnode____ = (BEFORE_IT).node_ptr;\ + boost_cont_memchain_node *____next____ = ____pnode____->next_node_ptr;\ + boost_cont_memchain_node *____first____ = (boost_cont_memchain_node *)(FIRST);\ + boost_cont_memchain_node *____blast____ = (boost_cont_memchain_node *)(BEFORELAST);\ + size_t ____num____ = (NUM);\ + if(!____num____){\ + break;\ + }\ + if(____pnode____ == ____chain____->last_node_ptr){\ + ____chain____->last_node_ptr = ____blast____;\ + }\ + ____pnode____->next_node_ptr = ____first____;\ + ____blast____->next_node_ptr = ____next____;\ + ____chain____->num_mem += ____num____;\ + }while(0)\ +/**/ + +/*!Indicates the all elements allocated by boost_cont_multialloc_nodes or boost_cont_multialloc_arrays + must be contiguous.*/ +#define BOOST_CONTAINER_DL_MULTIALLOC_ALL_CONTIGUOUS ((size_t)(-1)) + +/*!Indicates the number of contiguous elements allocated by boost_cont_multialloc_nodes or boost_cont_multialloc_arrays + should be selected by those functions.*/ +#define BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS ((size_t)(0)) + +typedef struct boost_cont_malloc_stats_impl +{ + size_t max_system_bytes; + size_t system_bytes; + size_t in_use_bytes; +} boost_cont_malloc_stats_t; + +typedef unsigned int allocation_type; + +enum +{ + // constants for allocation commands + BOOST_CONTAINER_ALLOCATE_NEW = 0X01, + BOOST_CONTAINER_EXPAND_FWD = 0X02, + BOOST_CONTAINER_EXPAND_BWD = 0X04, + BOOST_CONTAINER_SHRINK_IN_PLACE = 0X08, + BOOST_CONTAINER_NOTHROW_ALLOCATION = 0X10, +// BOOST_CONTAINER_ZERO_MEMORY = 0X20, + BOOST_CONTAINER_TRY_SHRINK_IN_PLACE = 0X40, + BOOST_CONTAINER_EXPAND_BOTH = BOOST_CONTAINER_EXPAND_FWD | BOOST_CONTAINER_EXPAND_BWD, + BOOST_CONTAINER_EXPAND_OR_NEW = BOOST_CONTAINER_ALLOCATE_NEW | BOOST_CONTAINER_EXPAND_BOTH +}; + +//#define BOOST_CONTAINER_DLMALLOC_FOOTERS +#ifndef BOOST_CONTAINER_DLMALLOC_FOOTERS +enum { BOOST_CONTAINER_ALLOCATION_PAYLOAD = sizeof(size_t) }; +#else +enum { BOOST_CONTAINER_ALLOCATION_PAYLOAD = sizeof(size_t)*2 }; +#endif + +typedef struct boost_cont_command_ret_impl +{ + void *first; + int second; +}boost_cont_command_ret_t; + +size_t boost_cont_size(const void *p); + +void* boost_cont_malloc(size_t bytes); + +void boost_cont_free(void* mem); + +void* boost_cont_memalign(size_t bytes, size_t alignment); + +int boost_cont_multialloc_nodes + (size_t n_elements, size_t elem_size, size_t contiguous_elements, boost_cont_memchain *pchain); + +int boost_cont_multialloc_arrays + (size_t n_elements, const size_t *sizes, size_t sizeof_element, size_t contiguous_elements, boost_cont_memchain *pchain); + +void boost_cont_multidealloc(boost_cont_memchain *pchain); + +size_t boost_cont_footprint(); + +size_t boost_cont_allocated_memory(); + +size_t boost_cont_chunksize(const void *p); + +int boost_cont_all_deallocated(); + +boost_cont_malloc_stats_t boost_cont_malloc_stats(); + +size_t boost_cont_in_use_memory(); + +int boost_cont_trim(size_t pad); + +int boost_cont_mallopt(int parameter_number, int parameter_value); + +int boost_cont_grow + (void* oldmem, size_t minbytes, size_t maxbytes, size_t *received); + +int boost_cont_shrink + (void* oldmem, size_t minbytes, size_t maxbytes, size_t *received, int do_commit); + +void* boost_cont_alloc + (size_t minbytes, size_t preferred_bytes, size_t *received_bytes); + +int boost_cont_malloc_check(); + +boost_cont_command_ret_t boost_cont_allocation_command + ( allocation_type command + , size_t sizeof_object + , size_t limit_objects + , size_t preferred_objects + , size_t *received_objects + , void *reuse_ptr + ); + +void *boost_cont_sync_create(); + +void boost_cont_sync_destroy(void *sync); + +int boost_cont_sync_lock(void *sync); + +void boost_cont_sync_unlock(void *sync); + +int boost_cont_global_sync_lock(); + +void boost_cont_global_sync_unlock(); + +#ifdef __cplusplus +} //extern "C" { +#endif + +#ifdef _MSC_VER +#pragma warning (pop) +#endif + + +#endif //#define BOOST_CONTAINERDLMALLOC__EXT_H diff --git a/boost/include/boost/container/detail/allocation_type.hpp b/boost/include/boost/container/detail/allocation_type.hpp new file mode 100644 index 00000000..5f0d4b62 --- /dev/null +++ b/boost/include/boost/container/detail/allocation_type.hpp @@ -0,0 +1,58 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2005-2013. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_CONTAINER_ALLOCATION_TYPE_HPP +#define BOOST_CONTAINER_ALLOCATION_TYPE_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include + +namespace boost { +namespace container { + +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED +enum allocation_type_v +{ + // constants for allocation commands + allocate_new_v = 0x01, + expand_fwd_v = 0x02, + expand_bwd_v = 0x04, +// expand_both = expand_fwd | expand_bwd, +// expand_or_new = allocate_new | expand_both, + shrink_in_place_v = 0x08, + nothrow_allocation_v = 0x10, + zero_memory_v = 0x20, + try_shrink_in_place_v = 0x40 +}; + +typedef unsigned int allocation_type; +#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED +BOOST_CONTAINER_CONSTANT_VAR allocation_type allocate_new = (allocation_type)allocate_new_v; +BOOST_CONTAINER_CONSTANT_VAR allocation_type expand_fwd = (allocation_type)expand_fwd_v; +BOOST_CONTAINER_CONSTANT_VAR allocation_type expand_bwd = (allocation_type)expand_bwd_v; +BOOST_CONTAINER_CONSTANT_VAR allocation_type shrink_in_place = (allocation_type)shrink_in_place_v; +BOOST_CONTAINER_CONSTANT_VAR allocation_type try_shrink_in_place= (allocation_type)try_shrink_in_place_v; +BOOST_CONTAINER_CONSTANT_VAR allocation_type nothrow_allocation = (allocation_type)nothrow_allocation_v; +BOOST_CONTAINER_CONSTANT_VAR allocation_type zero_memory = (allocation_type)zero_memory_v; + +} //namespace container { +} //namespace boost { + +#include + +#endif //BOOST_CONTAINER_ALLOCATION_TYPE_HPP diff --git a/boost/include/boost/container/detail/allocator_version_traits.hpp b/boost/include/boost/container/detail/allocator_version_traits.hpp new file mode 100644 index 00000000..4e83d213 --- /dev/null +++ b/boost/include/boost/container/detail/allocator_version_traits.hpp @@ -0,0 +1,162 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2012-2013. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_CONTAINER_DETAIL_ALLOCATOR_VERSION_TRAITS_HPP +#define BOOST_CONTAINER_DETAIL_ALLOCATOR_VERSION_TRAITS_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include + +#include //allocator_traits +#include +#include //multiallocation_chain +#include //version_type +#include //allocation_type +#include //integral_constant +#include //pointer_traits + +namespace boost { +namespace container { +namespace dtl { + +template::value> +struct allocator_version_traits +{ + typedef ::boost::container::dtl::integral_constant + alloc_version; + + typedef typename Allocator::multiallocation_chain multiallocation_chain; + + typedef typename boost::container::allocator_traits::pointer pointer; + typedef typename boost::container::allocator_traits::size_type size_type; + + //Node allocation interface + inline static pointer allocate_one(Allocator &a) + { return a.allocate_one(); } + + inline static void deallocate_one(Allocator &a, const pointer &p) + { a.deallocate_one(p); } + + inline static void allocate_individual(Allocator &a, size_type n, multiallocation_chain &m) + { return a.allocate_individual(n, m); } + + inline static void deallocate_individual(Allocator &a, multiallocation_chain &holder) + { a.deallocate_individual(holder); } + + inline static pointer allocation_command(Allocator &a, allocation_type command, + size_type limit_size, size_type &prefer_in_recvd_out_size, pointer &reuse) + { return a.allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse); } +}; + +template +struct allocator_version_traits +{ + typedef ::boost::container::dtl::integral_constant + alloc_version; + + typedef typename boost::container::allocator_traits::pointer pointer; + typedef typename boost::container::allocator_traits::size_type size_type; + typedef typename boost::container::allocator_traits::value_type value_type; + + typedef typename boost::intrusive::pointer_traits:: + template rebind_pointer::type void_ptr; + typedef dtl::basic_multiallocation_chain + multialloc_cached_counted; + typedef boost::container::dtl:: + transform_multiallocation_chain + < multialloc_cached_counted, value_type> multiallocation_chain; + + //Node allocation interface + inline static pointer allocate_one(Allocator &a) + { return a.allocate(1); } + + inline static void deallocate_one(Allocator &a, const pointer &p) + { a.deallocate(p, 1); } + + static void deallocate_individual(Allocator &a, multiallocation_chain &holder) + { + size_type n = holder.size(); + typename multiallocation_chain::iterator it = holder.begin(); + while(n){ + --n; + pointer p = boost::intrusive::pointer_traits::pointer_to(*it); + ++it; + a.deallocate(p, 1); + } + } + + struct allocate_individual_rollback + { + inline allocate_individual_rollback(Allocator &a, multiallocation_chain &chain) + : mr_a(a), mp_chain(&chain) + {} + + inline ~allocate_individual_rollback() + { + if(mp_chain) + allocator_version_traits::deallocate_individual(mr_a, *mp_chain); + } + + inline void release() + { + mp_chain = 0; + } + + Allocator &mr_a; + multiallocation_chain * mp_chain; + }; + + static void allocate_individual(Allocator &a, size_type n, multiallocation_chain &m) + { + allocate_individual_rollback rollback(a, m); + while(n--){ + m.push_front(a.allocate(1)); + } + rollback.release(); + } + + static pointer allocation_command(Allocator &a, allocation_type command, + size_type, size_type &prefer_in_recvd_out_size, pointer &reuse) + { + pointer ret = pointer(); + if(BOOST_UNLIKELY(!(command & allocate_new) && !(command & nothrow_allocation))){ + throw_logic_error("version 1 allocator without allocate_new flag"); + } + else{ + BOOST_CONTAINER_TRY{ + ret = a.allocate(prefer_in_recvd_out_size); + } + BOOST_CONTAINER_CATCH(...){ + if(!(command & nothrow_allocation)){ + BOOST_CONTAINER_RETHROW + } + } + BOOST_CONTAINER_CATCH_END + reuse = pointer(); + } + return ret; + } +}; + +} //namespace dtl { +} //namespace container { +} //namespace boost { + +#include + +#endif // ! defined(BOOST_CONTAINER_DETAIL_ALLOCATOR_VERSION_TRAITS_HPP) diff --git a/boost/include/boost/container/detail/auto_link.hpp b/boost/include/boost/container/detail/auto_link.hpp new file mode 100644 index 00000000..264b1ba1 --- /dev/null +++ b/boost/include/boost/container/detail/auto_link.hpp @@ -0,0 +1,51 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2007-2013. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// +#ifndef BOOST_CONTAINER_DETAIL_AUTO_LINK_HPP_INCLUDED +#define BOOST_CONTAINER_DETAIL_AUTO_LINK_HPP_INCLUDED + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +//Define BOOST_CONTAINER_DYNAMIC_LINKING which is independent from BOOST_*_NO_LIB +//and is needed is some tests that need to disable some checks (like operator new replacements) +//that don't work across DLL boundaries +#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_CONTAINER_DYN_LINK) +# define BOOST_CONTAINER_DYNAMIC_LINKING +#endif + +// +// Automatically link to the correct build variant where possible. +// +#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_CONTAINER_NO_LIB) && !defined(BOOST_CONTAINER_SOURCE) +// +// Set the name of our library, this will get undef'ed by auto_link.hpp +// once it's done with it: +// +#define BOOST_LIB_NAME boost_container + +// +// If we're importing code from a dll, then tell auto_link.hpp about it: +// +#if defined(BOOST_CONTAINER_DYNAMIC_LINKING) +# define BOOST_DYN_LINK +#endif + +// +// And include the header that does the work: +// +#include +#endif // auto-linking disabled + +#endif //#ifndef BOOST_CONTAINER_DETAIL_AUTO_LINK_HPP_INCLUDED diff --git a/boost/include/boost/container/detail/block_list.hpp b/boost/include/boost/container/detail/block_list.hpp new file mode 100644 index 00000000..48523267 --- /dev/null +++ b/boost/include/boost/container/detail/block_list.hpp @@ -0,0 +1,140 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2015-2015. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_CONTAINER_DETAIL_BLOCK_LIST_HEADER +#define BOOST_CONTAINER_DETAIL_BLOCK_LIST_HEADER + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace boost { +namespace container { +namespace pmr { + +struct list_node +{ + list_node *next; + list_node *previous; +}; + +struct list_node_traits +{ + typedef list_node node; + typedef list_node* node_ptr; + typedef const list_node* const_node_ptr; + + static node_ptr get_next(const_node_ptr n) + { return n->next; } + + static node_ptr get_previous(const_node_ptr n) + { return n->previous; } + + static void set_next(const node_ptr & n, const node_ptr & next) + { n->next = next; } + + static void set_previous(const node_ptr & n, const node_ptr & previous) + { n->previous = previous; } +}; + +struct block_list_header + : public list_node +{ + std::size_t size; +}; + +typedef bi::circular_list_algorithms list_algo; + + +template +class block_list_base +{ + list_node m_list; + + BOOST_STATIC_CONSTEXPR std::size_t MaxAlignMinus1 = memory_resource::max_align-1u; + + public: + + BOOST_STATIC_CONSTEXPR std::size_t header_size = std::size_t(sizeof(DerivedFromBlockListHeader) + MaxAlignMinus1) & std::size_t(~MaxAlignMinus1); + + explicit block_list_base() + { list_algo::init_header(&m_list); } + + #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + block_list_base(const block_list_base&) = delete; + block_list_base operator=(const block_list_base&) = delete; + #else + private: + block_list_base (const block_list_base&); + block_list_base operator=(const block_list_base&); + public: + #endif + + ~block_list_base() + {} + + void *allocate(std::size_t size, memory_resource &mr) + { + if((size_t(-1) - header_size) < size) + throw_bad_alloc(); + void *p = mr.allocate(size+header_size); + block_list_header &mb = *::new((void*)p, boost_container_new_t()) DerivedFromBlockListHeader; + mb.size = size+header_size; + list_algo::link_after(&m_list, &mb); + return (char *)p + header_size; + } + + void deallocate(void *p, memory_resource &mr) BOOST_NOEXCEPT + { + DerivedFromBlockListHeader *pheader = static_cast + (static_cast((char*)p - header_size)); + list_algo::unlink(pheader); + const std::size_t size = pheader->size; + static_cast(pheader)->~DerivedFromBlockListHeader(); + mr.deallocate(pheader, size, memory_resource::max_align); + } + + void release(memory_resource &mr) BOOST_NOEXCEPT + { + list_node *n = list_algo::node_traits::get_next(&m_list); + while(n != &m_list){ + DerivedFromBlockListHeader &d = static_cast(*n); + n = list_algo::node_traits::get_next(n); + std::size_t size = d.size; + d.~DerivedFromBlockListHeader(); + mr.deallocate(reinterpret_cast(&d), size, memory_resource::max_align); + } + list_algo::init_header(&m_list); + } +}; + +} //namespace pmr { +} //namespace container { +} //namespace boost { + +#include + +#endif //BOOST_CONTAINER_DETAIL_BLOCK_LIST_HEADER diff --git a/boost/include/boost/container/detail/block_slist.hpp b/boost/include/boost/container/detail/block_slist.hpp new file mode 100644 index 00000000..b265ba44 --- /dev/null +++ b/boost/include/boost/container/detail/block_slist.hpp @@ -0,0 +1,158 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2015-2015. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_CONTAINER_DETAIL_BLOCK_SLIST_HEADER +#define BOOST_CONTAINER_DETAIL_BLOCK_SLIST_HEADER + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +namespace boost { +namespace container { +namespace pmr { + +struct slist_node +{ + slist_node *next; +}; + +struct slist_node_traits +{ + typedef slist_node node; + typedef slist_node* node_ptr; + typedef const slist_node* const_node_ptr; + + static node_ptr get_next(const_node_ptr n) + { return n->next; } + + static void set_next(const node_ptr & n, const node_ptr & next) + { n->next = next; } +}; + +struct block_slist_header + : public slist_node +{ + std::size_t size; +}; + +typedef bi::linear_slist_algorithms slist_algo; + +template +class block_slist_base +{ + slist_node m_slist; + + BOOST_STATIC_CONSTEXPR std::size_t MaxAlignMinus1 = memory_resource::max_align-1u; + + public: + + BOOST_STATIC_CONSTEXPR std::size_t header_size = std::size_t(sizeof(DerivedFromBlockSlistHeader) + MaxAlignMinus1) & std::size_t(~MaxAlignMinus1); + + explicit block_slist_base() + { slist_algo::init_header(&m_slist); } + + #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + block_slist_base(const block_slist_base&) = delete; + block_slist_base operator=(const block_slist_base&) = delete; + #else + private: + block_slist_base (const block_slist_base&); + block_slist_base operator=(const block_slist_base&); + public: + #endif + + ~block_slist_base() + {} + + void *allocate(std::size_t size, memory_resource &mr) + { + if((size_t(-1) - header_size) < size) + throw_bad_alloc(); + void *p = mr.allocate(size+header_size); + block_slist_header &mb = *::new((void*)p, boost_container_new_t()) DerivedFromBlockSlistHeader; + mb.size = size+header_size; + slist_algo::link_after(&m_slist, &mb); + return (char *)p + header_size; + } + + void release(memory_resource &mr) BOOST_NOEXCEPT + { + slist_node *n = slist_algo::node_traits::get_next(&m_slist); + while(n){ + DerivedFromBlockSlistHeader &d = static_cast(*n); + n = slist_algo::node_traits::get_next(n); + std::size_t size = d.block_slist_header::size; + d.~DerivedFromBlockSlistHeader(); + mr.deallocate(reinterpret_cast(&d), size, memory_resource::max_align); + } + slist_algo::init_header(&m_slist); + } +}; + +class block_slist + : public block_slist_base<> +{ + memory_resource &m_upstream_rsrc; + + public: + + explicit block_slist(memory_resource &upstream_rsrc) + : block_slist_base<>(), m_upstream_rsrc(upstream_rsrc) + {} + + #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + block_slist(const block_slist&) = delete; + block_slist operator=(const block_slist&) = delete; + #else + private: + block_slist (const block_slist&); + block_slist operator=(const block_slist&); + public: + #endif + + ~block_slist() + { this->release(); } + + void *allocate(std::size_t size) + { return this->block_slist_base<>::allocate(size, m_upstream_rsrc); } + + void release() BOOST_NOEXCEPT + { return this->block_slist_base<>::release(m_upstream_rsrc); } + + memory_resource& upstream_resource() const BOOST_NOEXCEPT + { return m_upstream_rsrc; } +}; + +} //namespace pmr { +} //namespace container { +} //namespace boost { + +#include + +#endif //BOOST_CONTAINER_DETAIL_BLOCK_SLIST_HEADER diff --git a/boost/include/boost/container/detail/compare_functors.hpp b/boost/include/boost/container/detail/compare_functors.hpp new file mode 100644 index 00000000..9a352740 --- /dev/null +++ b/boost/include/boost/container/detail/compare_functors.hpp @@ -0,0 +1,134 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2014-2014. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_CONTAINER_DETAIL_COMPARE_FUNCTORS_HPP +#define BOOST_CONTAINER_DETAIL_COMPARE_FUNCTORS_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include + +namespace boost { +namespace container { + +template +class equal_to_value +{ + typedef ValueType value_type; + const value_type &t_; + + public: + inline explicit equal_to_value(const value_type &t) + : t_(t) + {} + + inline bool operator()(const value_type &t)const + { return t_ == t; } +}; + +template +struct value_to_node_compare + : Pred +{ + typedef Pred predicate_type; + typedef Node node_type; + + inline value_to_node_compare() + : Pred() + {} + + inline explicit value_to_node_compare(Pred pred) + : Pred(pred) + {} + + inline Ret operator()(const Node &a, const Node &b) const + { return static_cast(*this)(a.get_data(), b.get_data()); } + + inline Ret operator()(const Node &a) const + { return static_cast(*this)(a.get_data()); } + + inline Ret operator()(const Node &a, const Node &b) + { return static_cast(*this)(a.get_data(), b.get_data()); } + + inline Ret operator()(const Node &a) + { return static_cast(*this)(a.get_data()); } + + inline predicate_type & predicate() { return static_cast(*this); } + inline const predicate_type & predicate() const { return static_cast(*this); } +}; + +template +struct key_node_pred + : public boost::intrusive::detail::ebo_functor_holder +{ + inline explicit key_node_pred(const KeyPred &comp) + : base_t(comp) + {} + + inline explicit key_node_pred() + {} + + typedef boost::intrusive::detail::ebo_functor_holder base_t; + typedef KeyPred key_predicate; + typedef KeyOfValue key_of_value; + typedef typename KeyOfValue::type key_type; + + + inline static const key_type &key_from(const Node &n) + { + return key_of_value()(n.get_data()); + } + + template + inline static const T & + key_from(const T &t) + { return t; } + + inline const key_predicate &key_pred() const + { return static_cast(*this); } + + inline key_predicate &key_pred() + { return static_cast(*this); } + + inline Ret operator()(const key_type &key) const + { return this->key_pred()(key); } + + template + inline Ret operator()(const U &nonkey) const + { return this->key_pred()(this->key_from(nonkey)); } + + inline bool operator()(const key_type &key1, const key_type &key2) const + { return this->key_pred()(key1, key2); } + + template + inline bool operator()(const key_type &key1, const U &nonkey2) const + { return this->key_pred()(key1, this->key_from(nonkey2)); } + + template + inline bool operator()(const U &nonkey1, const key_type &key2) const + { return this->key_pred()(this->key_from(nonkey1), key2); } + + template + inline bool operator()(const U &nonkey1, const V &nonkey2) const + { return this->key_pred()(this->key_from(nonkey1), this->key_from(nonkey2)); } +}; + + +} //namespace container { +} //namespace boost { + +#endif //BOOST_CONTAINER_DETAIL_COMPARE_FUNCTORS_HPP diff --git a/boost/include/boost/container/detail/config_begin.hpp b/boost/include/boost/container/detail/config_begin.hpp new file mode 100644 index 00000000..e1075d1d --- /dev/null +++ b/boost/include/boost/container/detail/config_begin.hpp @@ -0,0 +1,61 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2005-2013. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// +#ifndef BOOST_CONTAINER_CONTAINER_DETAIL_CONFIG_INCLUDED +#define BOOST_CONTAINER_CONTAINER_DETAIL_CONFIG_INCLUDED +#ifndef BOOST_CONFIG_HPP +#include +#endif + +#endif //BOOST_CONTAINER_CONTAINER_DETAIL_CONFIG_INCLUDED + +#ifdef BOOST_MSVC + #pragma warning (push) + #pragma warning (disable : 4619) // there is no warning number 'XXXX' + #pragma warning (disable : 4127) // conditional expression is constant + #pragma warning (disable : 4146) // unary minus operator applied to unsigned type, result still unsigned + #pragma warning (disable : 4197) // top-level volatile in cast is ignored + #pragma warning (disable : 4251) // "identifier" : class "type" needs to have dll-interface to be used by clients of class "type2" + #pragma warning (disable : 4275) // non DLL-interface classkey "identifier" used as base for DLL-interface classkey "identifier" + #pragma warning (disable : 4284) // odd return type for operator-> + #pragma warning (disable : 4290) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow) + #pragma warning (disable : 4324) // structure was padded due to __declspec(align( + #pragma warning (disable : 4345) // behavior change: an object of POD type constructed with an initializer of the form () will be default-initialized + #pragma warning (disable : 4355) // "this" : used in base member initializer list + #pragma warning (disable : 4503) // "identifier" : decorated name length exceeded, name was truncated + #pragma warning (disable : 4510) // default constructor could not be generated + #pragma warning (disable : 4511) // copy constructor could not be generated + #pragma warning (disable : 4512) // assignment operator could not be generated + #pragma warning (disable : 4514) // unreferenced inline removed + #pragma warning (disable : 4521) // Disable "multiple copy constructors specified" + #pragma warning (disable : 4522) // "class" : multiple assignment operators specified + #pragma warning (disable : 4541) // 'typeid' used on polymorphic type '' with /GR-; unpredictable behavior may result + #pragma warning (disable : 4584) // X is already a base-class of Y + #pragma warning (disable : 4610) // struct can never be instantiated - user defined constructor required + #pragma warning (disable : 4671) // the copy constructor is inaccessible + #pragma warning (disable : 4673) // throwing '' the following types will not be considered at the catch site + #pragma warning (disable : 4675) // "method" should be declared "static" and have exactly one parameter + #pragma warning (disable : 4706) // assignment within conditional expression + #pragma warning (disable : 4710) // function not inlined + #pragma warning (disable : 4714) // "function": marked as __forceinline not inlined + #pragma warning (disable : 4711) // function selected for automatic inline expansion + #pragma warning (disable : 4786) // identifier truncated in debug info + #pragma warning (disable : 4996) // "function": was declared deprecated + +#endif //BOOST_MSVC + + +#if defined(BOOST_GCC) && (BOOST_GCC >= 40600) +#pragma GCC diagnostic push +//Sign conversion warnings broken before GCC 9.3 +//(https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87519) +#if BOOST_GCC < 90300 +#pragma GCC diagnostic ignored "-Wsign-conversion" +#endif +#endif diff --git a/boost/include/boost/container/detail/config_end.hpp b/boost/include/boost/container/detail/config_end.hpp new file mode 100644 index 00000000..65643ea1 --- /dev/null +++ b/boost/include/boost/container/detail/config_end.hpp @@ -0,0 +1,16 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2005-2013. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// +#if defined BOOST_MSVC + #pragma warning (pop) +#endif + +#if defined(BOOST_GCC) && (BOOST_GCC >= 40600) +#pragma GCC diagnostic pop +#endif diff --git a/boost/include/boost/container/detail/construct_in_place.hpp b/boost/include/boost/container/detail/construct_in_place.hpp new file mode 100644 index 00000000..bfdf05c2 --- /dev/null +++ b/boost/include/boost/container/detail/construct_in_place.hpp @@ -0,0 +1,132 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2014-2014. +// +// 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_CONTAINER_DETAIL_CONSTRUCT_IN_PLACE_HPP +#define BOOST_CONTAINER_DETAIL_CONSTRUCT_IN_PLACE_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include +#include +#include + +namespace boost { +namespace container { + +//In place construction + +struct iterator_arg_t{}; + +template +BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T* dest, InpIt source) +{ boost::container::allocator_traits::construct(a, dest, *source); } + +template +BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, value_init_construct_iterator) +{ + boost::container::allocator_traits::construct(a, dest); +} + +template +class default_init_construct_iterator; + +template +BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, default_init_construct_iterator) +{ + boost::container::allocator_traits::construct(a, dest, default_init); +} + +template +class emplace_iterator; + +template +BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, emplace_iterator ei) +{ + ei.construct_in_place(a, dest); +} + +//Assignment + +template +BOOST_CONTAINER_FORCEINLINE + typename dtl::disable_if_c + < dtl::is_pair::type>::value + && dtl::is_pair::type>::value + , void>::type +assign_in_place_ref(T &t, BOOST_FWD_REF(U) u) +{ t = ::boost::forward(u); } + +template +BOOST_CONTAINER_FORCEINLINE + typename dtl::enable_if_c + < dtl::is_pair::type>::value + && dtl::is_pair::type>::value + , void>::type +assign_in_place_ref(T &t, const U &u) +{ + assign_in_place_ref(t.first, u.first); + assign_in_place_ref(t.second, u.second); +} + +template +BOOST_CONTAINER_FORCEINLINE + typename dtl::enable_if_c + < dtl::is_pair::type>::value + && dtl::is_pair::type>::value + , void>::type +assign_in_place_ref(T &t, BOOST_RV_REF(U) u) +{ + assign_in_place_ref(t.first, ::boost::move(u.first)); + assign_in_place_ref(t.second, ::boost::move(u.second)); +} + +template +BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, InpIt source) +{ assign_in_place_ref(*dest, *source); } + +template +BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, value_init_construct_iterator) +{ + dtl::value_init val; + *dest = boost::move(val.get()); +} + +template +class default_init_construct_iterator; + +template +BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, default_init_construct_iterator) +{ + U u; + *dest = boost::move(u); +} + +template +class emplace_iterator; + +template +BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, emplace_iterator ei) +{ + ei.assign_in_place(dest); +} + +} //namespace container { +} //namespace boost { + +#endif //#ifndef BOOST_CONTAINER_DETAIL_CONSTRUCT_IN_PLACE_HPP diff --git a/boost/include/boost/container/detail/container_or_allocator_rebind.hpp b/boost/include/boost/container/detail/container_or_allocator_rebind.hpp new file mode 100644 index 00000000..1525e41d --- /dev/null +++ b/boost/include/boost/container/detail/container_or_allocator_rebind.hpp @@ -0,0 +1,53 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2017-2017. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// +#ifndef BOOST_CONTAINER_DETAIL_CONTAINER_OR_ALLOCATOR_REBIND_HPP +#define BOOST_CONTAINER_DETAIL_CONTAINER_OR_ALLOCATOR_REBIND_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include +#include + +namespace boost { +namespace container { +namespace dtl { + +template::value> +struct container_or_allocator_rebind_impl + : container_rebind +{}; + +template +struct container_or_allocator_rebind_impl + : allocator_traits::template portable_rebind_alloc +{}; + +template +struct container_or_allocator_rebind_impl + : real_allocator +{}; + +template +struct container_or_allocator_rebind + : container_or_allocator_rebind_impl +{}; + +} //namespace dtl { +} //namespace container { +} //namespace boost { + +#endif //#ifndef BOOST_CONTAINER_DETAIL_CONTAINER_OR_ALLOCATOR_REBIND_HPP diff --git a/boost/include/boost/container/detail/container_rebind.hpp b/boost/include/boost/container/detail/container_rebind.hpp new file mode 100644 index 00000000..854291ae --- /dev/null +++ b/boost/include/boost/container/detail/container_rebind.hpp @@ -0,0 +1,163 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2017-2017. 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) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// +#ifndef BOOST_CONTAINER_DETAIL_CONTAINER_REBIND_HPP +#define BOOST_CONTAINER_DETAIL_CONTAINER_REBIND_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include + + +namespace boost { +namespace container { +namespace dtl { + + template + struct container_rebind; + +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + + template