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 00000000..156be156 Binary files /dev/null and b/boost/arm64-v8a/lib/libboost_container.a differ 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 00000000..a65b4058 Binary files /dev/null and b/boost/armeabi-v7a/lib/libboost_container.a differ 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