mirror of
https://github.com/boostorg/lexical_cast.git
synced 2026-07-22 13:34:02 +00:00
Compare commits
2 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 nobody
|
b3d53db6c5 | ||
|
nobody
|
dfca010fb3 |
@@ -1,11 +0,0 @@
|
||||
# To get started with Dependabot version updates, you'll need to specify which
|
||||
# package ecosystems to update and where the package manifests are located.
|
||||
# Please see the documentation for all configuration options:
|
||||
# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
|
||||
|
||||
version: 2
|
||||
updates:
|
||||
- package-ecosystem: "github-actions" # See documentation for possible values
|
||||
directory: "/" # Location of package manifests
|
||||
schedule:
|
||||
interval: "weekly"
|
||||
@@ -1,260 +0,0 @@
|
||||
name: CI
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
push:
|
||||
branches:
|
||||
- master
|
||||
- develop
|
||||
- feature/**
|
||||
|
||||
env:
|
||||
UBSAN_OPTIONS: print_stacktrace=1
|
||||
|
||||
jobs:
|
||||
posix:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- toolset: gcc-14 # Do not remove! It is the only toolset that tests CMake tests down below
|
||||
cxxstd: "03,11,14,17,20"
|
||||
os: ubuntu-24.04
|
||||
compiler: g++-14
|
||||
- toolset: gcc-12
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-22.04
|
||||
cxxflags: "cxxflags=--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined"
|
||||
linkflags: "linkflags=--coverage -lasan -lubsan"
|
||||
gcov_tool: "gcov-12"
|
||||
launcher: "testing.launcher=LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libasan.so.8"
|
||||
- toolset: gcc-11
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-22.04
|
||||
- toolset: clang
|
||||
compiler: clang++-14
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-22.04
|
||||
- toolset: clang
|
||||
cxxstd: "11,14,17,20"
|
||||
os: macos-latest
|
||||
- toolset: clang-19
|
||||
cxxstd: "20,23"
|
||||
os: ubuntu-24.04
|
||||
compiler: clang++-19
|
||||
install: clang-19 llvm-19 libclang-rt-19-dev libc++-19-dev libc++abi-19-dev clang-tools-19
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
|
||||
- name: Install packages
|
||||
if: matrix.install
|
||||
run: sudo apt install ${{matrix.install}}
|
||||
|
||||
- name: Setup Boost
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
|
||||
LIBRARY=${GITHUB_REPOSITORY#*/}
|
||||
echo LIBRARY: $LIBRARY
|
||||
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
|
||||
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
|
||||
echo GITHUB_REF: $GITHUB_REF
|
||||
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
|
||||
REF=${REF#refs/heads/}
|
||||
echo REF: $REF
|
||||
BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
|
||||
echo BOOST_BRANCH: $BOOST_BRANCH
|
||||
cd ..
|
||||
git clone -b $BOOST_BRANCH --depth 10 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
git submodule update --init --depth 10 --jobs 2 tools/boostdep tools/inspect libs/filesystem
|
||||
python tools/boostdep/depinst/depinst.py --git_args "--depth 10 --jobs 3" filesystem
|
||||
rm -rf libs/$LIBRARY/*
|
||||
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
|
||||
python tools/boostdep/depinst/depinst.py --include benchmark --include example --include examples --include tools --git_args "--depth 10 --jobs 3" $LIBRARY
|
||||
./bootstrap.sh
|
||||
./b2 -j4 variant=debug tools/inspect
|
||||
|
||||
- name: Run modules tests without 'import std;'
|
||||
if: ${{matrix.toolset == 'clang-19'}}
|
||||
run: |
|
||||
cd ../boost-root/libs/lexical_cast
|
||||
cmake -S test/cmake_subdir_test -B build_module \
|
||||
-GNinja \
|
||||
-DBUILD_TESTING=1 \
|
||||
-DBOOST_USE_MODULES=1 \
|
||||
-DCMAKE_CXX_COMPILER=clang++-19 \
|
||||
-DCMAKE_C_COMPILER=clang-19
|
||||
cmake --build build_module
|
||||
ctest --test-dir build_module -V --no-tests=error
|
||||
rm -rf build_module
|
||||
|
||||
- name: Run modules tests
|
||||
if: ${{matrix.toolset == 'clang-19'}}
|
||||
run: |
|
||||
cd ../boost-root/libs/lexical_cast
|
||||
cmake -S test/cmake_subdir_test -B build_module \
|
||||
-GNinja \
|
||||
-DBUILD_TESTING=1 \
|
||||
-DBOOST_USE_MODULES=1 \
|
||||
-DCMAKE_CXX_COMPILER=clang++-19 \
|
||||
-DCMAKE_C_COMPILER=clang-19 \
|
||||
-DCMAKE_CXX_FLAGS=-stdlib=libc++ \
|
||||
-DCMAKE_CXX_STANDARD=23 \
|
||||
-DCMAKE_EXPERIMENTAL_CXX_IMPORT_STD=0e5b6991-d74f-4b3d-a41c-cf096e0b2508 \
|
||||
-DCMAKE_CXX_MODULE_STD=ON
|
||||
cmake --build build_module
|
||||
ctest --test-dir build_module -V --no-tests=error
|
||||
rm -rf build_module
|
||||
|
||||
- name: Run CMake tests
|
||||
if: ${{matrix.toolset == 'gcc-14' || matrix.toolset == 'clang-19'}}
|
||||
run: |
|
||||
cd ../boost-root/
|
||||
cmake -S . -B __build \
|
||||
-DBUILD_TESTING=1 \
|
||||
-DBOOST_INCLUDE_LIBRARIES=lexical_cast \
|
||||
-DCMAKE_CXX_COMPILER=${{matrix.compiler}} \
|
||||
-DCMAKE_C_COMPILER=${{matrix.toolset}}
|
||||
cmake --build __build --target tests
|
||||
ctest --test-dir __build --output-on-failure --no-tests=error
|
||||
rm -rf __build
|
||||
|
||||
- name: Run tests
|
||||
run: |
|
||||
cd ../boost-root
|
||||
./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release "${{matrix.cxxflags}}" "${{matrix.linkflags}}" "${{matrix.launcher}}"
|
||||
dist/bin/inspect libs/$LIBRARY
|
||||
|
||||
- name: Prepare coverage data
|
||||
if: matrix.gcov_tool
|
||||
run: |
|
||||
mkdir -p $GITHUB_WORKSPACE/coveralls
|
||||
|
||||
echo -e "#!/bin/bash\nexec ${{matrix.gcov_tool}} \"\$@\"" > $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh
|
||||
chmod +x $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh
|
||||
wget https://github.com/linux-test-project/lcov/archive/v1.16.zip
|
||||
unzip v1.16.zip
|
||||
LCOV="`pwd`/lcov-1.16/bin/lcov --gcov-tool $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh"
|
||||
|
||||
echo "$LCOV --directory ../boost-root/bin.v2/libs/$LIBRARY/ --base-directory `pwd`/libs/$LIBRARY/test --capture --output-file $GITHUB_WORKSPACE/coveralls/coverage.info"
|
||||
$LCOV --directory ../boost-root/bin.v2/libs/$LIBRARY/ --base-directory ../boost-root/ --capture --output-file $GITHUB_WORKSPACE/coveralls/coverage.info
|
||||
$LCOV --remove $GITHUB_WORKSPACE/coveralls/coverage.info "/usr*" "*/$LIBRARY/test/*" ${{matrix.ignore_coverage}} "*/$LIBRARY/tests/*" "*/$LIBRARY/examples/*" "*/$LIBRARY/example/*" -o $GITHUB_WORKSPACE/coveralls/coverage.info
|
||||
|
||||
cd ../boost-root
|
||||
OTHER_LIBS=`grep "submodule .*" .gitmodules | sed 's/\[submodule\ "\(.*\)"\]/"\*\/boost\/\1\.hpp" "\*\/boost\/\1\/\*"/g'| sed "/\"\*\/boost\/$LIBRARY\/\*\"/d" | sed ':a;N;$!ba;s/\n/ /g'`
|
||||
echo $OTHER_LIBS
|
||||
eval "$LCOV --remove $GITHUB_WORKSPACE/coveralls/coverage.info $OTHER_LIBS -o $GITHUB_WORKSPACE/coveralls/coverage.info"
|
||||
|
||||
- name: Coveralls
|
||||
uses: coverallsapp/github-action@master
|
||||
if: matrix.gcov_tool
|
||||
with:
|
||||
github-token: ${{ secrets.GITHUB_TOKEN }}
|
||||
path-to-lcov: ./coveralls/coverage.info
|
||||
parallel: true
|
||||
|
||||
windows:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- toolset: msvc-14.3
|
||||
cxxstd: "14,17,20,latest"
|
||||
addrmd: 32,64
|
||||
os: windows-2022
|
||||
- toolset: msvc
|
||||
cxxstd: "14,17,latest"
|
||||
addrmd: 64
|
||||
os: windows-2025
|
||||
- toolset: gcc
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
addrmd: 64
|
||||
os: windows-2022
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
|
||||
- name: Setup Boost
|
||||
shell: cmd
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
|
||||
for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
|
||||
echo LIBRARY: %LIBRARY%
|
||||
echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
|
||||
echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
|
||||
echo GITHUB_REF: %GITHUB_REF%
|
||||
if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
|
||||
set BOOST_BRANCH=develop
|
||||
for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
|
||||
echo BOOST_BRANCH: %BOOST_BRANCH%
|
||||
cd ..
|
||||
git clone -b %BOOST_BRANCH% --depth 10 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
|
||||
git submodule update --init tools/boostdep libs/test
|
||||
python tools/boostdep/depinst/depinst.py --include benchmark --include example --include examples --include tools --git_args "--jobs 3" %LIBRARY%
|
||||
cmd /c bootstrap
|
||||
|
||||
- name: Run CMake tests
|
||||
if: ${{matrix.toolset == 'msvc-14.3'}}
|
||||
shell: cmd
|
||||
run: |
|
||||
choco install --no-progress ninja
|
||||
call "C:/Program Files/Microsoft Visual Studio/2022/Enterprise/VC/Auxiliary/Build/vcvarsall.bat" x64
|
||||
cd ../boost-root/
|
||||
mkdir __build
|
||||
cd __build
|
||||
cmake -DBUILD_TESTING=1 -DBOOST_INCLUDE_LIBRARIES=lexical_cast -G Ninja ..
|
||||
cmake --build . --target tests --config Debug
|
||||
ctest --output-on-failure --no-tests=error -C Debug
|
||||
|
||||
- name: Run modules tests
|
||||
if: false
|
||||
#if: ${{matrix.toolset == 'msvc-14.3'}}
|
||||
shell: cmd
|
||||
run: |
|
||||
choco install --no-progress ninja
|
||||
call "C:/Program Files/Microsoft Visual Studio/2022/Enterprise/VC/Auxiliary/Build/vcvarsall.bat" x64
|
||||
cd ../boost-root/libs/lexical_cast
|
||||
rm -rf build_module
|
||||
mkdir build_module
|
||||
cd build_module
|
||||
cmake -DBOOST_USE_MODULES=1 -DCMAKE_CXX_STANDARD=23 -DCMAKE_EXPERIMENTAL_CXX_IMPORT_STD=0e5b6991-d74f-4b3d-a41c-cf096e0b2508 -G Ninja ../test/cmake_subdir_test/
|
||||
cmake --build .
|
||||
ctest --no-tests=error -V
|
||||
|
||||
- name: Run modules tests without 'import std;'
|
||||
if: ${{matrix.toolset == 'msvc-14.3'}}
|
||||
shell: cmd
|
||||
run: |
|
||||
choco install --no-progress ninja
|
||||
call "C:/Program Files/Microsoft Visual Studio/2022/Enterprise/VC/Auxiliary/Build/vcvarsall.bat" x64
|
||||
cd ../boost-root/libs/lexical_cast
|
||||
rm -rf build_module
|
||||
mkdir build_module
|
||||
cd build_module
|
||||
cmake -DBOOST_USE_MODULES=1 -DCMAKE_CXX_STANDARD=20 -G Ninja ../test/cmake_subdir_test/
|
||||
cmake --build .
|
||||
ctest --no-tests=error -V
|
||||
|
||||
- name: Run tests
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root
|
||||
b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
|
||||
|
||||
finish:
|
||||
if: false
|
||||
needs: posix
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Coveralls Finished
|
||||
uses: coverallsapp/github-action@master
|
||||
with:
|
||||
github-token: ${{ secrets.github_token }}
|
||||
parallel-finished: true
|
||||
@@ -1,46 +0,0 @@
|
||||
# Generated by `boostdep --cmake lexical_cast`
|
||||
# Copyright 2020 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# https://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
cmake_minimum_required(VERSION 3.5...4.0)
|
||||
|
||||
project(boost_lexical_cast VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
|
||||
|
||||
|
||||
if (BOOST_USE_MODULES)
|
||||
add_library(boost_lexical_cast)
|
||||
target_sources(boost_lexical_cast PUBLIC
|
||||
FILE_SET modules_public TYPE CXX_MODULES FILES
|
||||
${CMAKE_CURRENT_LIST_DIR}/modules/boost_lexical_cast.cppm
|
||||
)
|
||||
|
||||
target_compile_features(boost_lexical_cast PUBLIC cxx_std_20)
|
||||
target_compile_definitions(boost_lexical_cast PUBLIC BOOST_USE_MODULES)
|
||||
if (CMAKE_CXX_COMPILER_IMPORT_STD)
|
||||
target_compile_definitions(boost_lexical_cast PRIVATE BOOST_LEXICAL_CAST_USE_STD_MODULE)
|
||||
message(STATUS "Using `import std;`")
|
||||
else()
|
||||
message(STATUS "`import std;` is not available")
|
||||
endif()
|
||||
set(__scope PUBLIC)
|
||||
else()
|
||||
add_library(boost_lexical_cast INTERFACE)
|
||||
set(__scope INTERFACE)
|
||||
endif()
|
||||
|
||||
target_include_directories(boost_lexical_cast ${__scope} include)
|
||||
target_link_libraries(boost_lexical_cast
|
||||
${__scope}
|
||||
Boost::config
|
||||
Boost::container
|
||||
Boost::core
|
||||
Boost::throw_exception
|
||||
)
|
||||
|
||||
add_library(Boost::lexical_cast ALIAS boost_lexical_cast)
|
||||
|
||||
if(BUILD_TESTING)
|
||||
add_subdirectory(test)
|
||||
endif()
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
# [Boost.LexicalCast](https://boost.org/libs/lexical_cast)
|
||||
Boost.LexicalCast is one of the [Boost C++ Libraries](https://github.com/boostorg). This library is meant for general literal text conversions, such as an int represented a string, or vice-versa.
|
||||
|
||||
### Test results
|
||||
|
||||
@ | Build | Tests coverage | More info
|
||||
----------------|-------------- | -------------- |-----------
|
||||
Develop branch: | [](https://github.com/boostorg/lexical_cast/actions/workflows/ci.yml) [](https://ci.appveyor.com/project/apolukhin/lexical-cast/branch/develop) | [](https://coveralls.io/r/boostorg/lexical_cast?branch=develop) | [details...](https://www.boost.org/development/tests/develop/developer/lexical_cast.html)
|
||||
Master branch: | [](https://github.com/boostorg/lexical_cast/actions/workflows/ci.yml) [](https://ci.appveyor.com/project/apolukhin/lexical-cast/branch/master) | [](https://coveralls.io/r/boostorg/lexical_cast?branch=master) | [details...](https://www.boost.org/development/tests/master/developer/lexical_cast.html)
|
||||
|
||||
[Latest developer documentation](https://www.boost.org/doc/libs/develop/doc/html/boost_lexical_cast.html)
|
||||
|
||||
### License
|
||||
|
||||
Distributed under the [Boost Software License, Version 1.0](https://boost.org/LICENSE_1_0.txt).
|
||||
@@ -1,26 +0,0 @@
|
||||
# Copyright René Ferdinand Rivera Morell 2023-2024
|
||||
# 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)
|
||||
|
||||
require-b2 5.2 ;
|
||||
|
||||
constant boost_dependencies :
|
||||
/boost/config//boost_config
|
||||
/boost/container//boost_container
|
||||
/boost/core//boost_core
|
||||
/boost/throw_exception//boost_throw_exception ;
|
||||
|
||||
project /boost/lexical_cast
|
||||
: common-requirements
|
||||
<include>include
|
||||
;
|
||||
|
||||
explicit
|
||||
[ alias boost_lexical_cast : : : : <library>$(boost_dependencies) ]
|
||||
[ alias all : boost_lexical_cast test ]
|
||||
;
|
||||
|
||||
call-if : boost-library lexical_cast
|
||||
;
|
||||
|
||||
@@ -0,0 +1,202 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
||||
|
||||
<html>
|
||||
<head>
|
||||
<meta name="generator" content=
|
||||
"HTML Tidy for Cygwin (vers 1st April 2002), see www.w3.org">
|
||||
<meta http-equiv="Content-Type" content=
|
||||
"text/html; charset=windows-1252">
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
|
||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||
|
||||
<title>Header boost/cast.hpp Documentation</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align=
|
||||
"middle" width="277" height="86">Header <a href=
|
||||
"../../boost/cast.hpp">boost/cast.hpp</a></h1>
|
||||
|
||||
<h2><a name="Cast Functions">Cast Functions</a></h2>
|
||||
|
||||
<p>The header <a href="../../boost/cast.hpp">boost/cast.hpp</a> provides
|
||||
<a href="#Polymorphic_cast"><b>polymorphic_cast</b></a>, <a href=
|
||||
"#Polymorphic_cast"><b>polymorphic_downcast</b></a>, and <a href=
|
||||
"#numeric_cast"><b>numeric_cast</b></a> function templates designed to
|
||||
complement the C++ built-in casts.</p>
|
||||
|
||||
<p>The program <a href="cast_test.cpp">cast_test.cpp</a> can be used to
|
||||
verify these function templates work as expected.</p>
|
||||
|
||||
<h3><a name="Polymorphic_cast">Polymorphic casts</a></h3>
|
||||
|
||||
<p>Pointers to polymorphic objects (objects of classes which define at
|
||||
least one virtual function) are sometimes downcast or crosscast.
|
||||
Downcasting means casting from a base class to a derived class.
|
||||
Crosscasting means casting across an inheritance hierarchy diagram, such
|
||||
as from one base to the other in a <b>Y</b> diagram hierarchy.</p>
|
||||
|
||||
<p>Such casts can be done with old-style casts, but this approach is
|
||||
never to be recommended. Old-style casts are sorely lacking in type
|
||||
safety, suffer poor readability, and are difficult to locate with search
|
||||
tools.</p>
|
||||
|
||||
<p>The C++ built-in <b>static_cast</b> can be used for efficiently
|
||||
downcasting pointers to polymorphic objects, but provides no error
|
||||
detection for the case where the pointer being cast actually points to
|
||||
the wrong derived class. The <b>polymorphic_downcast</b> template retains
|
||||
the efficiency of <b>static_cast</b> for non-debug compilations, but for
|
||||
debug compilations adds safety via an assert() that a <b>dynamic_cast</b>
|
||||
succeeds.</p>
|
||||
|
||||
<p>The C++ built-in <b>dynamic_cast</b> can be used for downcasts and
|
||||
crosscasts of pointers to polymorphic objects, but error notification in
|
||||
the form of a returned value of 0 is inconvenient to test, or worse yet,
|
||||
easy to forget to test. The throwing form of <b>dynamic_cast</b>, which
|
||||
works on references, can be used on pointers through the ugly expression
|
||||
&<code>dynamic_cast<T&>(*p)</code>, which causes undefined
|
||||
behavior if <code>p</code> is <code>0</code>. The <b>polymorphic_cast</b>
|
||||
template performs a <b>dynamic_cast</b> on a pointer, and throws an
|
||||
exception if the <b>dynamic_cast</b> returns 0.</p>
|
||||
|
||||
<p>A <b>polymorphic_downcast</b> is preferred when debug-mode tests will
|
||||
cover 100% of the object types possibly cast and when non-debug-mode
|
||||
efficiency is an issue. If these two conditions are not present,
|
||||
<b>polymorphic_cast</b> is preferred. It must also be used for
|
||||
crosscasts. It does an assert( dynamic_cast<Derived>(x) == x )
|
||||
where x is the base pointer, ensuring that not only is a non-zero pointer
|
||||
returned, but also that it correct in the presence of multiple
|
||||
inheritance. <b>Warning:</b>: Because <b>polymorphic_downcast</b> uses
|
||||
assert(), it violates the one definition rule (ODR) if NDEBUG is
|
||||
inconsistently defined across translation units. [See ISO Std 3.2]</p>
|
||||
|
||||
<p>The C++ built-in <b>dynamic_cast</b> must be used to cast references
|
||||
rather than pointers. It is also the only cast that can be used to check
|
||||
whether a given interface is supported; in that case a return of 0 isn't
|
||||
an error condition.</p>
|
||||
|
||||
<h3>polymorphic_cast and polymorphic_downcast synopsis</h3>
|
||||
|
||||
<blockquote>
|
||||
<pre>
|
||||
namespace boost {
|
||||
|
||||
template <class Derived, class Base>
|
||||
inline Derived polymorphic_cast(Base* x);
|
||||
// Throws: std::bad_cast if ( dynamic_cast<Derived>(x) == 0 )
|
||||
// Returns: dynamic_cast<Derived>(x)
|
||||
|
||||
template <class Derived, class Base>
|
||||
inline Derived polymorphic_downcast(Base* x);
|
||||
// Effects: assert( dynamic_cast<Derived>(x) == x );
|
||||
// Returns: static_cast<Derived>(x)
|
||||
|
||||
}
|
||||
</pre>
|
||||
</blockquote>
|
||||
|
||||
<h3>polymorphic_downcast example</h3>
|
||||
|
||||
<blockquote>
|
||||
<pre>
|
||||
#include <boost/cast.hpp>
|
||||
...
|
||||
class Fruit { public: virtual ~Fruit(){}; ... };
|
||||
class Banana : public Fruit { ... };
|
||||
...
|
||||
void f( Fruit * fruit ) {
|
||||
// ... logic which leads us to believe it is a Banana
|
||||
Banana * banana = boost::polymorphic_downcast<Banana*>(fruit);
|
||||
...
|
||||
</pre>
|
||||
</blockquote>
|
||||
|
||||
<h3><a name="numeric_cast">numeric_cast</a></h3>
|
||||
|
||||
<p>A <b>static_cast</b> or implicit conversion will not detect failure to
|
||||
preserve range for numeric casts. The <b>numeric_cast</b> function
|
||||
templates are similar to <b>static_cast</b> and certain (dubious)
|
||||
implicit conversions in this respect, except that they detect loss of
|
||||
numeric range. An exception is thrown when a runtime value-preservation
|
||||
check fails.</p>
|
||||
|
||||
<p>The requirements on the argument and result types are:</p>
|
||||
|
||||
<blockquote>
|
||||
<ul>
|
||||
<li>Both argument and result types are CopyConstructible [ISO Std
|
||||
20.1.3].</li>
|
||||
|
||||
<li>Both argument and result types are Numeric, defined by
|
||||
<code>std::numeric_limits<>::is_specialized</code> being
|
||||
true.</li>
|
||||
|
||||
<li>The argument can be converted to the result type using
|
||||
<b>static_cast</b>.</li>
|
||||
</ul>
|
||||
</blockquote>
|
||||
|
||||
<h3>numeric_cast synopsis</h3>
|
||||
|
||||
<blockquote>
|
||||
<pre>
|
||||
namespace boost {
|
||||
|
||||
class bad_numeric_cast : public std::bad_cast {...};
|
||||
|
||||
template<typename Target, typename Source>
|
||||
inline Target numeric_cast(Source arg);
|
||||
// Throws: bad_numeric_cast unless, in converting arg from Source to Target,
|
||||
// there is no loss of negative range, and no underflow, and no
|
||||
// overflow, as determined by std::numeric_limits
|
||||
// Returns: static_cast<Target>(arg)
|
||||
|
||||
}
|
||||
</pre>
|
||||
</blockquote>
|
||||
|
||||
<h3>numeric_cast example</h3>
|
||||
|
||||
<blockquote>
|
||||
<pre>
|
||||
#include <boost/cast.hpp>
|
||||
using namespace boost::cast;
|
||||
|
||||
void ariane(double vx)
|
||||
{
|
||||
...
|
||||
unsigned short dx = numeric_cast<unsigned short>(vx);
|
||||
...
|
||||
}
|
||||
</pre>
|
||||
</blockquote>
|
||||
|
||||
<h3>numeric_cast rationale</h3>
|
||||
|
||||
<p>The form of the throws condition is specified so that != is not a
|
||||
required operation.</p>
|
||||
|
||||
<h3>History</h3>
|
||||
|
||||
<p><b>polymorphic_cast</b> was suggested by Bjarne Stroustrup in "The C++
|
||||
Programming Language".<br>
|
||||
<b>polymorphic_downcast</b> was contributed by <a href=
|
||||
"../../people/dave_abrahams.htm">Dave Abrahams</a>.<b><br>
|
||||
numeric_cast</b> was contributed by <a href=
|
||||
"../../people/kevlin_henney.htm">Kevlin Henney</a>.</p>
|
||||
<hr>
|
||||
|
||||
<p>Revised
|
||||
<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan
|
||||
-->06 January, 2001
|
||||
<!--webbot bot="Timestamp" endspan i-checksum="38320"
|
||||
--></p>
|
||||
|
||||
<p>© Copyright boost.org 1999. Permission to copy, use, modify, sell
|
||||
and distribute this document is granted provided this copyright notice
|
||||
appears in all copies. This document is provided "as is" without express
|
||||
or implied warranty, and with no claim as to its suitability for any
|
||||
purpose.</p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -0,0 +1,91 @@
|
||||
// boost utility cast test program -----------------------------------------//
|
||||
|
||||
// (C) Copyright Beman Dawes, Dave Abrahams 1999. 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 for most recent version including documentation.
|
||||
|
||||
// Revision History
|
||||
// 28 Set 04 factored out numeric_cast<> test (Fernando Cacciola)
|
||||
// 20 Jan 01 removed use of <limits> for portability to raw GCC (David Abrahams)
|
||||
// 28 Jun 00 implicit_cast removed (Beman Dawes)
|
||||
// 30 Aug 99 value_cast replaced by numeric_cast
|
||||
// 3 Aug 99 Initial Version
|
||||
|
||||
#include <iostream>
|
||||
#include <climits>
|
||||
#include <cfloat> // for DBL_MAX (Peter Schmid)
|
||||
#include <boost/cast.hpp>
|
||||
|
||||
# if SCHAR_MAX == LONG_MAX
|
||||
# error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
|
||||
# endif
|
||||
|
||||
using namespace boost;
|
||||
using std::cout;
|
||||
|
||||
namespace
|
||||
{
|
||||
struct Base
|
||||
{
|
||||
virtual char kind() { return 'B'; }
|
||||
};
|
||||
|
||||
struct Base2
|
||||
{
|
||||
virtual char kind2() { return '2'; }
|
||||
};
|
||||
|
||||
struct Derived : public Base, Base2
|
||||
{
|
||||
virtual char kind() { return 'D'; }
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
int main( int argc, char * argv[] )
|
||||
{
|
||||
# ifdef NDEBUG
|
||||
cout << "NDEBUG is defined\n";
|
||||
# else
|
||||
cout << "NDEBUG is not defined\n";
|
||||
# endif
|
||||
|
||||
cout << "\nBeginning tests...\n";
|
||||
|
||||
// test polymorphic_cast ---------------------------------------------------//
|
||||
|
||||
// tests which should succeed
|
||||
Base * base = new Derived;
|
||||
Base2 * base2 = 0;
|
||||
Derived * derived = 0;
|
||||
derived = polymorphic_downcast<Derived*>( base ); // downcast
|
||||
assert( derived->kind() == 'D' );
|
||||
|
||||
derived = 0;
|
||||
derived = polymorphic_cast<Derived*>( base ); // downcast, throw on error
|
||||
assert( derived->kind() == 'D' );
|
||||
|
||||
base2 = polymorphic_cast<Base2*>( base ); // crosscast
|
||||
assert( base2->kind2() == '2' );
|
||||
|
||||
// tests which should result in errors being detected
|
||||
int err_count = 0;
|
||||
base = new Base;
|
||||
|
||||
if ( argc > 1 && *argv[1] == '1' )
|
||||
{ derived = polymorphic_downcast<Derived*>( base ); } // #1 assert failure
|
||||
|
||||
bool caught_exception = false;
|
||||
try { derived = polymorphic_cast<Derived*>( base ); }
|
||||
catch (std::bad_cast)
|
||||
{ cout<<"caught bad_cast\n"; caught_exception = true; }
|
||||
if ( !caught_exception ) ++err_count;
|
||||
// the following is just so generated code can be inspected
|
||||
if ( derived->kind() == 'B' ) ++err_count;
|
||||
|
||||
cout << err_count << " errors detected\nTest "
|
||||
<< (err_count==0 ? "passed\n" : "failed\n");
|
||||
return err_count;
|
||||
} // main
|
||||
@@ -1,27 +0,0 @@
|
||||
# Copyright Antony Polukhin, 2011-2026.
|
||||
#
|
||||
# Use, modification, and distribution are
|
||||
# subject to 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)
|
||||
|
||||
using quickbook ;
|
||||
import boostbook : boostbook ;
|
||||
|
||||
xml lexical_cast : lexical_cast.qbk ;
|
||||
boostbook standalone
|
||||
:
|
||||
lexical_cast
|
||||
:
|
||||
<xsl:param>boost.root=../../../..
|
||||
<format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
|
||||
;
|
||||
|
||||
###############################################################################
|
||||
alias boostdoc
|
||||
: lexical_cast
|
||||
:
|
||||
:
|
||||
: ;
|
||||
explicit boostdoc ;
|
||||
alias boostrelease ;
|
||||
explicit boostrelease ;
|
||||
@@ -1,847 +0,0 @@
|
||||
[library Boost.Lexical_Cast
|
||||
[quickbook 1.5]
|
||||
[version 1.0]
|
||||
[copyright 2000-2005 Kevlin Henney]
|
||||
[copyright 2006-2010 Alexander Nasonov]
|
||||
[copyright 2011-2026 Antony Polukhin]
|
||||
[category String and text processing]
|
||||
[category Miscellaneous]
|
||||
[license
|
||||
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])
|
||||
]
|
||||
]
|
||||
|
||||
[def __numericcast__ [@boost:libs/numeric/conversion/doc/html/boost_numericconversion/improved_numeric_cast__.html `boost::numeric_cast`]]
|
||||
[def __proposallong__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1973.html Lexical Conversion Library Proposal for TR2, N1973 by Kevlin Henney and Beman Dawes]]
|
||||
[def __proposalshort__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1973.html Lexical Conversion Library Proposal for TR2, N1973]]
|
||||
|
||||
[section Motivation]
|
||||
Sometimes a value must be converted to a literal text form, such as an [c++] `int` represented as a `std::string`, or vice-versa, when a `std::string` is interpreted as an `int`. Such examples are common when converting between data types internal to a program and representation external to a program, such as windows and configuration files.
|
||||
|
||||
The standard C and C++ libraries offer a number of facilities for performing such conversions. However, they vary with their ease of use, extensibility, and safety.
|
||||
|
||||
For instance, there are a number of limitations with the family of standard C functions typified by `atoi`:
|
||||
|
||||
* Conversion is supported in one direction only: from text to internal data type. Converting the other way using the C library requires either the inconvenience and compromised safety of the `sprintf` function, or the loss of portability associated with non-standard functions such as `itoa`.
|
||||
* The range of types supported is only a subset of the built-in numeric types, namely `int`, `long`, and `double`.
|
||||
* The range of types cannot be extended in a uniform manner. For instance, conversion from string representation to complex or rational.
|
||||
|
||||
The standard C functions typified by `strtol` have the same basic limitations, but offer finer control over the conversion process. However, for the common case such control is often either not required or not used. The `scanf` family of functions offer even greater control, but also lack safety and ease of use.
|
||||
|
||||
The standard C++ library offers `stringstream` for the kind of in-core formatting being discussed. It offers a great deal of control over the formatting and conversion of I/O to and from arbitrary types through text. However, for simple conversions direct use of `stringstream` can be either clumsy (with the introduction of extra local variables and the loss of infix-expression convenience) or obscure (where `stringstream` objects are created as temporary objects in an expression). Facets provide a comprehensive concept and facility for controlling textual representation, but their perceived complexity and high entry level requires an extreme degree of involvement for simple conversions, and excludes all but a few programmers.
|
||||
|
||||
The `lexical_cast` function template offers a convenient and consistent form for supporting common conversions to and from arbitrary types when they are represented as text. The simplification it offers is in expression-level convenience for such conversions. For more involved conversions, such as where precision or formatting need tighter control than is offered by the default behavior of `lexical_cast`, the conventional `std::stringstream` approach is recommended. Where the conversions are numeric to numeric, __numericcast__ may offer more reasonable behavior than `lexical_cast`.
|
||||
|
||||
For a good discussion of the options and issues involved in string-based formatting, including comparison of `stringstream`, `lexical_cast`, and others, see Herb Sutter's article, [@http://www.gotw.ca/publications/mill19.htm The String Formatters of Manor Farm]. Also, take a look at the [link boost_lexical_cast.performance Performance] section.
|
||||
[endsect]
|
||||
|
||||
[section Examples]
|
||||
|
||||
[import ../example/args_to_numbers.cpp]
|
||||
|
||||
[section Strings to numbers conversion] [lexical_cast_args_example] [endsect]
|
||||
|
||||
[import ../example/small_examples.cpp]
|
||||
[section Numbers to strings conversion] [lexical_cast_log_errno] [endsect]
|
||||
[section Converting to string without dynamic memory allocation] [lexical_cast_fixed_buffer] [endsect]
|
||||
[section Converting part of the string] [lexical_cast_substring_conversion] [endsect]
|
||||
|
||||
[import ../example/generic_stringize.cpp]
|
||||
[section Generic programming (Boost.Fusion)] [lexical_cast_stringize] [endsect]
|
||||
|
||||
[import ../example/variant_to_long_double.cpp]
|
||||
[section Generic programming (Boost.Variant)] [lexical_cast_variant_to_long_double] [endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Synopsis]
|
||||
Library features defined in [@boost:boost/lexical_cast.hpp boost/lexical_cast.hpp]:
|
||||
``
|
||||
namespace boost
|
||||
{
|
||||
class bad_lexical_cast;
|
||||
|
||||
template<typename Target, typename Source>
|
||||
Target lexical_cast(const Source& arg);
|
||||
|
||||
template <typename Target>
|
||||
Target lexical_cast(const AnyCharacterType* chars, std::size_t count);
|
||||
|
||||
namespace conversion
|
||||
{
|
||||
template<typename Target, typename Source>
|
||||
bool try_lexical_convert(const Source& arg, Target& result);
|
||||
|
||||
template <typename AnyCharacterType, typename Target>
|
||||
bool try_lexical_convert(const AnyCharacterType* chars, std::size_t count, Target& result);
|
||||
|
||||
} // namespace conversion
|
||||
} // namespace boost
|
||||
``
|
||||
|
||||
[section lexical_cast]
|
||||
``
|
||||
template<typename Target, typename Source>
|
||||
Target lexical_cast(const Source& arg);
|
||||
``
|
||||
Returns the result of streaming arg into a standard library string-based stream and then out as a Target object. Where Target is either `std::string` or `std::wstring`, stream extraction takes the whole content of the string, including spaces, rather than relying on the default `operator>>` behavior. If the conversion is unsuccessful, a `bad_lexical_cast` exception is thrown.
|
||||
|
||||
``
|
||||
template <typename Target>
|
||||
Target lexical_cast(const AnyCharacterType* chars, std::size_t count);
|
||||
``
|
||||
Takes an array of `count` characters as input parameter and streams them out as a Target object. If the conversion is unsuccessful, a `bad_lexical_cast` exception is thrown. This call may be useful for processing nonzero terminated array of characters or processing just some part of character array.
|
||||
|
||||
The requirements on the argument and result types for both functions are:
|
||||
|
||||
* Source is OutputStreamable, meaning that an `operator<<` is defined that takes a `std::ostream` or `std::wostream` object on the left hand side and an instance of the argument type on the right.
|
||||
* Target is InputStreamable, meaning that an `operator>>` is defined that takes a `std::istream` or `std::wistream` object on the left hand side and an instance of the result type on the right.
|
||||
* Target is CopyConstructible [20.1.3].
|
||||
* Target is DefaultConstructible, meaning that it is possible to default-initialize an object of that type [8.5, 20.1.4].
|
||||
|
||||
The character type of the underlying stream is assumed to be `char` unless either the `Source` or the `Target` requires wide-character streaming, in which case the underlying stream uses `wchar_t`. Following types also can use `char16_t` or `char32_t` for wide-character streaming:
|
||||
|
||||
* Single character: `char16_t`, `char32_t`
|
||||
* Arrays of characters: `char16_t *`, `char32_t *`, `const char16_t *`, `const char32_t *`
|
||||
* Strings: `std::basic_string`, `boost::containers::basic_string`
|
||||
* `boost::iterator_range<WideCharPtr>`, where `WideCharPtr` is a pointer to wide-character or pointer to const wide-character
|
||||
* `boost::array<CharT, N>` and `std::array<CharT, N>`, `boost::array<const CharT, N>` and `std::array<const CharT, N>`
|
||||
|
||||
[important Many compilers and runtime libraries fail to make conversions using new Unicode characters. Make sure that the following code compiles and outputs nonzero values, before using new types:
|
||||
``
|
||||
std::cout
|
||||
<< boost::lexical_cast<std::u32string>(1.0).size()
|
||||
<< " "
|
||||
<< boost::lexical_cast<std::u16string>(1.0).size();
|
||||
``
|
||||
]
|
||||
|
||||
Where a higher degree of control is required over conversions, `std::stringstream` and `std::wstringstream` offer a more appropriate path. Where non-stream-based conversions are required, `lexical_cast` is the wrong tool for the job and is not special-cased for such scenarios.
|
||||
[endsect]
|
||||
|
||||
[section bad_lexical_cast]
|
||||
``
|
||||
class bad_lexical_cast : public std::bad_cast
|
||||
{
|
||||
public:
|
||||
... // same member function interface as std::exception
|
||||
};
|
||||
``
|
||||
Exception used to indicate runtime lexical_cast failure.
|
||||
[endsect]
|
||||
|
||||
[section try_lexical_convert]
|
||||
`boost::lexical_cast` remains the main interface for lexical conversions. It must be used by default in most cases. However
|
||||
some developers wish to make their own conversion functions, reusing all the optimizations of the `boost::lexical_cast`.
|
||||
That's where the `boost::conversion::try_lexical_convert` function steps in.
|
||||
|
||||
`try_lexical_convert` returns `true` if conversion succeeded, otherwise returns `false`. If conversion
|
||||
failed and `false` was returned, state of `result` output variable is undefined.
|
||||
|
||||
Actually, `boost::lexical_cast` is implemented using `try_lexical_convert`:
|
||||
``
|
||||
template <typename Target, typename Source>
|
||||
inline Target lexical_cast(const Source &arg)
|
||||
{
|
||||
Target result;
|
||||
|
||||
if (!conversion::try_lexical_convert(arg, result))
|
||||
throw bad_lexical_cast();
|
||||
|
||||
return result;
|
||||
}
|
||||
``
|
||||
|
||||
`try_lexical_convert` relaxes the CopyConstructible and DefaultConstructible requirements for `Target` type.
|
||||
Following requirements for `Target` and `Source` remain:
|
||||
|
||||
* Source must be OutputStreamable, meaning that an `operator<<` is defined that takes a `std::ostream` or `std::wostream` object on the left hand side and an instance of the argument type on the right.
|
||||
* Target must be InputStreamable, meaning that an `operator>>` is defined that takes a `std::istream` or `std::wistream` object on the left hand side and an instance of the result type on the right.
|
||||
|
||||
[endsect]
|
||||
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Frequently Asked Questions]
|
||||
|
||||
* [*Question:] Why does `lexical_cast<int8_t>("127")` throw `bad_lexical_cast`?
|
||||
* [*Answer:] The type `int8_t` is a `typedef` to `char` or `signed char`. Lexical conversion to these types is simply reading a byte from source but since the source has more than one byte, the exception is thrown.
|
||||
Please use other integer types such as `int` or `short int`. If bounds checking is important, you can also
|
||||
call __numericcast__:
|
||||
`numeric_cast<int8_t>(lexical_cast<int>("127"));`
|
||||
|
||||
[pre
|
||||
]
|
||||
|
||||
* [*Question:] Why does `lexical_cast<unsigned char>("127")` throw `bad_lexical_cast`?
|
||||
* [*Answer:] Lexical conversion to any char type is simply reading a byte from source. But since the source has more than one byte, the exception is thrown.
|
||||
Please use other integer types such as `int` or `short int`. If bounds checking is important, you can also
|
||||
call __numericcast__:
|
||||
`numeric_cast<unsigned char>(lexical_cast<int>("127"));`
|
||||
|
||||
[pre
|
||||
]
|
||||
|
||||
* [*Question:] What does `lexical_cast<std::string>` of an `int8_t` or `uint8_t` not do what I expect?
|
||||
* [*Answer:] As above, note that int8_t and uint8_t are actually chars and are formatted as such. To avoid
|
||||
this, cast to an integer type first: `lexical_cast<std::string>(static_cast<int>(n));`
|
||||
|
||||
[pre
|
||||
]
|
||||
|
||||
* [*Question:] The implementation always resets the `ios_base::skipws` flag of an underlying stream object.
|
||||
It breaks my `operator>>` that works only in presence of this flag. Can you remove code that resets the flag?
|
||||
* [*Answer:] May be in a future version. There is no requirement in
|
||||
__proposallong__ to reset the flag but
|
||||
remember that __proposalshort__ is not yet accepted by the committee. By the way, it's a great opportunity to
|
||||
make your `operator>>` more general.
|
||||
Read a good C++ book, study `std::sentry` and [@boost:libs/io/doc/ios_state.html `ios_state_saver`].
|
||||
|
||||
[pre
|
||||
]
|
||||
|
||||
* [*Question:] Why does `std::cout << boost::lexical_cast<unsigned int>("-1");` not throw, but outputs 4294967295?
|
||||
* [*Answer:] `boost::lexical_cast` has the behavior of `std::stringstream`, which uses `num_get` functions of
|
||||
`std::locale` to convert numbers. If we look at the Programming languages — C++, we'll see, that `num_get` uses
|
||||
the rules of `scanf` for conversions. And in the C99 standard for unsigned input value minus sign is optional, so
|
||||
if a negative number is read, no errors will arise and the result will be the two's complement.
|
||||
|
||||
[pre
|
||||
]
|
||||
|
||||
* [*Question:] Why does `boost::lexical_cast<int>(L'A');` output 65 and `boost::lexical_cast<wchar_t>(L"65");` not throw?
|
||||
* [*Answer:] If you are using an old version of Visual Studio or compile code with /Zc:wchar_t- flag,
|
||||
`boost::lexical_cast` sees single `wchar_t` character as `unsigned short`. It is not a `boost::lexical_cast` mistake, but a
|
||||
limitation of compiler options that you use.
|
||||
|
||||
[pre
|
||||
]
|
||||
|
||||
* [*Question:] Why does `boost::lexical_cast<double>("-1.#IND");` throw `boost::bad_lexical_cast`?
|
||||
* [*Answer:] `"-1.#IND"` is a compiler extension, that violates standard. You shall input `"-nan"`, `"nan"`, `"inf"`
|
||||
, `"-inf"` (case insensitive) strings to get NaN and Inf values. `boost::lexical_cast<string>` outputs `"-nan"`, `"nan"`,
|
||||
`"inf"`, `"-inf"` strings, when has NaN or Inf input values.
|
||||
|
||||
[pre
|
||||
]
|
||||
|
||||
* [*Question:] What is the fastest way to convert a non zero terminated string or a substring using `boost::lexical_cast`?
|
||||
* [*Answer:] Use `boost::iterator_range` for conversion or `lexical_cast` overload with two parameters. For example, if you want to convert to `int` two characters from a string `str`, you shall write `lexical_cast<int>(make_iterator_range(str.data(), str.data() + 2));` or `lexical_cast<int>(str.data(), 2);`.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section C++20 module]
|
||||
|
||||
[caution C++20 module support is on early stage, targets, flags and behavior may change in the future]
|
||||
|
||||
If using modern CMake define CMake option `-DBOOST_USE_MODULES=1` to build a C++20 module and
|
||||
make the `Boost::lexical_cast` CMake target provide it. After that an explicit usage of C++20 module `boost.lexical_cast` is allowed:
|
||||
|
||||
[import ../modules/usage_sample.cpp]
|
||||
[lexical_cast_module_example]
|
||||
|
||||
The `Boost::lexical_cast` CMake target gives an ability to mix includes and imports of the library in different translation units. Moreover,
|
||||
if `BOOST_USE_MODULES` macro is defined then all the `boost/lexical_cast...` includes implicitly do `import boost.lexical_cast;` to give all the
|
||||
benefits of modules without changing the existing code.
|
||||
|
||||
[note For better compile times make sure that `import std;` is available when building the `boost.lexical_cast` module (in CMake logs there should be
|
||||
a 'Using `import std;`' message). ]
|
||||
|
||||
If not using CMake, then the module could be build manually from the `modules/boost_lexical_cast.cppm` file.
|
||||
|
||||
For manual module build the following commands could be used for clang compiler:
|
||||
|
||||
```
|
||||
cd lexical_cast/modules
|
||||
clang++ -I ../include -std=c++20 --precompile -x c++-module boost_lexical_cast.cppm
|
||||
```
|
||||
|
||||
After that, the module could be used in the following way:
|
||||
|
||||
```
|
||||
clang++ -std=c++20 -fmodule-file=boost_lexical_cast.pcm boost_lexical_cast.pcm usage_sample.cpp
|
||||
```
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Changes]
|
||||
|
||||
* [*boost 1.91.0 :]
|
||||
* Added C++20 modules support.
|
||||
|
||||
* [*boost 1.86.0 :]
|
||||
|
||||
* Fixed conversion of `std::basic_string_view` and `boost::basic_string_view`
|
||||
containing one or more `\0` characters. Issue was introduced in 1.85.0.
|
||||
|
||||
* [*boost 1.85.0 :]
|
||||
|
||||
* Significant rewrite of the internal logic to separate optimized and C++ Standard Library IO-based streams:
|
||||
* C++ Standard Library based streams now constructed in less cases leading to [*better performance];
|
||||
* less template instantiations and simpler code;
|
||||
* always use `std::char_traits` (do not use custom traits from input/output types as it leads to linktime or runtime errors);
|
||||
* support for `volatile` input types was dropped, following the C++ Standard Library trend.
|
||||
* Optimized conversions from std::basic_string_view and boost::basic_string_view
|
||||
* Dropped dependency on Boost.NumericConversion and Boost.MPL. Fixed some cases
|
||||
of converting floting point types to arithmetics.
|
||||
* The library now works fine with `-fno-sanitize-recover=integer`.
|
||||
|
||||
* [*boost 1.84.0 :]
|
||||
|
||||
* Dropped support of C++98 and C++03.
|
||||
|
||||
* [*boost 1.56.0 :]
|
||||
|
||||
* Added `boost::conversion::try_lexical_convert` functions.
|
||||
|
||||
* [*boost 1.54.0 :]
|
||||
|
||||
* Fix some issues with `boost::int128_type` and `boost::uint128_type` conversions. Notify user at compile time
|
||||
if the `std::numeric_limits` are not specialized for 128bit types and `boost::lexical_cast` can not make conversions.
|
||||
|
||||
* [*boost 1.54.0 :]
|
||||
|
||||
* Added code to convert `boost::int128_type` and `boost::uint128_type` types (requires GCC 4.7 or higher).
|
||||
* Conversions to pointers will now fail to compile, instead of throwing at runtime.
|
||||
* Restored ability to get pointers to `lexical_cast` function (was broken in 1.53.0).
|
||||
|
||||
* [*boost 1.53.0 :]
|
||||
|
||||
* Much better input and output streams detection for user defined types.
|
||||
|
||||
* [*boost 1.52.0 :]
|
||||
|
||||
* Restored compilation on MSVC-2003 (was broken in 1.51.0).
|
||||
* Added `lexical_cast(const CharType* chars, std::size_t count)` function overload.
|
||||
|
||||
* [*boost 1.51.0 :]
|
||||
|
||||
* Better performance, less memory usage for `boost::array<character_type, N>` and `std::array<character_type, N>` conversions.
|
||||
|
||||
* [*boost 1.50.0 :]
|
||||
|
||||
* `boost::bad_lexical_cast` exception is now globaly visible and can be catched even if code is compiled with -fvisibility=hidden.
|
||||
* Now it is possible to compile library with disabled exceptions.
|
||||
* Better performance, less memory usage and bugfixes for `boost::iterator_range<character_type*>` conversions.
|
||||
|
||||
* [*boost 1.49.0 :]
|
||||
|
||||
* Restored work with typedefed wchar_t (compilation flag /Zc:wchar_t- for Visual Studio).
|
||||
* Better performance and less memory usage for `boost::container::basic_string` conversions.
|
||||
|
||||
* [*boost 1.48.0 :]
|
||||
|
||||
* Added code to work with Inf and NaN on any platform.
|
||||
* Better performance and less memory usage for conversions to float type (and to double type, if `sizeof(double) < sizeof(long double)`).
|
||||
|
||||
* [*boost 1.47.0 :]
|
||||
|
||||
* Optimizations for "C" and other locales without number grouping.
|
||||
* Better performance and less memory usage for unsigned char and signed char conversions.
|
||||
* Better performance and less memory usage for conversions to arithmetic types.
|
||||
* Better performance and less memory usage for conversions from arithmetic type to arithmetic type.
|
||||
* Directly construct Target from Source on some conversions (like conversions from string to string, from char array to string, from char to char and others).
|
||||
|
||||
* [*boost 1.34.0 :]
|
||||
|
||||
* Better performance for many combinations of Source and Target types. For more details refer to Alexander Nasonovs article [@http://accu.org/index.php/journals/1375 Fine Tuning for lexical_cast, Overload #74, August 2006] [@http://www.accu.org/var/uploads/journals/overload74.pdf (PDF)].
|
||||
|
||||
* [*boost 1.33.0 :]
|
||||
|
||||
* Call-by-const reference for the parameters. This requires partial specialization of class templates, so it doesn't work for MSVC 6, and it uses the original pass by value there.
|
||||
* The MSVC 6 support is deprecated, and will be removed in a future Boost version.
|
||||
|
||||
* [*Earlier :]
|
||||
|
||||
* The previous version of lexical_cast used the default stream precision for reading and writing floating-point numbers. For numerics that have a corresponding specialization of `std::numeric_limits`, the current version now chooses a precision to match.
|
||||
* The previous version of lexical_cast did not support conversion to or from any wide-character-based types. For compilers with full language and library support for wide characters, `lexical_cast` now supports conversions from `wchar_t`, `wchar_t *`, and `std::wstring` and to `wchar_t` and `std::wstring`.
|
||||
* The previous version of `lexical_cast` assumed that the conventional stream extractor operators were sufficient for reading values. However, string I/O is asymmetric, with the result that spaces play the role of I/O separators rather than string content. The current version fixes this error for `std::string` and, where supported, `std::wstring`: `lexical_cast<std::string>("Hello, World")` succeeds instead of failing with a `bad_lexical_cast` exception.
|
||||
* The previous version of `lexical_cast` allowed unsafe and meaningless conversions to pointers. The current version now throws a `bad_lexical_cast` for conversions to pointers: `lexical_cast<char *>("Goodbye, World")` now throws an exception instead of causing undefined behavior.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Performance]
|
||||
|
||||
In most cases `boost::lexical_cast` is faster than `scanf`, `printf`, `std::stringstream`. For more detailed info you can look at the tables below.
|
||||
|
||||
[section Tests description]
|
||||
All the tests measure execution speed in milliseconds for 10000 iterations of the following code blocks:
|
||||
[table:legend Tests source code
|
||||
[[Test name] [Code]]
|
||||
[[lexical_cast]
|
||||
[``
|
||||
_out = boost::lexical_cast<OUTTYPE>(_in);
|
||||
``]
|
||||
]
|
||||
[[std::stringstream with construction]
|
||||
[``
|
||||
std::stringstream ss;
|
||||
ss << _in;
|
||||
if (ss.fail()) throw std::logic_error(descr);
|
||||
ss >> _out;
|
||||
if (ss.fail()) throw std::logic_error(descr);
|
||||
``]
|
||||
]
|
||||
[[std::stringstream without construction]
|
||||
[``
|
||||
ss << _in; // ss is an instance of std::stringstream
|
||||
if (ss.fail()) throw std::logic_error(descr);
|
||||
ss >> _out;
|
||||
if (ss.fail()) throw std::logic_error(descr);
|
||||
/* reseting std::stringstream to use it again */
|
||||
ss.str(std::string());
|
||||
ss.clear();
|
||||
``]
|
||||
]
|
||||
[[scanf/printf]
|
||||
[``
|
||||
typename OUTTYPE::value_type buffer[500];
|
||||
sprintf( (char*)buffer, conv, _in);
|
||||
_out = buffer;
|
||||
``]
|
||||
]
|
||||
]
|
||||
Fastest results are highlitened with "!!! *x* !!!".
|
||||
Do not use this results to compare compilers, because tests were taken on different hardware.
|
||||
|
||||
[endsect]
|
||||
|
||||
[/ BEGIN of section, generated by performance measuring program ]
|
||||
|
||||
|
||||
|
||||
[section GNU C++ version 9.4.0]
|
||||
[table:id Performance Table ( GNU C++ version 9.4.0)
|
||||
[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
|
||||
[[ string->char ][ !!! *<1* !!! ][ 59 ][ 7 ][ 17 ]]
|
||||
[[ string->signed char ][ !!! *<1* !!! ][ 142 ][ 13 ][ 21 ]]
|
||||
[[ string->unsigned char ][ !!! *<1* !!! ][ 63 ][ 5 ][ 8 ]]
|
||||
[[ string->int ][ !!! *4* !!! ][ 63 ][ 13 ][ 12 ]]
|
||||
[[ string->short ][ !!! *4* !!! ][ 65 ][ 12 ][ 12 ]]
|
||||
[[ string->long int ][ !!! *4* !!! ][ 62 ][ 12 ][ 12 ]]
|
||||
[[ string->long long ][ !!! *3* !!! ][ 61 ][ 13 ][ 12 ]]
|
||||
[[ string->unsigned int ][ !!! *4* !!! ][ 58 ][ 10 ][ 12 ]]
|
||||
[[ string->unsigned short ][ !!! *4* !!! ][ 59 ][ 10 ][ 12 ]]
|
||||
[[ string->unsigned long int ][ !!! *4* !!! ][ 62 ][ 11 ][ 12 ]]
|
||||
[[ string->unsigned long long ][ !!! *4* !!! ][ 64 ][ 11 ][ 12 ]]
|
||||
[[ string->float ][ 59 ][ 92 ][ 35 ][ !!! *23* !!! ]]
|
||||
[[ string->double ][ 55 ][ 89 ][ 31 ][ !!! *23* !!! ]]
|
||||
[[ string->long double ][ 52 ][ 83 ][ 32 ][ !!! *26* !!! ]]
|
||||
[[ string->array<char, 50> ][ !!! *<1* !!! ][ 59 ][ 10 ][ 8 ]]
|
||||
[[ string->string ][ !!! *1* !!! ][ 68 ][ 13 ][ --- ]]
|
||||
[[ string->container::string ][ !!! *<1* !!! ][ 65 ][ 11 ][ --- ]]
|
||||
[[ string->char ][ !!! *1* !!! ][ 58 ][ 10 ][ 7 ]]
|
||||
[[ string->signed char ][ !!! *1* !!! ][ 57 ][ 10 ][ 10 ]]
|
||||
[[ string->unsigned char ][ !!! *1* !!! ][ 57 ][ 10 ][ 10 ]]
|
||||
[[ int->string ][ !!! *4* !!! ][ 64 ][ 13 ][ 10 ]]
|
||||
[[ short->string ][ !!! *4* !!! ][ 69 ][ 13 ][ 10 ]]
|
||||
[[ long int->string ][ !!! *4* !!! ][ 68 ][ 13 ][ 10 ]]
|
||||
[[ long long->string ][ !!! *4* !!! ][ 66 ][ 13 ][ 10 ]]
|
||||
[[ unsigned int->string ][ !!! *4* !!! ][ 62 ][ 14 ][ 10 ]]
|
||||
[[ unsigned short->string ][ !!! *4* !!! ][ 66 ][ 13 ][ 10 ]]
|
||||
[[ unsigned long int->string ][ !!! *4* !!! ][ 70 ][ 13 ][ 10 ]]
|
||||
[[ unsigned long long->string ][ !!! *4* !!! ][ 64 ][ 14 ][ 10 ]]
|
||||
[[ float->string ][ 26 ][ 108 ][ 50 ][ !!! *23* !!! ]]
|
||||
[[ double->string ][ 33 ][ 114 ][ 51 ][ !!! *26* !!! ]]
|
||||
[[ long double->string ][ 88 ][ 194 ][ 54 ][ !!! *26* !!! ]]
|
||||
[[ char*->char ][ !!! *<1* !!! ][ 53 ][ 6 ][ 5 ]]
|
||||
[[ char*->signed char ][ !!! *<1* !!! ][ 52 ][ 6 ][ 7 ]]
|
||||
[[ char*->unsigned char ][ !!! *<1* !!! ][ 55 ][ 6 ][ 7 ]]
|
||||
[[ char*->int ][ !!! *4* !!! ][ 67 ][ 12 ][ 10 ]]
|
||||
[[ char*->short ][ !!! *4* !!! ][ 68 ][ 13 ][ 10 ]]
|
||||
[[ char*->long int ][ !!! *3* !!! ][ 68 ][ 13 ][ 10 ]]
|
||||
[[ char*->long long ][ !!! *3* !!! ][ 67 ][ 14 ][ 10 ]]
|
||||
[[ char*->unsigned int ][ !!! *3* !!! ][ 67 ][ 11 ][ 10 ]]
|
||||
[[ char*->unsigned short ][ !!! *3* !!! ][ 61 ][ 11 ][ 11 ]]
|
||||
[[ char*->unsigned long int ][ !!! *3* !!! ][ 61 ][ 13 ][ 10 ]]
|
||||
[[ char*->unsigned long long ][ !!! *3* !!! ][ 67 ][ 13 ][ 10 ]]
|
||||
[[ char*->float ][ 56 ][ 93 ][ 35 ][ !!! *21* !!! ]]
|
||||
[[ char*->double ][ 59 ][ 88 ][ 33 ][ !!! *21* !!! ]]
|
||||
[[ char*->long double ][ 54 ][ 88 ][ 33 ][ !!! *24* !!! ]]
|
||||
[[ char*->array<char, 50> ][ !!! *<1* !!! ][ 63 ][ 11 ][ 8 ]]
|
||||
[[ char*->string ][ !!! *1* !!! ][ 65 ][ 12 ][ --- ]]
|
||||
[[ char*->container::string ][ !!! *<1* !!! ][ 71 ][ 13 ][ --- ]]
|
||||
[[ unsigned char*->char ][ !!! *<1* !!! ][ 57 ][ 6 ][ 5 ]]
|
||||
[[ unsigned char*->signed char ][ !!! *<1* !!! ][ 57 ][ 6 ][ 7 ]]
|
||||
[[ unsigned char*->unsigned char ][ !!! *<1* !!! ][ 63 ][ 5 ][ 6 ]]
|
||||
[[ unsigned char*->int ][ !!! *4* !!! ][ 63 ][ 12 ][ 10 ]]
|
||||
[[ unsigned char*->short ][ !!! *4* !!! ][ 65 ][ 13 ][ 10 ]]
|
||||
[[ unsigned char*->long int ][ !!! *3* !!! ][ 67 ][ 12 ][ 10 ]]
|
||||
[[ unsigned char*->long long ][ !!! *3* !!! ][ 66 ][ 12 ][ 10 ]]
|
||||
[[ unsigned char*->unsigned int ][ !!! *3* !!! ][ 64 ][ 11 ][ 10 ]]
|
||||
[[ unsigned char*->unsigned short ][ !!! *3* !!! ][ 65 ][ 12 ][ 10 ]]
|
||||
[[ unsigned char*->unsigned long int ][ !!! *3* !!! ][ 60 ][ 13 ][ 10 ]]
|
||||
[[ unsigned char*->unsigned long long ][ !!! *3* !!! ][ 62 ][ 12 ][ 10 ]]
|
||||
[[ unsigned char*->float ][ 57 ][ 94 ][ 34 ][ !!! *21* !!! ]]
|
||||
[[ unsigned char*->double ][ 60 ][ 88 ][ 35 ][ !!! *21* !!! ]]
|
||||
[[ unsigned char*->long double ][ 54 ][ 89 ][ 32 ][ !!! *24* !!! ]]
|
||||
[[ unsigned char*->array<char, 50> ][ !!! *<1* !!! ][ 68 ][ 12 ][ 8 ]]
|
||||
[[ unsigned char*->string ][ !!! *1* !!! ][ 61 ][ 13 ][ --- ]]
|
||||
[[ unsigned char*->container::string ][ !!! *<1* !!! ][ 66 ][ 12 ][ --- ]]
|
||||
[[ signed char*->char ][ !!! *<1* !!! ][ 58 ][ 6 ][ 5 ]]
|
||||
[[ signed char*->signed char ][ !!! *<1* !!! ][ 59 ][ 6 ][ 7 ]]
|
||||
[[ signed char*->unsigned char ][ !!! *<1* !!! ][ 57 ][ 6 ][ 7 ]]
|
||||
[[ signed char*->int ][ !!! *4* !!! ][ 68 ][ 12 ][ 10 ]]
|
||||
[[ signed char*->short ][ !!! *4* !!! ][ 68 ][ 12 ][ 10 ]]
|
||||
[[ signed char*->long int ][ !!! *3* !!! ][ 69 ][ 12 ][ 10 ]]
|
||||
[[ signed char*->long long ][ !!! *3* !!! ][ 61 ][ 12 ][ 11 ]]
|
||||
[[ signed char*->unsigned int ][ !!! *3* !!! ][ 59 ][ 11 ][ 10 ]]
|
||||
[[ signed char*->unsigned short ][ !!! *3* !!! ][ 58 ][ 11 ][ 10 ]]
|
||||
[[ signed char*->unsigned long int ][ !!! *3* !!! ][ 59 ][ 12 ][ 10 ]]
|
||||
[[ signed char*->unsigned long long ][ !!! *3* !!! ][ 68 ][ 12 ][ 10 ]]
|
||||
[[ signed char*->float ][ 55 ][ 93 ][ 39 ][ !!! *22* !!! ]]
|
||||
[[ signed char*->double ][ 56 ][ 95 ][ 34 ][ !!! *23* !!! ]]
|
||||
[[ signed char*->long double ][ 58 ][ 89 ][ 32 ][ !!! *23* !!! ]]
|
||||
[[ signed char*->array<char, 50> ][ !!! *<1* !!! ][ 70 ][ 11 ][ 8 ]]
|
||||
[[ signed char*->string ][ !!! *1* !!! ][ 64 ][ 15 ][ --- ]]
|
||||
[[ signed char*->container::string ][ !!! *1* !!! ][ 67 ][ 13 ][ --- ]]
|
||||
[[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 62 ][ 6 ][ 7 ]]
|
||||
[[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 56 ][ 6 ][ 8 ]]
|
||||
[[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 57 ][ 5 ][ 11 ]]
|
||||
[[ iterator_range<char*>->int ][ !!! *4* !!! ][ 75 ][ 16 ][ 12 ]]
|
||||
[[ iterator_range<char*>->short ][ !!! *3* !!! ][ 69 ][ 16 ][ 12 ]]
|
||||
[[ iterator_range<char*>->long int ][ !!! *3* !!! ][ 66 ][ 21 ][ 12 ]]
|
||||
[[ iterator_range<char*>->long long ][ !!! *3* !!! ][ 70 ][ 15 ][ 12 ]]
|
||||
[[ iterator_range<char*>->unsigned int ][ !!! *3* !!! ][ 67 ][ 16 ][ 12 ]]
|
||||
[[ iterator_range<char*>->unsigned short ][ !!! *3* !!! ][ 64 ][ 14 ][ 12 ]]
|
||||
[[ iterator_range<char*>->unsigned long int ][ !!! *3* !!! ][ 66 ][ 15 ][ 12 ]]
|
||||
[[ iterator_range<char*>->unsigned long long ][ !!! *3* !!! ][ 72 ][ 17 ][ 12 ]]
|
||||
[[ iterator_range<char*>->float ][ 55 ][ 100 ][ 42 ][ !!! *23* !!! ]]
|
||||
[[ iterator_range<char*>->double ][ 54 ][ 100 ][ 40 ][ !!! *23* !!! ]]
|
||||
[[ iterator_range<char*>->long double ][ 56 ][ 100 ][ 39 ][ !!! *25* !!! ]]
|
||||
[[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 69 ][ 20 ][ 10 ]]
|
||||
[[ iterator_range<char*>->string ][ !!! *1* !!! ][ 72 ][ 21 ][ --- ]]
|
||||
[[ iterator_range<char*>->container::string ][ !!! *<1* !!! ][ 82 ][ 21 ][ --- ]]
|
||||
[[ std::string_view->char ][ !!! *<1* !!! ][ 65 ][ 5 ][ 8 ]]
|
||||
[[ std::string_view->signed char ][ !!! *<1* !!! ][ 61 ][ 6 ][ 10 ]]
|
||||
[[ std::string_view->unsigned char ][ !!! *<1* !!! ][ 56 ][ 5 ][ 9 ]]
|
||||
[[ std::string_view->int ][ !!! *4* !!! ][ 59 ][ 12 ][ 14 ]]
|
||||
[[ std::string_view->short ][ !!! *4* !!! ][ 63 ][ 12 ][ 14 ]]
|
||||
[[ std::string_view->long int ][ !!! *4* !!! ][ 61 ][ 11 ][ 13 ]]
|
||||
[[ std::string_view->long long ][ !!! *4* !!! ][ 58 ][ 13 ][ 14 ]]
|
||||
[[ std::string_view->unsigned int ][ !!! *3* !!! ][ 65 ][ 10 ][ 13 ]]
|
||||
[[ std::string_view->unsigned short ][ !!! *3* !!! ][ 64 ][ 10 ][ 14 ]]
|
||||
[[ std::string_view->unsigned long int ][ !!! *3* !!! ][ 64 ][ 12 ][ 13 ]]
|
||||
[[ std::string_view->unsigned long long ][ !!! *3* !!! ][ 65 ][ 11 ][ 14 ]]
|
||||
[[ std::string_view->float ][ 55 ][ 89 ][ 35 ][ !!! *24* !!! ]]
|
||||
[[ std::string_view->double ][ 53 ][ 87 ][ 36 ][ !!! *25* !!! ]]
|
||||
[[ std::string_view->long double ][ 56 ][ 93 ][ 34 ][ !!! *28* !!! ]]
|
||||
[[ std::string_view->array<char, 50> ][ !!! *1* !!! ][ 64 ][ 10 ][ 11 ]]
|
||||
[[ std::string_view->string ][ !!! *1* !!! ][ 62 ][ 11 ][ --- ]]
|
||||
[[ std::string_view->container::string ][ !!! *1* !!! ][ 65 ][ 11 ][ --- ]]
|
||||
[[ array<char, 50>->char ][ !!! *<1* !!! ][ 54 ][ 6 ][ 5 ]]
|
||||
[[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 54 ][ 5 ][ 7 ]]
|
||||
[[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 53 ][ 6 ][ 6 ]]
|
||||
[[ array<char, 50>->int ][ !!! *2* !!! ][ 59 ][ 12 ][ 10 ]]
|
||||
[[ array<char, 50>->short ][ !!! *3* !!! ][ 58 ][ 12 ][ 10 ]]
|
||||
[[ array<char, 50>->long int ][ !!! *3* !!! ][ 57 ][ 12 ][ 10 ]]
|
||||
[[ array<char, 50>->long long ][ !!! *3* !!! ][ 60 ][ 12 ][ 10 ]]
|
||||
[[ array<char, 50>->unsigned int ][ !!! *3* !!! ][ 60 ][ 11 ][ 10 ]]
|
||||
[[ array<char, 50>->unsigned short ][ !!! *3* !!! ][ 58 ][ 11 ][ 10 ]]
|
||||
[[ array<char, 50>->unsigned long int ][ !!! *3* !!! ][ 61 ][ 11 ][ 10 ]]
|
||||
[[ array<char, 50>->unsigned long long ][ !!! *3* !!! ][ 59 ][ 12 ][ 10 ]]
|
||||
[[ array<char, 50>->float ][ 52 ][ 89 ][ 35 ][ !!! *21* !!! ]]
|
||||
[[ array<char, 50>->double ][ 50 ][ 91 ][ 33 ][ !!! *21* !!! ]]
|
||||
[[ array<char, 50>->long double ][ 52 ][ 83 ][ 33 ][ !!! *23* !!! ]]
|
||||
[[ array<char, 50>->array<char, 50> ][ !!! *<1* !!! ][ 59 ][ 11 ][ 8 ]]
|
||||
[[ array<char, 50>->string ][ !!! *1* !!! ][ 66 ][ 13 ][ --- ]]
|
||||
[[ array<char, 50>->container::string ][ !!! *1* !!! ][ 61 ][ 12 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 61 ][ 14 ][ --- ]]
|
||||
[[ float->double ][ !!! *<1* !!! ][ 136 ][ 72 ][ --- ]]
|
||||
[[ char->signed char ][ !!! *<1* !!! ][ 54 ][ 5 ][ --- ]]
|
||||
]
|
||||
[endsect]
|
||||
|
||||
[section Clang version 15.0.7 ]
|
||||
[table:id Performance Table ( Clang version 15.0.7 )
|
||||
[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
|
||||
[[ string->char ][ !!! *<1* !!! ][ 68 ][ 5 ][ 6 ]]
|
||||
[[ string->signed char ][ !!! *<1* !!! ][ 59 ][ 5 ][ 7 ]]
|
||||
[[ string->unsigned char ][ !!! *<1* !!! ][ 59 ][ 5 ][ 7 ]]
|
||||
[[ string->int ][ !!! *3* !!! ][ 69 ][ 11 ][ 10 ]]
|
||||
[[ string->short ][ !!! *3* !!! ][ 64 ][ 11 ][ 10 ]]
|
||||
[[ string->long int ][ !!! *3* !!! ][ 65 ][ 11 ][ 10 ]]
|
||||
[[ string->long long ][ !!! *3* !!! ][ 68 ][ 13 ][ 10 ]]
|
||||
[[ string->unsigned int ][ !!! *3* !!! ][ 65 ][ 10 ][ 10 ]]
|
||||
[[ string->unsigned short ][ !!! *3* !!! ][ 64 ][ 10 ][ 10 ]]
|
||||
[[ string->unsigned long int ][ !!! *3* !!! ][ 62 ][ 11 ][ 10 ]]
|
||||
[[ string->unsigned long long ][ !!! *3* !!! ][ 64 ][ 11 ][ 10 ]]
|
||||
[[ string->float ][ 55 ][ 90 ][ 33 ][ !!! *22* !!! ]]
|
||||
[[ string->double ][ 56 ][ 89 ][ 32 ][ !!! *22* !!! ]]
|
||||
[[ string->long double ][ 55 ][ 92 ][ 32 ][ !!! *23* !!! ]]
|
||||
[[ string->array<char, 50> ][ !!! *<1* !!! ][ 66 ][ 10 ][ 8 ]]
|
||||
[[ string->string ][ !!! *1* !!! ][ 66 ][ 12 ][ --- ]]
|
||||
[[ string->container::string ][ !!! *<1* !!! ][ 66 ][ 15 ][ --- ]]
|
||||
[[ string->char ][ !!! *<1* !!! ][ 61 ][ 9 ][ 1 ]]
|
||||
[[ string->signed char ][ !!! *<1* !!! ][ 62 ][ 9 ][ 10 ]]
|
||||
[[ string->unsigned char ][ !!! *<1* !!! ][ 59 ][ 9 ][ 10 ]]
|
||||
[[ int->string ][ !!! *4* !!! ][ 63 ][ 13 ][ 9 ]]
|
||||
[[ short->string ][ !!! *4* !!! ][ 69 ][ 13 ][ 10 ]]
|
||||
[[ long int->string ][ !!! *4* !!! ][ 67 ][ 13 ][ 10 ]]
|
||||
[[ long long->string ][ !!! *4* !!! ][ 65 ][ 13 ][ 10 ]]
|
||||
[[ unsigned int->string ][ !!! *4* !!! ][ 66 ][ 13 ][ 10 ]]
|
||||
[[ unsigned short->string ][ !!! *4* !!! ][ 67 ][ 13 ][ 10 ]]
|
||||
[[ unsigned long int->string ][ !!! *4* !!! ][ 66 ][ 12 ][ 10 ]]
|
||||
[[ unsigned long long->string ][ !!! *4* !!! ][ 67 ][ 13 ][ 10 ]]
|
||||
[[ float->string ][ 25 ][ 108 ][ 47 ][ !!! *22* !!! ]]
|
||||
[[ double->string ][ !!! *32* !!! ][ 130 ][ 116 ][ 56 ]]
|
||||
[[ long double->string ][ 103 ][ 266 ][ 123 ][ !!! *64* !!! ]]
|
||||
[[ char*->char ][ !!! *<1* !!! ][ 129 ][ 13 ][ 14 ]]
|
||||
[[ char*->signed char ][ !!! *<1* !!! ][ 131 ][ 13 ][ 17 ]]
|
||||
[[ char*->unsigned char ][ !!! *<1* !!! ][ 133 ][ 13 ][ 17 ]]
|
||||
[[ char*->int ][ !!! *7* !!! ][ 154 ][ 32 ][ 26 ]]
|
||||
[[ char*->short ][ !!! *7* !!! ][ 161 ][ 29 ][ 27 ]]
|
||||
[[ char*->long int ][ !!! *7* !!! ][ 159 ][ 30 ][ 27 ]]
|
||||
[[ char*->long long ][ !!! *7* !!! ][ 158 ][ 28 ][ 26 ]]
|
||||
[[ char*->unsigned int ][ !!! *7* !!! ][ 146 ][ 26 ][ 26 ]]
|
||||
[[ char*->unsigned short ][ !!! *7* !!! ][ 150 ][ 26 ][ 26 ]]
|
||||
[[ char*->unsigned long int ][ !!! *7* !!! ][ 159 ][ 28 ][ 26 ]]
|
||||
[[ char*->unsigned long long ][ !!! *7* !!! ][ 158 ][ 30 ][ 27 ]]
|
||||
[[ char*->float ][ 123 ][ 207 ][ 78 ][ !!! *54* !!! ]]
|
||||
[[ char*->double ][ 135 ][ 218 ][ 77 ][ !!! *54* !!! ]]
|
||||
[[ char*->long double ][ 130 ][ 216 ][ 82 ][ !!! *59* !!! ]]
|
||||
[[ char*->array<char, 50> ][ !!! *<1* !!! ][ 153 ][ 25 ][ 21 ]]
|
||||
[[ char*->string ][ !!! *2* !!! ][ 159 ][ 31 ][ --- ]]
|
||||
[[ char*->container::string ][ !!! *3* !!! ][ 151 ][ 15 ][ --- ]]
|
||||
[[ unsigned char*->char ][ !!! *<1* !!! ][ 56 ][ 5 ][ 6 ]]
|
||||
[[ unsigned char*->signed char ][ !!! *<1* !!! ][ 58 ][ 5 ][ 7 ]]
|
||||
[[ unsigned char*->unsigned char ][ !!! *<1* !!! ][ 59 ][ 5 ][ 7 ]]
|
||||
[[ unsigned char*->int ][ !!! *3* !!! ][ 58 ][ 12 ][ 11 ]]
|
||||
[[ unsigned char*->short ][ !!! *3* !!! ][ 67 ][ 12 ][ 11 ]]
|
||||
[[ unsigned char*->long int ][ !!! *3* !!! ][ 67 ][ 12 ][ 11 ]]
|
||||
[[ unsigned char*->long long ][ !!! *3* !!! ][ 70 ][ 11 ][ 11 ]]
|
||||
[[ unsigned char*->unsigned int ][ !!! *3* !!! ][ 60 ][ 10 ][ 10 ]]
|
||||
[[ unsigned char*->unsigned short ][ !!! *3* !!! ][ 65 ][ 10 ][ 11 ]]
|
||||
[[ unsigned char*->unsigned long int ][ !!! *3* !!! ][ 61 ][ 11 ][ 10 ]]
|
||||
[[ unsigned char*->unsigned long long ][ !!! *3* !!! ][ 58 ][ 11 ][ 10 ]]
|
||||
[[ unsigned char*->float ][ 51 ][ 88 ][ 32 ][ !!! *22* !!! ]]
|
||||
[[ unsigned char*->double ][ 54 ][ 88 ][ 32 ][ !!! *22* !!! ]]
|
||||
[[ unsigned char*->long double ][ 51 ][ 88 ][ 35 ][ !!! *24* !!! ]]
|
||||
[[ unsigned char*->array<char, 50> ][ !!! *<1* !!! ][ 127 ][ 26 ][ 21 ]]
|
||||
[[ unsigned char*->string ][ !!! *2* !!! ][ 90 ][ 11 ][ --- ]]
|
||||
[[ unsigned char*->container::string ][ !!! *1* !!! ][ 62 ][ 15 ][ --- ]]
|
||||
[[ signed char*->char ][ !!! *<1* !!! ][ 52 ][ 5 ][ 5 ]]
|
||||
[[ signed char*->signed char ][ !!! *<1* !!! ][ 53 ][ 5 ][ 7 ]]
|
||||
[[ signed char*->unsigned char ][ !!! *<1* !!! ][ 52 ][ 5 ][ 7 ]]
|
||||
[[ signed char*->int ][ !!! *3* !!! ][ 60 ][ 12 ][ 11 ]]
|
||||
[[ signed char*->short ][ !!! *3* !!! ][ 63 ][ 12 ][ 11 ]]
|
||||
[[ signed char*->long int ][ !!! *3* !!! ][ 63 ][ 11 ][ 11 ]]
|
||||
[[ signed char*->long long ][ !!! *3* !!! ][ 64 ][ 11 ][ 11 ]]
|
||||
[[ signed char*->unsigned int ][ !!! *3* !!! ][ 60 ][ 10 ][ 10 ]]
|
||||
[[ signed char*->unsigned short ][ !!! *3* !!! ][ 59 ][ 10 ][ 10 ]]
|
||||
[[ signed char*->unsigned long int ][ !!! *2* !!! ][ 62 ][ 11 ][ 10 ]]
|
||||
[[ signed char*->unsigned long long ][ !!! *3* !!! ][ 66 ][ 11 ][ 10 ]]
|
||||
[[ signed char*->float ][ 51 ][ 86 ][ 32 ][ !!! *22* !!! ]]
|
||||
[[ signed char*->double ][ 55 ][ 87 ][ 32 ][ !!! *22* !!! ]]
|
||||
[[ signed char*->long double ][ 55 ][ 86 ][ 32 ][ !!! *24* !!! ]]
|
||||
[[ signed char*->array<char, 50> ][ !!! *<1* !!! ][ 64 ][ 10 ][ 8 ]]
|
||||
[[ signed char*->string ][ !!! *1* !!! ][ 62 ][ 12 ][ --- ]]
|
||||
[[ signed char*->container::string ][ !!! *1* !!! ][ 66 ][ 15 ][ --- ]]
|
||||
[[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 53 ][ 5 ][ 5 ]]
|
||||
[[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 55 ][ 5 ][ 7 ]]
|
||||
[[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 57 ][ 5 ][ 7 ]]
|
||||
[[ iterator_range<char*>->int ][ !!! *3* !!! ][ 67 ][ 15 ][ 11 ]]
|
||||
[[ iterator_range<char*>->short ][ !!! *3* !!! ][ 96 ][ 37 ][ 27 ]]
|
||||
[[ iterator_range<char*>->long int ][ !!! *7* !!! ][ 166 ][ 37 ][ 27 ]]
|
||||
[[ iterator_range<char*>->long long ][ !!! *7* !!! ][ 150 ][ 37 ][ 26 ]]
|
||||
[[ iterator_range<char*>->unsigned int ][ !!! *7* !!! ][ 158 ][ 34 ][ 26 ]]
|
||||
[[ iterator_range<char*>->unsigned short ][ !!! *7* !!! ][ 170 ][ 36 ][ 26 ]]
|
||||
[[ iterator_range<char*>->unsigned long int ][ !!! *7* !!! ][ 154 ][ 35 ][ 26 ]]
|
||||
[[ iterator_range<char*>->unsigned long long ][ !!! *7* !!! ][ 158 ][ 36 ][ 26 ]]
|
||||
[[ iterator_range<char*>->float ][ 122 ][ 233 ][ 100 ][ !!! *54* !!! ]]
|
||||
[[ iterator_range<char*>->double ][ 134 ][ 245 ][ 97 ][ !!! *54* !!! ]]
|
||||
[[ iterator_range<char*>->long double ][ 127 ][ 238 ][ 98 ][ !!! *59* !!! ]]
|
||||
[[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 159 ][ 42 ][ 21 ]]
|
||||
[[ iterator_range<char*>->string ][ !!! *2* !!! ][ 165 ][ 50 ][ --- ]]
|
||||
[[ iterator_range<char*>->container::string ][ !!! *1* !!! ][ 186 ][ 58 ][ --- ]]
|
||||
[[ std::string_view->char ][ !!! *<1* !!! ][ 130 ][ 12 ][ 14 ]]
|
||||
[[ std::string_view->signed char ][ !!! *<1* !!! ][ 128 ][ 12 ][ 18 ]]
|
||||
[[ std::string_view->unsigned char ][ !!! *<1* !!! ][ 134 ][ 12 ][ 17 ]]
|
||||
[[ std::string_view->int ][ !!! *7* !!! ][ 153 ][ 31 ][ 27 ]]
|
||||
[[ std::string_view->short ][ !!! *7* !!! ][ 148 ][ 29 ][ 26 ]]
|
||||
[[ std::string_view->long int ][ !!! *7* !!! ][ 150 ][ 28 ][ 26 ]]
|
||||
[[ std::string_view->long long ][ !!! *7* !!! ][ 116 ][ 11 ][ 10 ]]
|
||||
[[ std::string_view->unsigned int ][ !!! *2* !!! ][ 57 ][ 10 ][ 10 ]]
|
||||
[[ std::string_view->unsigned short ][ !!! *3* !!! ][ 57 ][ 10 ][ 10 ]]
|
||||
[[ std::string_view->unsigned long int ][ !!! *2* !!! ][ 66 ][ 11 ][ 10 ]]
|
||||
[[ std::string_view->unsigned long long ][ !!! *2* !!! ][ 61 ][ 11 ][ 10 ]]
|
||||
[[ std::string_view->float ][ 52 ][ 90 ][ 31 ][ !!! *22* !!! ]]
|
||||
[[ std::string_view->double ][ 56 ][ 92 ][ 31 ][ !!! *22* !!! ]]
|
||||
[[ std::string_view->long double ][ 56 ][ 95 ][ 32 ][ !!! *24* !!! ]]
|
||||
[[ std::string_view->array<char, 50> ][ !!! *<1* !!! ][ 65 ][ 10 ][ 8 ]]
|
||||
[[ std::string_view->string ][ !!! *1* !!! ][ 60 ][ 12 ][ --- ]]
|
||||
[[ std::string_view->container::string ][ !!! *2* !!! ][ 67 ][ 14 ][ --- ]]
|
||||
[[ array<char, 50>->char ][ !!! *<1* !!! ][ 53 ][ 5 ][ 6 ]]
|
||||
[[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 54 ][ 5 ][ 7 ]]
|
||||
[[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 53 ][ 5 ][ 7 ]]
|
||||
[[ array<char, 50>->int ][ !!! *3* !!! ][ 63 ][ 12 ][ 11 ]]
|
||||
[[ array<char, 50>->short ][ !!! *3* !!! ][ 62 ][ 12 ][ 11 ]]
|
||||
[[ array<char, 50>->long int ][ !!! *3* !!! ][ 63 ][ 11 ][ 11 ]]
|
||||
[[ array<char, 50>->long long ][ !!! *3* !!! ][ 60 ][ 11 ][ 11 ]]
|
||||
[[ array<char, 50>->unsigned int ][ !!! *3* !!! ][ 57 ][ 10 ][ 11 ]]
|
||||
[[ array<char, 50>->unsigned short ][ !!! *3* !!! ][ 65 ][ 11 ][ 11 ]]
|
||||
[[ array<char, 50>->unsigned long int ][ !!! *3* !!! ][ 69 ][ 11 ][ 11 ]]
|
||||
[[ array<char, 50>->unsigned long long ][ !!! *3* !!! ][ 68 ][ 11 ][ 10 ]]
|
||||
[[ array<char, 50>->float ][ 54 ][ 82 ][ 32 ][ !!! *22* !!! ]]
|
||||
[[ array<char, 50>->double ][ 57 ][ 93 ][ 32 ][ !!! *22* !!! ]]
|
||||
[[ array<char, 50>->long double ][ 53 ][ 85 ][ 32 ][ !!! *23* !!! ]]
|
||||
[[ array<char, 50>->array<char, 50> ][ !!! *<1* !!! ][ 60 ][ 10 ][ 8 ]]
|
||||
[[ array<char, 50>->string ][ !!! *1* !!! ][ 61 ][ 11 ][ --- ]]
|
||||
[[ array<char, 50>->container::string ][ !!! *1* !!! ][ 62 ][ 15 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 65 ][ 15 ][ --- ]]
|
||||
[[ float->double ][ !!! *<1* !!! ][ 138 ][ 68 ][ --- ]]
|
||||
[[ char->signed char ][ !!! *<1* !!! ][ 53 ][ 5 ][ --- ]]
|
||||
]
|
||||
[endsect]
|
||||
|
||||
[section GNU C++ version 10.5.0]
|
||||
[table:id Performance Table ( GNU C++ version 10.5.0)
|
||||
[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
|
||||
[[ string->char ][ !!! *<1* !!! ][ 64 ][ 5 ][ 5 ]]
|
||||
[[ string->signed char ][ !!! *<1* !!! ][ 51 ][ 5 ][ 7 ]]
|
||||
[[ string->unsigned char ][ !!! *<1* !!! ][ 53 ][ 5 ][ 6 ]]
|
||||
[[ string->int ][ !!! *3* !!! ][ 56 ][ 11 ][ 10 ]]
|
||||
[[ string->short ][ !!! *3* !!! ][ 56 ][ 12 ][ 10 ]]
|
||||
[[ string->long int ][ !!! *3* !!! ][ 58 ][ 13 ][ 10 ]]
|
||||
[[ string->long long ][ !!! *3* !!! ][ 56 ][ 13 ][ 10 ]]
|
||||
[[ string->unsigned int ][ !!! *3* !!! ][ 60 ][ 10 ][ 10 ]]
|
||||
[[ string->unsigned short ][ !!! *3* !!! ][ 58 ][ 10 ][ 10 ]]
|
||||
[[ string->unsigned long int ][ !!! *3* !!! ][ 59 ][ 12 ][ 10 ]]
|
||||
[[ string->unsigned long long ][ !!! *3* !!! ][ 53 ][ 11 ][ 10 ]]
|
||||
[[ string->float ][ 49 ][ 81 ][ 34 ][ !!! *21* !!! ]]
|
||||
[[ string->double ][ 45 ][ 75 ][ 28 ][ !!! *21* !!! ]]
|
||||
[[ string->long double ][ 46 ][ 76 ][ 30 ][ !!! *25* !!! ]]
|
||||
[[ string->array<char, 50> ][ !!! *<1* !!! ][ 55 ][ 10 ][ 10 ]]
|
||||
[[ string->string ][ !!! *1* !!! ][ 54 ][ 11 ][ --- ]]
|
||||
[[ string->container::string ][ !!! *<1* !!! ][ 57 ][ 11 ][ --- ]]
|
||||
[[ string->char ][ !!! *<1* !!! ][ 51 ][ 9 ][ 7 ]]
|
||||
[[ string->signed char ][ !!! *<1* !!! ][ 51 ][ 10 ][ 10 ]]
|
||||
[[ string->unsigned char ][ !!! *<1* !!! ][ 53 ][ 10 ][ 10 ]]
|
||||
[[ int->string ][ !!! *3* !!! ][ 55 ][ 12 ][ 10 ]]
|
||||
[[ short->string ][ !!! *3* !!! ][ 55 ][ 13 ][ 10 ]]
|
||||
[[ long int->string ][ !!! *3* !!! ][ 55 ][ 12 ][ 10 ]]
|
||||
[[ long long->string ][ !!! *3* !!! ][ 56 ][ 12 ][ 10 ]]
|
||||
[[ unsigned int->string ][ !!! *3* !!! ][ 54 ][ 12 ][ 10 ]]
|
||||
[[ unsigned short->string ][ !!! *3* !!! ][ 54 ][ 12 ][ 10 ]]
|
||||
[[ unsigned long int->string ][ !!! *3* !!! ][ 55 ][ 12 ][ 10 ]]
|
||||
[[ unsigned long long->string ][ !!! *3* !!! ][ 55 ][ 12 ][ 10 ]]
|
||||
[[ float->string ][ 26 ][ 96 ][ 46 ][ !!! *25* !!! ]]
|
||||
[[ double->string ][ 33 ][ 94 ][ 46 ][ !!! *23* !!! ]]
|
||||
[[ long double->string ][ 44 ][ 96 ][ 52 ][ !!! *26* !!! ]]
|
||||
[[ char*->char ][ !!! *<1* !!! ][ 48 ][ 5 ][ 5 ]]
|
||||
[[ char*->signed char ][ !!! *<1* !!! ][ 47 ][ 5 ][ 7 ]]
|
||||
[[ char*->unsigned char ][ !!! *<1* !!! ][ 47 ][ 5 ][ 6 ]]
|
||||
[[ char*->int ][ !!! *3* !!! ][ 57 ][ 12 ][ 10 ]]
|
||||
[[ char*->short ][ !!! *3* !!! ][ 55 ][ 12 ][ 10 ]]
|
||||
[[ char*->long int ][ !!! *3* !!! ][ 59 ][ 11 ][ 10 ]]
|
||||
[[ char*->long long ][ !!! *4* !!! ][ 61 ][ 11 ][ 10 ]]
|
||||
[[ char*->unsigned int ][ !!! *3* !!! ][ 53 ][ 10 ][ 10 ]]
|
||||
[[ char*->unsigned short ][ !!! *3* !!! ][ 53 ][ 10 ][ 10 ]]
|
||||
[[ char*->unsigned long int ][ !!! *3* !!! ][ 54 ][ 11 ][ 10 ]]
|
||||
[[ char*->unsigned long long ][ !!! *3* !!! ][ 55 ][ 11 ][ 10 ]]
|
||||
[[ char*->float ][ 46 ][ 78 ][ 39 ][ !!! *21* !!! ]]
|
||||
[[ char*->double ][ 43 ][ 73 ][ 28 ][ !!! *21* !!! ]]
|
||||
[[ char*->long double ][ 46 ][ 74 ][ 30 ][ !!! *23* !!! ]]
|
||||
[[ char*->array<char, 50> ][ !!! *<1* !!! ][ 52 ][ 10 ][ 8 ]]
|
||||
[[ char*->string ][ !!! *1* !!! ][ 58 ][ 11 ][ --- ]]
|
||||
[[ char*->container::string ][ !!! *<1* !!! ][ 64 ][ 11 ][ --- ]]
|
||||
[[ unsigned char*->char ][ !!! *<1* !!! ][ 47 ][ 5 ][ 5 ]]
|
||||
[[ unsigned char*->signed char ][ !!! *<1* !!! ][ 47 ][ 5 ][ 7 ]]
|
||||
[[ unsigned char*->unsigned char ][ !!! *<1* !!! ][ 47 ][ 5 ][ 7 ]]
|
||||
[[ unsigned char*->int ][ !!! *3* !!! ][ 55 ][ 12 ][ 12 ]]
|
||||
[[ unsigned char*->short ][ !!! *4* !!! ][ 59 ][ 11 ][ 10 ]]
|
||||
[[ unsigned char*->long int ][ !!! *3* !!! ][ 56 ][ 12 ][ 10 ]]
|
||||
[[ unsigned char*->long long ][ !!! *3* !!! ][ 55 ][ 12 ][ 10 ]]
|
||||
[[ unsigned char*->unsigned int ][ !!! *3* !!! ][ 53 ][ 10 ][ 10 ]]
|
||||
[[ unsigned char*->unsigned short ][ !!! *3* !!! ][ 54 ][ 10 ][ 10 ]]
|
||||
[[ unsigned char*->unsigned long int ][ !!! *3* !!! ][ 54 ][ 11 ][ 10 ]]
|
||||
[[ unsigned char*->unsigned long long ][ !!! *3* !!! ][ 55 ][ 11 ][ 10 ]]
|
||||
[[ unsigned char*->float ][ 100 ][ 143 ][ 33 ][ !!! *21* !!! ]]
|
||||
[[ unsigned char*->double ][ 44 ][ 73 ][ 28 ][ !!! *22* !!! ]]
|
||||
[[ unsigned char*->long double ][ 46 ][ 75 ][ 30 ][ !!! *23* !!! ]]
|
||||
[[ unsigned char*->array<char, 50> ][ !!! *<1* !!! ][ 53 ][ 11 ][ 8 ]]
|
||||
[[ unsigned char*->string ][ !!! *1* !!! ][ 58 ][ 11 ][ --- ]]
|
||||
[[ unsigned char*->container::string ][ !!! *<1* !!! ][ 59 ][ 11 ][ --- ]]
|
||||
[[ signed char*->char ][ !!! *<1* !!! ][ 47 ][ 5 ][ 5 ]]
|
||||
[[ signed char*->signed char ][ !!! *<1* !!! ][ 47 ][ 5 ][ 7 ]]
|
||||
[[ signed char*->unsigned char ][ !!! *<1* !!! ][ 51 ][ 5 ][ 6 ]]
|
||||
[[ signed char*->int ][ !!! *3* !!! ][ 55 ][ 12 ][ 10 ]]
|
||||
[[ signed char*->short ][ !!! *4* !!! ][ 56 ][ 12 ][ 10 ]]
|
||||
[[ signed char*->long int ][ !!! *4* !!! ][ 56 ][ 11 ][ 10 ]]
|
||||
[[ signed char*->long long ][ !!! *3* !!! ][ 55 ][ 11 ][ 10 ]]
|
||||
[[ signed char*->unsigned int ][ !!! *3* !!! ][ 60 ][ 10 ][ 10 ]]
|
||||
[[ signed char*->unsigned short ][ !!! *3* !!! ][ 53 ][ 10 ][ 10 ]]
|
||||
[[ signed char*->unsigned long int ][ !!! *3* !!! ][ 54 ][ 11 ][ 10 ]]
|
||||
[[ signed char*->unsigned long long ][ !!! *6* !!! ][ 58 ][ 11 ][ 10 ]]
|
||||
[[ signed char*->float ][ 47 ][ 76 ][ 32 ][ !!! *21* !!! ]]
|
||||
[[ signed char*->double ][ 44 ][ 73 ][ 29 ][ !!! *21* !!! ]]
|
||||
[[ signed char*->long double ][ 45 ][ 74 ][ 31 ][ !!! *24* !!! ]]
|
||||
[[ signed char*->array<char, 50> ][ !!! *<1* !!! ][ 52 ][ 11 ][ 8 ]]
|
||||
[[ signed char*->string ][ !!! *1* !!! ][ 58 ][ 11 ][ --- ]]
|
||||
[[ signed char*->container::string ][ !!! *<1* !!! ][ 59 ][ 11 ][ --- ]]
|
||||
[[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 47 ][ 5 ][ 5 ]]
|
||||
[[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 47 ][ 5 ][ 7 ]]
|
||||
[[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 53 ][ 5 ][ 6 ]]
|
||||
[[ iterator_range<char*>->int ][ !!! *3* !!! ][ 58 ][ 15 ][ 10 ]]
|
||||
[[ iterator_range<char*>->short ][ !!! *3* !!! ][ 59 ][ 16 ][ 10 ]]
|
||||
[[ iterator_range<char*>->long int ][ !!! *3* !!! ][ 58 ][ 15 ][ 10 ]]
|
||||
[[ iterator_range<char*>->long long ][ !!! *3* !!! ][ 59 ][ 15 ][ 10 ]]
|
||||
[[ iterator_range<char*>->unsigned int ][ !!! *3* !!! ][ 56 ][ 14 ][ 10 ]]
|
||||
[[ iterator_range<char*>->unsigned short ][ !!! *3* !!! ][ 61 ][ 14 ][ 10 ]]
|
||||
[[ iterator_range<char*>->unsigned long int ][ !!! *3* !!! ][ 58 ][ 14 ][ 10 ]]
|
||||
[[ iterator_range<char*>->unsigned long long ][ !!! *3* !!! ][ 71 ][ 36 ][ 25 ]]
|
||||
[[ iterator_range<char*>->float ][ 116 ][ 93 ][ 39 ][ !!! *21* !!! ]]
|
||||
[[ iterator_range<char*>->double ][ 43 ][ 81 ][ 34 ][ !!! *21* !!! ]]
|
||||
[[ iterator_range<char*>->long double ][ 44 ][ 87 ][ 37 ][ !!! *24* !!! ]]
|
||||
[[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 58 ][ 17 ][ 8 ]]
|
||||
[[ iterator_range<char*>->string ][ !!! *1* !!! ][ 63 ][ 20 ][ --- ]]
|
||||
[[ iterator_range<char*>->container::string ][ !!! *<1* !!! ][ 65 ][ 20 ][ --- ]]
|
||||
[[ std::string_view->char ][ !!! *<1* !!! ][ 46 ][ 5 ][ 5 ]]
|
||||
[[ std::string_view->signed char ][ !!! *<1* !!! ][ 47 ][ 5 ][ 7 ]]
|
||||
[[ std::string_view->unsigned char ][ !!! *<1* !!! ][ 47 ][ 5 ][ 7 ]]
|
||||
[[ std::string_view->int ][ !!! *4* !!! ][ 56 ][ 11 ][ 10 ]]
|
||||
[[ std::string_view->short ][ !!! *3* !!! ][ 55 ][ 12 ][ 10 ]]
|
||||
[[ std::string_view->long int ][ !!! *4* !!! ][ 54 ][ 11 ][ 10 ]]
|
||||
[[ std::string_view->long long ][ !!! *4* !!! ][ 54 ][ 11 ][ 10 ]]
|
||||
[[ std::string_view->unsigned int ][ !!! *3* !!! ][ 53 ][ 10 ][ 10 ]]
|
||||
[[ std::string_view->unsigned short ][ !!! *3* !!! ][ 54 ][ 10 ][ 10 ]]
|
||||
[[ std::string_view->unsigned long int ][ !!! *3* !!! ][ 54 ][ 11 ][ 10 ]]
|
||||
[[ std::string_view->unsigned long long ][ !!! *3* !!! ][ 55 ][ 11 ][ 10 ]]
|
||||
[[ std::string_view->float ][ 47 ][ 76 ][ 32 ][ !!! *22* !!! ]]
|
||||
[[ std::string_view->double ][ 43 ][ 74 ][ 28 ][ !!! *21* !!! ]]
|
||||
[[ std::string_view->long double ][ 46 ][ 75 ][ 31 ][ !!! *24* !!! ]]
|
||||
[[ std::string_view->array<char, 50> ][ !!! *1* !!! ][ 51 ][ 10 ][ 8 ]]
|
||||
[[ std::string_view->string ][ !!! *2* !!! ][ 53 ][ 10 ][ --- ]]
|
||||
[[ std::string_view->container::string ][ !!! *1* !!! ][ 56 ][ 11 ][ --- ]]
|
||||
[[ array<char, 50>->char ][ !!! *<1* !!! ][ 47 ][ 5 ][ 5 ]]
|
||||
[[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 47 ][ 5 ][ 6 ]]
|
||||
[[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 49 ][ 5 ][ 6 ]]
|
||||
[[ array<char, 50>->int ][ !!! *3* !!! ][ 54 ][ 12 ][ 10 ]]
|
||||
[[ array<char, 50>->short ][ !!! *3* !!! ][ 61 ][ 11 ][ 10 ]]
|
||||
[[ array<char, 50>->long int ][ !!! *3* !!! ][ 55 ][ 11 ][ 10 ]]
|
||||
[[ array<char, 50>->long long ][ !!! *3* !!! ][ 54 ][ 11 ][ 10 ]]
|
||||
[[ array<char, 50>->unsigned int ][ !!! *3* !!! ][ 53 ][ 10 ][ 10 ]]
|
||||
[[ array<char, 50>->unsigned short ][ !!! *3* !!! ][ 52 ][ 10 ][ 10 ]]
|
||||
[[ array<char, 50>->unsigned long int ][ !!! *3* !!! ][ 62 ][ 11 ][ 10 ]]
|
||||
[[ array<char, 50>->unsigned long long ][ !!! *3* !!! ][ 54 ][ 11 ][ 10 ]]
|
||||
[[ array<char, 50>->float ][ 45 ][ 75 ][ 35 ][ !!! *24* !!! ]]
|
||||
[[ array<char, 50>->double ][ 44 ][ 75 ][ 28 ][ !!! *21* !!! ]]
|
||||
[[ array<char, 50>->long double ][ 45 ][ 76 ][ 29 ][ !!! *24* !!! ]]
|
||||
[[ array<char, 50>->array<char, 50> ][ !!! *<1* !!! ][ 53 ][ 10 ][ 8 ]]
|
||||
[[ array<char, 50>->string ][ !!! *1* !!! ][ 54 ][ 11 ][ --- ]]
|
||||
[[ array<char, 50>->container::string ][ !!! *1* !!! ][ 56 ][ 12 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 58 ][ 13 ][ --- ]]
|
||||
[[ float->double ][ !!! *<1* !!! ][ 116 ][ 63 ][ --- ]]
|
||||
[[ char->signed char ][ !!! *<1* !!! ][ 47 ][ 5 ][ --- ]]
|
||||
]
|
||||
[endsect]
|
||||
|
||||
|
||||
|
||||
|
||||
[/ END of section, generated by performance measuring program ]
|
||||
[endsect]
|
||||
|
||||
@@ -1,36 +0,0 @@
|
||||
// Copyright Antony Polukhin, 2013-2026.
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See the accompanying file LICENSE_1_0.txt
|
||||
// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
|
||||
|
||||
//[lexical_cast_args_example
|
||||
//`The following example treats command line arguments as a sequence of numeric data
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
int main(int /*argc*/, char * argv[])
|
||||
{
|
||||
using boost::lexical_cast;
|
||||
using boost::bad_lexical_cast;
|
||||
|
||||
std::vector<short> args;
|
||||
|
||||
while (*++argv)
|
||||
{
|
||||
try
|
||||
{
|
||||
args.push_back(lexical_cast<short>(*argv));
|
||||
}
|
||||
catch(const bad_lexical_cast &)
|
||||
{
|
||||
args.push_back(0);
|
||||
}
|
||||
}
|
||||
|
||||
// ...
|
||||
}
|
||||
|
||||
//] [/lexical_cast_args_example]
|
||||
@@ -1,72 +0,0 @@
|
||||
// Copyright Antony Polukhin, 2013-2026.
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See the accompanying file LICENSE_1_0.txt
|
||||
// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(disable: 4512) // generic_stringize.cpp(37) : warning C4512: 'stringize_functor' : assignment operator could not be generated
|
||||
#endif
|
||||
|
||||
//[lexical_cast_stringize
|
||||
/*`
|
||||
In this example we'll make a `stringize` method that accepts a sequence, converts
|
||||
each element of the sequence into string and appends that string to the result.
|
||||
|
||||
Example is based on the example from the Boost C++ Application Development Cookbook
|
||||
by Antony Polukhin, ISBN 9781849514880. Russian translation: [@https://dmkpress.com/catalog/computer/programming/c/978-5-97060-868-5/ ISBN: 9785970608685].
|
||||
|
||||
Step 1: Making a functor that converts any type to a string and remembers result:
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
|
||||
#include <boost/fusion/include/for_each.hpp>
|
||||
#include <boost/fusion/adapted/std_tuple.hpp>
|
||||
#include <boost/fusion/adapted/std_pair.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
struct stringize_functor {
|
||||
private:
|
||||
std::string& result;
|
||||
|
||||
public:
|
||||
explicit stringize_functor(std::string& res)
|
||||
: result(res)
|
||||
{}
|
||||
|
||||
template <class T>
|
||||
void operator()(const T& v) const {
|
||||
result += boost::lexical_cast<std::string>(v);
|
||||
}
|
||||
};
|
||||
|
||||
//` Step 2: Applying `stringize_functor` to each element in sequence:
|
||||
template <class Sequence>
|
||||
std::string stringize(const Sequence& seq) {
|
||||
std::string result;
|
||||
boost::fusion::for_each(seq, stringize_functor(result));
|
||||
return result;
|
||||
}
|
||||
|
||||
//` Step 3: Using the `stringize` with different types:
|
||||
int main() {
|
||||
std::tuple<char, int, char, int> decim('-', 10, 'e', 5);
|
||||
if (stringize(decim) != "-10e5") {
|
||||
return 1;
|
||||
}
|
||||
|
||||
std::pair<int, std::string> value_and_type(270, "Kelvin");
|
||||
if (stringize(value_and_type) != "270Kelvin") {
|
||||
return 2;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
//] [/lexical_cast_stringize]
|
||||
|
||||
|
||||
|
||||
@@ -1,59 +0,0 @@
|
||||
// Copyright Antony Polukhin, 2013-2026.
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See the accompanying file LICENSE_1_0.txt
|
||||
// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
|
||||
|
||||
#include <array>
|
||||
#include <string>
|
||||
#include <string.h>
|
||||
#include <cstdio>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(disable: 4996) // `strerror` is not safe
|
||||
#endif
|
||||
|
||||
//[lexical_cast_log_errno
|
||||
//`The following example uses numeric data in a string expression:
|
||||
|
||||
void log_message(const std::string &);
|
||||
|
||||
void log_errno(int yoko)
|
||||
{
|
||||
log_message("Error " + boost::lexical_cast<std::string>(yoko) + ": " + strerror(yoko));
|
||||
}
|
||||
|
||||
//] [/lexical_cast_log_errno]
|
||||
|
||||
|
||||
//[lexical_cast_fixed_buffer
|
||||
//`The following example converts some number and puts it to file:
|
||||
|
||||
void number_to_file(int number, std::FILE* file)
|
||||
{
|
||||
using buf_t = std::array<char, 50>;
|
||||
buf_t buffer = boost::lexical_cast<buf_t>(number); // No dynamic memory allocation
|
||||
std::fputs(buffer.data(), file);
|
||||
}
|
||||
|
||||
//] [/lexical_cast_fixed_buffer]
|
||||
|
||||
//[lexical_cast_substring_conversion
|
||||
//`The following example takes part of the string and converts it to `int`:
|
||||
|
||||
int convert_strings_part(const std::string& s, std::size_t pos, std::size_t n)
|
||||
{
|
||||
return boost::lexical_cast<int>(s.data() + pos, n);
|
||||
}
|
||||
|
||||
//] [/lexical_cast_substring_conversion]
|
||||
|
||||
void log_message(const std::string &) {}
|
||||
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,46 +0,0 @@
|
||||
// Copyright Antony Polukhin, 2013-2026.
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See the accompanying file LICENSE_1_0.txt
|
||||
// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
|
||||
|
||||
|
||||
//[lexical_cast_variant_to_long_double
|
||||
/*`
|
||||
In this example we'll make a `to_long_double` method that converts value of the Boost.Variant to `long double`.
|
||||
*/
|
||||
|
||||
#ifdef BOOST_USE_MODULES
|
||||
#include <compare>
|
||||
#endif
|
||||
#include <boost/variant.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
struct to_long_double_functor: boost::static_visitor<long double> {
|
||||
template <class T>
|
||||
long double operator()(const T& v) const {
|
||||
// Lexical cast has many optimizations including optimizations for situations that usually
|
||||
// occur in generic programming, like std::string to std::string or arithmetic type to arithmetic type conversion.
|
||||
return boost::lexical_cast<long double>(v);
|
||||
}
|
||||
};
|
||||
|
||||
// Throws `boost::bad_lexical_cast` if value of the variant is not convertible to `long double`
|
||||
template <class Variant>
|
||||
long double to_long_double(const Variant& v) {
|
||||
return boost::apply_visitor(to_long_double_functor(), v);
|
||||
}
|
||||
|
||||
int main() {
|
||||
boost::variant<char, int, std::string> v1('0'), v2("10.0001"), v3(1);
|
||||
|
||||
const long double sum = to_long_double(v1) + to_long_double(v2) + to_long_double(v3);
|
||||
if (11 < sum && sum < 11.1) {
|
||||
return 0; // OK, as expected
|
||||
};
|
||||
|
||||
return 1; // FAIL
|
||||
}
|
||||
|
||||
//] [/lexical_cast_variant_to_long_double]
|
||||
@@ -0,0 +1,384 @@
|
||||
// boost cast.hpp header file ----------------------------------------------//
|
||||
|
||||
// (C) Copyright Kevlin Henney and Dave Abrahams 1999.
|
||||
// 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/conversion for Documentation.
|
||||
|
||||
// Revision History
|
||||
// 02 Apr 01 Removed BOOST_NO_LIMITS workarounds and included
|
||||
// <boost/limits.hpp> instead (the workaround did not
|
||||
// actually compile when BOOST_NO_LIMITS was defined in
|
||||
// any case, so we loose nothing). (John Maddock)
|
||||
// 21 Jan 01 Undid a bug I introduced yesterday. numeric_cast<> never
|
||||
// worked with stock GCC; trying to get it to do that broke
|
||||
// vc-stlport.
|
||||
// 20 Jan 01 Moved BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS to config.hpp.
|
||||
// Removed unused BOOST_EXPLICIT_TARGET macro. Moved
|
||||
// boost::detail::type to boost/type.hpp. Made it compile with
|
||||
// stock gcc again (Dave Abrahams)
|
||||
// 29 Nov 00 Remove nested namespace cast, cleanup spacing before Formal
|
||||
// Review (Beman Dawes)
|
||||
// 19 Oct 00 Fix numeric_cast for floating-point types (Dave Abrahams)
|
||||
// 15 Jul 00 Suppress numeric_cast warnings for GCC, Borland and MSVC
|
||||
// (Dave Abrahams)
|
||||
// 30 Jun 00 More MSVC6 wordarounds. See comments below. (Dave Abrahams)
|
||||
// 28 Jun 00 Removed implicit_cast<>. See comment below. (Beman Dawes)
|
||||
// 27 Jun 00 More MSVC6 workarounds
|
||||
// 15 Jun 00 Add workarounds for MSVC6
|
||||
// 2 Feb 00 Remove bad_numeric_cast ";" syntax error (Doncho Angelov)
|
||||
// 26 Jan 00 Add missing throw() to bad_numeric_cast::what(0 (Adam Levar)
|
||||
// 29 Dec 99 Change using declarations so usages in other namespaces work
|
||||
// correctly (Dave Abrahams)
|
||||
// 23 Sep 99 Change polymorphic_downcast assert to also detect M.I. errors
|
||||
// as suggested Darin Adler and improved by Valentin Bonnard.
|
||||
// 2 Sep 99 Remove controversial asserts, simplify, rename.
|
||||
// 30 Aug 99 Move to cast.hpp, replace value_cast with numeric_cast,
|
||||
// place in nested namespace.
|
||||
// 3 Aug 99 Initial version
|
||||
|
||||
#ifndef BOOST_CAST_HPP
|
||||
#define BOOST_CAST_HPP
|
||||
|
||||
# include <boost/config.hpp>
|
||||
# include <cassert>
|
||||
# include <typeinfo>
|
||||
# include <boost/type.hpp>
|
||||
# include <boost/limits.hpp>
|
||||
# include <boost/detail/select_type.hpp>
|
||||
|
||||
// It has been demonstrated numerous times that MSVC 6.0 fails silently at link
|
||||
// time if you use a template function which has template parameters that don't
|
||||
// appear in the function's argument list.
|
||||
//
|
||||
// TODO: Add this to config.hpp?
|
||||
# if defined(BOOST_MSVC) && BOOST_MSVC <= 1200 // 1200 = VC6
|
||||
# define BOOST_EXPLICIT_DEFAULT_TARGET , ::boost::type<Target>* = 0
|
||||
# else
|
||||
# define BOOST_EXPLICIT_DEFAULT_TARGET
|
||||
# endif
|
||||
|
||||
namespace boost
|
||||
{
|
||||
// See the documentation for descriptions of how to choose between
|
||||
// static_cast<>, dynamic_cast<>, polymorphic_cast<> and polymorphic_downcast<>
|
||||
|
||||
// polymorphic_cast --------------------------------------------------------//
|
||||
|
||||
// Runtime checked polymorphic downcasts and crosscasts.
|
||||
// Suggested in The C++ Programming Language, 3rd Ed, Bjarne Stroustrup,
|
||||
// section 15.8 exercise 1, page 425.
|
||||
|
||||
template <class Target, class Source>
|
||||
inline Target polymorphic_cast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET)
|
||||
{
|
||||
Target tmp = dynamic_cast<Target>(x);
|
||||
if ( tmp == 0 ) throw std::bad_cast();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
// polymorphic_downcast ----------------------------------------------------//
|
||||
|
||||
// assert() checked polymorphic downcast. Crosscasts prohibited.
|
||||
|
||||
// WARNING: Because this cast uses assert(), it violates the One Definition
|
||||
// Rule if NDEBUG is inconsistently defined across translation units.
|
||||
|
||||
// Contributed by Dave Abrahams
|
||||
|
||||
template <class Target, class Source>
|
||||
inline Target polymorphic_downcast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET)
|
||||
{
|
||||
assert( dynamic_cast<Target>(x) == x ); // detect logic error
|
||||
return static_cast<Target>(x);
|
||||
}
|
||||
|
||||
// implicit_cast -----------------------------------------------------------//
|
||||
//
|
||||
// Removed due to uncertain purpose. Use either numeric_cast (see below)
|
||||
// or static_cast according to the need.
|
||||
|
||||
// numeric_cast and related exception --------------------------------------//
|
||||
|
||||
// Contributed by Kevlin Henney
|
||||
|
||||
// bad_numeric_cast --------------------------------------------------------//
|
||||
|
||||
// exception used to indicate runtime numeric_cast failure
|
||||
class bad_numeric_cast : public std::bad_cast
|
||||
{
|
||||
public:
|
||||
// constructors, destructors and assignment operator defaulted
|
||||
|
||||
// function inlined for brevity and consistency with rest of library
|
||||
virtual const char *what() const throw()
|
||||
{
|
||||
return "bad numeric cast: loss of range in numeric_cast";
|
||||
}
|
||||
};
|
||||
|
||||
// numeric_cast ------------------------------------------------------------//
|
||||
|
||||
#if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || defined(BOOST_SGI_CPP_LIMITS)
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <class T>
|
||||
struct signed_numeric_limits : std::numeric_limits<T>
|
||||
{
|
||||
static inline T min BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
||||
{
|
||||
return (std::numeric_limits<T>::min)() >= 0
|
||||
// unary minus causes integral promotion, thus the static_cast<>
|
||||
? static_cast<T>(-(std::numeric_limits<T>::max)())
|
||||
: (std::numeric_limits<T>::min)();
|
||||
};
|
||||
};
|
||||
|
||||
// Move to namespace boost in utility.hpp?
|
||||
template <class T, bool specialized>
|
||||
struct fixed_numeric_limits_base
|
||||
: public if_true< std::numeric_limits<T>::is_signed >
|
||||
::BOOST_NESTED_TEMPLATE then< signed_numeric_limits<T>,
|
||||
std::numeric_limits<T>
|
||||
>::type
|
||||
{};
|
||||
|
||||
template <class T>
|
||||
struct fixed_numeric_limits
|
||||
: fixed_numeric_limits_base<T,(std::numeric_limits<T>::is_specialized)>
|
||||
{};
|
||||
|
||||
# ifdef BOOST_HAS_LONG_LONG
|
||||
// cover implementations which supply no specialization for long
|
||||
// long / unsigned long long. Not intended to be full
|
||||
// numeric_limits replacements, but good enough for numeric_cast<>
|
||||
template <>
|
||||
struct fixed_numeric_limits_base< ::boost::long_long_type, false>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, is_specialized = true);
|
||||
BOOST_STATIC_CONSTANT(bool, is_signed = true);
|
||||
static ::boost::long_long_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
||||
{
|
||||
# ifdef LONGLONG_MAX
|
||||
return LONGLONG_MAX;
|
||||
# else
|
||||
return 9223372036854775807LL; // hope this is portable
|
||||
# endif
|
||||
}
|
||||
|
||||
static ::boost::long_long_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
||||
{
|
||||
# ifdef LONGLONG_MIN
|
||||
return LONGLONG_MIN;
|
||||
# else
|
||||
return -( 9223372036854775807LL )-1; // hope this is portable
|
||||
# endif
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct fixed_numeric_limits_base< ::boost::ulong_long_type, false>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, is_specialized = true);
|
||||
BOOST_STATIC_CONSTANT(bool, is_signed = false);
|
||||
static ::boost::ulong_long_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
||||
{
|
||||
# ifdef ULONGLONG_MAX
|
||||
return ULONGLONG_MAX;
|
||||
# else
|
||||
return 0xffffffffffffffffULL; // hope this is portable
|
||||
# endif
|
||||
}
|
||||
|
||||
static ::boost::ulong_long_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return 0; }
|
||||
};
|
||||
# endif
|
||||
} // namespace detail
|
||||
|
||||
// less_than_type_min -
|
||||
// x_is_signed should be numeric_limits<X>::is_signed
|
||||
// y_is_signed should be numeric_limits<Y>::is_signed
|
||||
// y_min should be numeric_limits<Y>::min()
|
||||
//
|
||||
// check(x, y_min) returns true iff x < y_min without invoking comparisons
|
||||
// between signed and unsigned values.
|
||||
//
|
||||
// "poor man's partial specialization" is in use here.
|
||||
template <bool x_is_signed, bool y_is_signed>
|
||||
struct less_than_type_min
|
||||
{
|
||||
template <class X, class Y>
|
||||
static bool check(X x, Y y_min)
|
||||
{ return x < y_min; }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct less_than_type_min<false, true>
|
||||
{
|
||||
template <class X, class Y>
|
||||
static bool check(X, Y)
|
||||
{ return false; }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct less_than_type_min<true, false>
|
||||
{
|
||||
template <class X, class Y>
|
||||
static bool check(X x, Y)
|
||||
{ return x < 0; }
|
||||
};
|
||||
|
||||
// greater_than_type_max -
|
||||
// same_sign should be:
|
||||
// numeric_limits<X>::is_signed == numeric_limits<Y>::is_signed
|
||||
// y_max should be numeric_limits<Y>::max()
|
||||
//
|
||||
// check(x, y_max) returns true iff x > y_max without invoking comparisons
|
||||
// between signed and unsigned values.
|
||||
//
|
||||
// "poor man's partial specialization" is in use here.
|
||||
template <bool same_sign, bool x_is_signed>
|
||||
struct greater_than_type_max;
|
||||
|
||||
template<>
|
||||
struct greater_than_type_max<true, true>
|
||||
{
|
||||
template <class X, class Y>
|
||||
static inline bool check(X x, Y y_max)
|
||||
{ return x > y_max; }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct greater_than_type_max<false, true>
|
||||
{
|
||||
// What does the standard say about this? I think it's right, and it
|
||||
// will work with every compiler I know of.
|
||||
template <class X, class Y>
|
||||
static inline bool check(X x, Y)
|
||||
{ return x >= 0 && static_cast<X>(static_cast<Y>(x)) != x; }
|
||||
|
||||
# if defined(BOOST_MSVC) && BOOST_MSVC <= 1200
|
||||
// MSVC6 can't static_cast unsigned __int64 -> floating types
|
||||
# define BOOST_UINT64_CAST(src_type) \
|
||||
static inline bool check(src_type x, unsigned __int64) \
|
||||
{ \
|
||||
if (x < 0) return false; \
|
||||
unsigned __int64 y = static_cast<unsigned __int64>(x); \
|
||||
bool odd = y & 0x1; \
|
||||
__int64 div2 = static_cast<__int64>(y >> 1); \
|
||||
return ((static_cast<src_type>(div2) * 2.0) + odd) != x; \
|
||||
}
|
||||
|
||||
BOOST_UINT64_CAST(long double);
|
||||
BOOST_UINT64_CAST(double);
|
||||
BOOST_UINT64_CAST(float);
|
||||
# undef BOOST_UINT64_CAST
|
||||
# endif
|
||||
};
|
||||
|
||||
template<>
|
||||
struct greater_than_type_max<true, false>
|
||||
{
|
||||
template <class X, class Y>
|
||||
static inline bool check(X x, Y y_max)
|
||||
{ return x > y_max; }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct greater_than_type_max<false, false>
|
||||
{
|
||||
// What does the standard say about this? I think it's right, and it
|
||||
// will work with every compiler I know of.
|
||||
template <class X, class Y>
|
||||
static inline bool check(X x, Y)
|
||||
{ return static_cast<X>(static_cast<Y>(x)) != x; }
|
||||
};
|
||||
|
||||
#else // use #pragma hacks if available
|
||||
|
||||
namespace detail
|
||||
{
|
||||
# if BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4018)
|
||||
# pragma warning(disable : 4146)
|
||||
#elif defined(__BORLANDC__)
|
||||
# pragma option push -w-8041
|
||||
# endif
|
||||
|
||||
// Move to namespace boost in utility.hpp?
|
||||
template <class T>
|
||||
struct fixed_numeric_limits : public std::numeric_limits<T>
|
||||
{
|
||||
static inline T min BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
||||
{
|
||||
return std::numeric_limits<T>::is_signed && (std::numeric_limits<T>::min)() >= 0
|
||||
? T(-(std::numeric_limits<T>::max)()) : (std::numeric_limits<T>::min)();
|
||||
}
|
||||
};
|
||||
|
||||
# if BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#elif defined(__BORLANDC__)
|
||||
# pragma option pop
|
||||
# endif
|
||||
} // namespace detail
|
||||
|
||||
#endif
|
||||
|
||||
template<typename Target, typename Source>
|
||||
inline Target numeric_cast(Source arg BOOST_EXPLICIT_DEFAULT_TARGET)
|
||||
{
|
||||
// typedefs abbreviating respective trait classes
|
||||
typedef detail::fixed_numeric_limits<Source> arg_traits;
|
||||
typedef detail::fixed_numeric_limits<Target> result_traits;
|
||||
|
||||
#if defined(BOOST_STRICT_CONFIG) \
|
||||
|| (!defined(__HP_aCC) || __HP_aCC > 33900) \
|
||||
&& (!defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) \
|
||||
|| defined(BOOST_SGI_CPP_LIMITS))
|
||||
// typedefs that act as compile time assertions
|
||||
// (to be replaced by boost compile time assertions
|
||||
// as and when they become available and are stable)
|
||||
typedef bool argument_must_be_numeric[arg_traits::is_specialized];
|
||||
typedef bool result_must_be_numeric[result_traits::is_specialized];
|
||||
|
||||
const bool arg_is_signed = arg_traits::is_signed;
|
||||
const bool result_is_signed = result_traits::is_signed;
|
||||
const bool same_sign = arg_is_signed == result_is_signed;
|
||||
|
||||
if (less_than_type_min<arg_is_signed, result_is_signed>::check(arg, (result_traits::min)())
|
||||
|| greater_than_type_max<same_sign, arg_is_signed>::check(arg, (result_traits::max)())
|
||||
)
|
||||
|
||||
#else // We need to use #pragma hacks if available
|
||||
|
||||
# if BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4018)
|
||||
#elif defined(__BORLANDC__)
|
||||
#pragma option push -w-8012
|
||||
# endif
|
||||
if ((arg < 0 && !result_traits::is_signed) // loss of negative range
|
||||
|| (arg_traits::is_signed && arg < (result_traits::min)()) // underflow
|
||||
|| arg > (result_traits::max)()) // overflow
|
||||
# if BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#elif defined(__BORLANDC__)
|
||||
#pragma option pop
|
||||
# endif
|
||||
#endif
|
||||
{
|
||||
throw bad_numeric_cast();
|
||||
}
|
||||
return static_cast<Target>(arg);
|
||||
} // numeric_cast
|
||||
|
||||
# undef BOOST_EXPLICIT_DEFAULT_TARGET
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_CAST_HPP
|
||||
@@ -1,134 +0,0 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
// boost detail/templated_streams.hpp header file
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 2013 John Maddock, Antony Polukhin
|
||||
//
|
||||
//
|
||||
// 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)
|
||||
|
||||
#ifndef BOOST_DETAIL_BASIC_POINTERBUF_HPP
|
||||
#define BOOST_DETAIL_BASIC_POINTERBUF_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <streambuf>
|
||||
|
||||
namespace boost { namespace detail {
|
||||
|
||||
//
|
||||
// class basic_pointerbuf:
|
||||
// acts as a stream buffer which wraps around a pair of pointers:
|
||||
//
|
||||
template <class charT, class BufferT >
|
||||
class basic_pointerbuf : public BufferT {
|
||||
protected:
|
||||
typedef BufferT base_type;
|
||||
typedef basic_pointerbuf<charT, BufferT> this_type;
|
||||
typedef typename base_type::int_type int_type;
|
||||
typedef typename base_type::char_type char_type;
|
||||
typedef typename base_type::pos_type pos_type;
|
||||
typedef ::std::streamsize streamsize;
|
||||
typedef typename base_type::off_type off_type;
|
||||
|
||||
public:
|
||||
basic_pointerbuf() : base_type() { this_type::setbuf(0, 0); }
|
||||
const charT* getnext() { return this->gptr(); }
|
||||
|
||||
using base_type::pptr;
|
||||
using base_type::pbase;
|
||||
|
||||
protected:
|
||||
// VC mistakenly assumes that `setbuf` and other functions are not referenced.
|
||||
// Marking those functions with `inline` suppresses the warnings.
|
||||
// There must be no harm from marking virtual functions as inline: inline virtual
|
||||
// call can be inlined ONLY when the compiler knows the "exact class".
|
||||
inline base_type* setbuf(char_type* s, streamsize n) BOOST_OVERRIDE;
|
||||
inline typename this_type::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which) BOOST_OVERRIDE;
|
||||
inline typename this_type::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) BOOST_OVERRIDE;
|
||||
|
||||
private:
|
||||
basic_pointerbuf& operator=(const basic_pointerbuf&);
|
||||
basic_pointerbuf(const basic_pointerbuf&);
|
||||
};
|
||||
|
||||
template<class charT, class BufferT>
|
||||
BufferT*
|
||||
basic_pointerbuf<charT, BufferT>::setbuf(char_type* s, streamsize n)
|
||||
{
|
||||
this->setg(s, s, s + n);
|
||||
return this;
|
||||
}
|
||||
|
||||
template<class charT, class BufferT>
|
||||
typename basic_pointerbuf<charT, BufferT>::pos_type
|
||||
basic_pointerbuf<charT, BufferT>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which)
|
||||
{
|
||||
typedef ::std::ios_base::seekdir cast_type;
|
||||
|
||||
if(which & ::std::ios_base::out)
|
||||
return pos_type(off_type(-1));
|
||||
std::ptrdiff_t size = this->egptr() - this->eback();
|
||||
std::ptrdiff_t pos = this->gptr() - this->eback();
|
||||
charT* g = this->eback();
|
||||
switch(static_cast<cast_type>(way))
|
||||
{
|
||||
case ::std::ios_base::beg:
|
||||
if((off < 0) || (off > size))
|
||||
return pos_type(off_type(-1));
|
||||
else
|
||||
this->setg(g, g + off, g + size);
|
||||
break;
|
||||
case ::std::ios_base::end:
|
||||
if((off < 0) || (off > size))
|
||||
return pos_type(off_type(-1));
|
||||
else
|
||||
this->setg(g, g + size - off, g + size);
|
||||
break;
|
||||
case ::std::ios_base::cur:
|
||||
{
|
||||
std::ptrdiff_t newpos = static_cast<std::ptrdiff_t>(pos + off);
|
||||
if((newpos < 0) || (newpos > size))
|
||||
return pos_type(off_type(-1));
|
||||
else
|
||||
this->setg(g, g + newpos, g + size);
|
||||
break;
|
||||
}
|
||||
default: ;
|
||||
}
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:4244)
|
||||
#endif
|
||||
return static_cast<pos_type>(this->gptr() - this->eback());
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
}
|
||||
|
||||
template<class charT, class BufferT>
|
||||
typename basic_pointerbuf<charT, BufferT>::pos_type
|
||||
basic_pointerbuf<charT, BufferT>::seekpos(pos_type sp, ::std::ios_base::openmode which)
|
||||
{
|
||||
if(which & ::std::ios_base::out)
|
||||
return pos_type(off_type(-1));
|
||||
off_type size = static_cast<off_type>(this->egptr() - this->eback());
|
||||
charT* g = this->eback();
|
||||
if(off_type(sp) <= size)
|
||||
{
|
||||
this->setg(g, g + off_type(sp), g + size);
|
||||
}
|
||||
return pos_type(off_type(-1));
|
||||
}
|
||||
|
||||
}} // namespace boost::detail
|
||||
|
||||
#endif // BOOST_DETAIL_BASIC_POINTERBUF_HPP
|
||||
Executable
+35
@@ -0,0 +1,35 @@
|
||||
// Copyright David Abrahams 2003.
|
||||
// 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)
|
||||
#ifndef IMPLICIT_CAST_DWA200356_HPP
|
||||
# define IMPLICIT_CAST_DWA200356_HPP
|
||||
|
||||
# include <boost/mpl/identity.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
// implementation originally suggested by C. Green in
|
||||
// http://lists.boost.org/MailArchives/boost/msg00886.php
|
||||
|
||||
// The use of identity creates a non-deduced form, so that the
|
||||
// explicit template argument must be supplied
|
||||
template <typename T>
|
||||
inline T implicit_cast (typename mpl::identity<T>::type x) {
|
||||
return x;
|
||||
}
|
||||
|
||||
// incomplete return type now is here
|
||||
//template <typename T>
|
||||
//void implicit_cast (...);
|
||||
|
||||
// Macro for when you need a constant expression (Gennaro Prota)
|
||||
#define BOOST_IMPLICIT_CAST(dst_type, expr) \
|
||||
( sizeof( implicit_cast<dst_type>(expr) ) \
|
||||
, \
|
||||
static_cast<dst_type>(expr) \
|
||||
)
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // IMPLICIT_CAST_DWA200356_HPP
|
||||
+196
-105
@@ -1,112 +1,203 @@
|
||||
// Copyright Kevlin Henney, 2000-2005.
|
||||
// Copyright Alexander Nasonov, 2006-2010.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
#ifndef BOOST_LEXICAL_CAST_INCLUDED
|
||||
#define BOOST_LEXICAL_CAST_INCLUDED
|
||||
|
||||
// Boost lexical_cast.hpp header -------------------------------------------//
|
||||
//
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
// See end of this header for rights and permissions.
|
||||
//
|
||||
// what: lexical_cast custom keyword cast
|
||||
// who: contributed by Kevlin Henney,
|
||||
// enhanced with contributions from Terje Slettebø,
|
||||
// with additional fixes and suggestions from Gennaro Prota,
|
||||
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
|
||||
// and other Boosters
|
||||
// when: November 2000, March 2003
|
||||
|
||||
#include <string>
|
||||
#include <typeinfo>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <boost/type_traits/is_pointer.hpp>
|
||||
|
||||
#ifdef BOOST_NO_STRINGSTREAM
|
||||
#include <strstream>
|
||||
#else
|
||||
#include <sstream>
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || \
|
||||
defined(BOOST_NO_STD_WSTRING) || \
|
||||
defined(BOOST_NO_STD_LOCALE) || \
|
||||
defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
#define DISABLE_WIDE_CHAR_SUPPORT
|
||||
#endif
|
||||
|
||||
namespace boost
|
||||
{
|
||||
// exception used to indicate runtime lexical_cast failure
|
||||
class bad_lexical_cast : public std::bad_cast
|
||||
{
|
||||
public:
|
||||
bad_lexical_cast() :
|
||||
source(&typeid(void)), target(&typeid(void))
|
||||
{
|
||||
}
|
||||
bad_lexical_cast(
|
||||
const std::type_info &s,
|
||||
const std::type_info &t) :
|
||||
source(&s), target(&t)
|
||||
{
|
||||
}
|
||||
const std::type_info &source_type() const
|
||||
{
|
||||
return *source;
|
||||
}
|
||||
const std::type_info &target_type() const
|
||||
{
|
||||
return *target;
|
||||
}
|
||||
virtual const char *what() const throw()
|
||||
{
|
||||
return "bad lexical cast: "
|
||||
"source type value could not be interpreted as target";
|
||||
}
|
||||
virtual ~bad_lexical_cast() throw()
|
||||
{
|
||||
}
|
||||
private:
|
||||
const std::type_info *source;
|
||||
const std::type_info *target;
|
||||
};
|
||||
|
||||
namespace detail // selectors for choosing stream character type
|
||||
{
|
||||
template<typename Type>
|
||||
struct stream_char
|
||||
{
|
||||
typedef char type;
|
||||
};
|
||||
|
||||
#ifndef DISABLE_WIDE_CHAR_SUPPORT
|
||||
template<>
|
||||
struct stream_char<wchar_t>
|
||||
{
|
||||
typedef wchar_t type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct stream_char<wchar_t *>
|
||||
{
|
||||
typedef wchar_t type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct stream_char<const wchar_t *>
|
||||
{
|
||||
typedef wchar_t type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct stream_char<std::wstring>
|
||||
{
|
||||
typedef wchar_t type;
|
||||
};
|
||||
#endif
|
||||
|
||||
template<typename TargetChar, typename SourceChar>
|
||||
struct widest_char
|
||||
{
|
||||
typedef TargetChar type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct widest_char<char, wchar_t>
|
||||
{
|
||||
typedef wchar_t type;
|
||||
};
|
||||
}
|
||||
|
||||
namespace detail // stream wrapper for handling lexical conversions
|
||||
{
|
||||
template<typename Target, typename Source>
|
||||
class lexical_stream
|
||||
{
|
||||
public:
|
||||
lexical_stream()
|
||||
{
|
||||
stream.unsetf(std::ios::skipws);
|
||||
|
||||
if(std::numeric_limits<Target>::is_specialized)
|
||||
stream.precision(std::numeric_limits<Target>::digits10 + 1);
|
||||
else if(std::numeric_limits<Source>::is_specialized)
|
||||
stream.precision(std::numeric_limits<Source>::digits10 + 1);
|
||||
}
|
||||
~lexical_stream()
|
||||
{
|
||||
#if defined(BOOST_NO_STRINGSTREAM)
|
||||
stream.freeze(false);
|
||||
#endif
|
||||
}
|
||||
bool operator<<(const Source &input)
|
||||
{
|
||||
return !(stream << input).fail();
|
||||
}
|
||||
template<typename InputStreamable>
|
||||
bool operator>>(InputStreamable &output)
|
||||
{
|
||||
return !is_pointer<InputStreamable>::value &&
|
||||
stream >> output &&
|
||||
(stream >> std::ws).eof();
|
||||
}
|
||||
bool operator>>(std::string &output)
|
||||
{
|
||||
#if defined(BOOST_NO_STRINGSTREAM)
|
||||
stream << '\0';
|
||||
#endif
|
||||
output = stream.str();
|
||||
return true;
|
||||
}
|
||||
#ifndef DISABLE_WIDE_CHAR_SUPPORT
|
||||
bool operator>>(std::wstring &output)
|
||||
{
|
||||
output = stream.str();
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
private:
|
||||
typedef typename widest_char<
|
||||
typename stream_char<Target>::type,
|
||||
typename stream_char<Source>::type>::type char_type;
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM)
|
||||
std::strstream stream;
|
||||
#elif defined(BOOST_NO_STD_LOCALE)
|
||||
std::stringstream stream;
|
||||
#else
|
||||
std::basic_stringstream<char_type> stream;
|
||||
#endif
|
||||
};
|
||||
}
|
||||
|
||||
template<typename Target, typename Source>
|
||||
Target lexical_cast(Source arg)
|
||||
{
|
||||
detail::lexical_stream<Target, Source> interpreter;
|
||||
Target result;
|
||||
|
||||
if(!(interpreter << arg && interpreter >> result))
|
||||
throw_exception(bad_lexical_cast(typeid(Target), typeid(Source)));
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
// Copyright Kevlin Henney, 2000-2003. All rights reserved.
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// what: lexical_cast custom keyword cast
|
||||
// who: contributed by Kevlin Henney,
|
||||
// enhanced with contributions from Terje Slettebo,
|
||||
// with additional fixes and suggestions from Gennaro Prota,
|
||||
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
|
||||
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
|
||||
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
|
||||
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INCLUDED
|
||||
#define BOOST_LEXICAL_CAST_INCLUDED
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
#undef DISABLE_WIDE_CHAR_SUPPORT
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
|
||||
#define BOOST_LCAST_NO_WCHAR_T
|
||||
#endif
|
||||
|
||||
#include <boost/lexical_cast/detail/buffer_view.hpp>
|
||||
|
||||
#include <boost/lexical_cast/bad_lexical_cast.hpp>
|
||||
#include <boost/lexical_cast/try_lexical_convert.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
BOOST_LEXICAL_CAST_BEGIN_MODULE_EXPORT
|
||||
template <typename Target, typename Source>
|
||||
inline Target lexical_cast(const Source &arg)
|
||||
{
|
||||
Target result = Target();
|
||||
|
||||
if (!boost::conversion::detail::try_lexical_convert(arg, result)) {
|
||||
boost::conversion::detail::throw_bad_cast<Source, Target>();
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
template <typename Target>
|
||||
inline Target lexical_cast(const char* chars, std::size_t count)
|
||||
{
|
||||
return ::boost::lexical_cast<Target>(
|
||||
::boost::conversion::detail::make_buffer_view(chars, chars + count)
|
||||
);
|
||||
}
|
||||
|
||||
template <typename Target>
|
||||
inline Target lexical_cast(const unsigned char* chars, std::size_t count)
|
||||
{
|
||||
return ::boost::lexical_cast<Target>(
|
||||
::boost::conversion::detail::make_buffer_view(chars, chars + count)
|
||||
);
|
||||
}
|
||||
|
||||
template <typename Target>
|
||||
inline Target lexical_cast(const signed char* chars, std::size_t count)
|
||||
{
|
||||
return ::boost::lexical_cast<Target>(
|
||||
::boost::conversion::detail::make_buffer_view(chars, chars + count)
|
||||
);
|
||||
}
|
||||
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
template <typename Target>
|
||||
inline Target lexical_cast(const wchar_t* chars, std::size_t count)
|
||||
{
|
||||
return ::boost::lexical_cast<Target>(
|
||||
::boost::conversion::detail::make_buffer_view(chars, chars + count)
|
||||
);
|
||||
}
|
||||
#endif
|
||||
template <typename Target>
|
||||
inline Target lexical_cast(const char16_t* chars, std::size_t count)
|
||||
{
|
||||
return ::boost::lexical_cast<Target>(
|
||||
::boost::conversion::detail::make_buffer_view(chars, chars + count)
|
||||
);
|
||||
}
|
||||
template <typename Target>
|
||||
inline Target lexical_cast(const char32_t* chars, std::size_t count)
|
||||
{
|
||||
return ::boost::lexical_cast<Target>(
|
||||
::boost::conversion::detail::make_buffer_view(chars, chars + count)
|
||||
);
|
||||
}
|
||||
|
||||
BOOST_LEXICAL_CAST_END_MODULE_EXPORT
|
||||
} // namespace boost
|
||||
|
||||
#undef BOOST_LCAST_NO_WCHAR_T
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_INCLUDED
|
||||
|
||||
|
||||
@@ -1,110 +0,0 @@
|
||||
// Copyright Kevlin Henney, 2000-2005.
|
||||
// Copyright Alexander Nasonov, 2006-2010.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// what: lexical_cast custom keyword cast
|
||||
// who: contributed by Kevlin Henney,
|
||||
// enhanced with contributions from Terje Slettebo,
|
||||
// with additional fixes and suggestions from Gennaro Prota,
|
||||
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
|
||||
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
|
||||
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
|
||||
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_BAD_LEXICAL_CAST_HPP
|
||||
#define BOOST_LEXICAL_CAST_BAD_LEXICAL_CAST_HPP
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <exception>
|
||||
#include <typeinfo>
|
||||
#include <boost/throw_exception.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost
|
||||
{
|
||||
BOOST_LEXICAL_CAST_BEGIN_MODULE_EXPORT
|
||||
// exception used to indicate runtime lexical_cast failure
|
||||
class BOOST_SYMBOL_VISIBLE bad_lexical_cast :
|
||||
// workaround MSVC bug with std::bad_cast when _HAS_EXCEPTIONS == 0
|
||||
#if defined(BOOST_MSVC) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
|
||||
public std::exception
|
||||
#else
|
||||
public std::bad_cast
|
||||
#endif
|
||||
{
|
||||
public:
|
||||
bad_lexical_cast() noexcept
|
||||
#ifndef BOOST_NO_TYPEID
|
||||
: source(&typeid(void)), target(&typeid(void))
|
||||
#endif
|
||||
{}
|
||||
|
||||
const char *what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE {
|
||||
return "bad lexical cast: "
|
||||
"source type value could not be interpreted as target";
|
||||
}
|
||||
|
||||
bad_lexical_cast(const bad_lexical_cast&) = default;
|
||||
bad_lexical_cast& operator=(const bad_lexical_cast&) = default;
|
||||
|
||||
#ifndef BOOST_NO_TYPEID
|
||||
private:
|
||||
#ifdef BOOST_NO_STD_TYPEINFO
|
||||
typedef ::type_info type_info_t;
|
||||
#else
|
||||
typedef ::std::type_info type_info_t;
|
||||
#endif
|
||||
public:
|
||||
bad_lexical_cast(
|
||||
const type_info_t &source_type_arg,
|
||||
const type_info_t &target_type_arg) noexcept
|
||||
: source(&source_type_arg), target(&target_type_arg)
|
||||
{}
|
||||
|
||||
const type_info_t &source_type() const noexcept {
|
||||
return *source;
|
||||
}
|
||||
|
||||
const type_info_t &target_type() const noexcept {
|
||||
return *target;
|
||||
}
|
||||
|
||||
private:
|
||||
const type_info_t *source;
|
||||
const type_info_t *target;
|
||||
#endif
|
||||
};
|
||||
BOOST_LEXICAL_CAST_END_MODULE_EXPORT
|
||||
|
||||
namespace conversion { namespace detail {
|
||||
#ifdef BOOST_NO_TYPEID
|
||||
template <class S, class T>
|
||||
inline void throw_bad_cast() {
|
||||
boost::throw_exception(bad_lexical_cast());
|
||||
}
|
||||
#else
|
||||
template <class S, class T>
|
||||
inline void throw_bad_cast() {
|
||||
boost::throw_exception(bad_lexical_cast(typeid(S), typeid(T)));
|
||||
}
|
||||
#endif
|
||||
}} // namespace conversion::detail
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_BAD_LEXICAL_CAST_HPP
|
||||
@@ -1,67 +0,0 @@
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_DETAIL_BUFFER_VIEW_HPP
|
||||
#define BOOST_LEXICAL_CAST_DETAIL_BUFFER_VIEW_HPP
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <iosfwd>
|
||||
#endif
|
||||
|
||||
namespace boost { namespace conversion { namespace detail {
|
||||
|
||||
template < typename CharT >
|
||||
struct buffer_view {
|
||||
const CharT* begin;
|
||||
const CharT* end;
|
||||
};
|
||||
|
||||
template < typename CharT >
|
||||
buffer_view<CharT> make_buffer_view(const CharT* begin, const CharT* end) {
|
||||
return buffer_view<CharT>{begin, end};
|
||||
}
|
||||
|
||||
inline buffer_view<char> make_buffer_view(const signed char* begin, const signed char* end) {
|
||||
return buffer_view<char>{
|
||||
reinterpret_cast<const char*>(begin),
|
||||
reinterpret_cast<const char*>(end)
|
||||
};
|
||||
}
|
||||
|
||||
inline buffer_view<char> make_buffer_view(const unsigned char* begin, const unsigned char* end) {
|
||||
return buffer_view<char>{
|
||||
reinterpret_cast<const char*>(begin),
|
||||
reinterpret_cast<const char*>(end)
|
||||
};
|
||||
}
|
||||
|
||||
template< typename CharT, typename Elem, typename Traits >
|
||||
std::basic_ostream<Elem,Traits>& operator<<(
|
||||
std::basic_ostream<Elem, Traits>& os,
|
||||
buffer_view<CharT> r)
|
||||
{
|
||||
while (r.begin != r.end) {
|
||||
os << r.begin[0];
|
||||
++r.begin;
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
}}} // namespace boost::conversion::detail
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_DETAIL_BUFFER_VIEW_HPP
|
||||
|
||||
@@ -1,22 +0,0 @@
|
||||
// Copyright Antony Polukhin, 2021-2026.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_DETAIL_CONFIG_HPP
|
||||
#define BOOST_LEXICAL_CAST_DETAIL_CONFIG_HPP
|
||||
|
||||
#ifdef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
# define BOOST_LEXICAL_CAST_BEGIN_MODULE_EXPORT export {
|
||||
# define BOOST_LEXICAL_CAST_END_MODULE_EXPORT }
|
||||
#else
|
||||
# define BOOST_LEXICAL_CAST_BEGIN_MODULE_EXPORT
|
||||
# define BOOST_LEXICAL_CAST_END_MODULE_EXPORT
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_USE_MODULES) && !defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
import boost.lexical_cast;
|
||||
#endif
|
||||
|
||||
#endif // #ifndef BOOST_LEXICAL_CAST_DETAIL_CONFIG_HPP
|
||||
@@ -1,491 +0,0 @@
|
||||
// Copyright Kevlin Henney, 2000-2005.
|
||||
// Copyright Alexander Nasonov, 2006-2010.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// what: lexical_cast custom keyword cast
|
||||
// who: contributed by Kevlin Henney,
|
||||
// enhanced with contributions from Terje Slettebo,
|
||||
// with additional fixes and suggestions from Gennaro Prota,
|
||||
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
|
||||
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
|
||||
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
|
||||
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
|
||||
#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
|
||||
#define BOOST_LCAST_NO_WCHAR_T
|
||||
#endif
|
||||
|
||||
#include <array>
|
||||
#include <cstddef>
|
||||
#include <string>
|
||||
#include <type_traits>
|
||||
#include <boost/limits.hpp>
|
||||
|
||||
#include <array>
|
||||
|
||||
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
|
||||
#include <string_view>
|
||||
#endif
|
||||
|
||||
#include <boost/container/container_fwd.hpp>
|
||||
|
||||
#endif // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
|
||||
#include <boost/lexical_cast/detail/lcast_precision.hpp>
|
||||
#include <boost/lexical_cast/detail/widest_char.hpp>
|
||||
#include <boost/lexical_cast/detail/is_character.hpp>
|
||||
#include <boost/lexical_cast/detail/buffer_view.hpp>
|
||||
#include <boost/lexical_cast/detail/converter_lexical_streams.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
// Forward declaration
|
||||
template<class T, std::size_t N>
|
||||
class array;
|
||||
template<class IteratorT>
|
||||
class iterator_range;
|
||||
|
||||
// Forward declaration of boost::basic_string_view from Utility
|
||||
template<class Ch, class Tr> class basic_string_view;
|
||||
|
||||
namespace detail // normalize_single_byte_char<Char>
|
||||
{
|
||||
// Converts signed/unsigned char to char
|
||||
template < class Char >
|
||||
struct normalize_single_byte_char
|
||||
{
|
||||
using type = Char;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct normalize_single_byte_char< signed char >
|
||||
{
|
||||
using type = char;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct normalize_single_byte_char< unsigned char >
|
||||
{
|
||||
using type = char;
|
||||
};
|
||||
}
|
||||
|
||||
namespace detail // deduce_character_type_later<T>
|
||||
{
|
||||
// Helper type, meaning that stram character for T must be deduced
|
||||
// at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
|
||||
template < class T > struct deduce_character_type_later {};
|
||||
}
|
||||
|
||||
namespace detail // stream_char_common<T>
|
||||
{
|
||||
// Selectors to choose stream character type (common for Source and Target)
|
||||
// Returns one of char, wchar_t, char16_t, char32_t or deduce_character_type_later<T> types
|
||||
// Executed on Stage 1 (See deduce_source_char<T> and deduce_target_char<T>)
|
||||
template < typename Type >
|
||||
struct stream_char_common: public std::conditional<
|
||||
boost::detail::is_character< Type >::value,
|
||||
Type,
|
||||
boost::detail::deduce_character_type_later< Type >
|
||||
> {};
|
||||
|
||||
template < typename Char >
|
||||
struct stream_char_common< Char* >: public std::conditional<
|
||||
boost::detail::is_character< Char >::value,
|
||||
Char,
|
||||
boost::detail::deduce_character_type_later< Char* >
|
||||
> {};
|
||||
|
||||
template < typename Char >
|
||||
struct stream_char_common< const Char* >: public std::conditional<
|
||||
boost::detail::is_character< Char >::value,
|
||||
Char,
|
||||
boost::detail::deduce_character_type_later< const Char* >
|
||||
> {};
|
||||
|
||||
template < typename Char >
|
||||
struct stream_char_common< boost::conversion::detail::buffer_view< Char > >
|
||||
{
|
||||
using type = Char;
|
||||
};
|
||||
|
||||
template < typename Char >
|
||||
struct stream_char_common< boost::iterator_range< Char* > >: public std::conditional<
|
||||
boost::detail::is_character< Char >::value,
|
||||
Char,
|
||||
boost::detail::deduce_character_type_later< boost::iterator_range< Char* > >
|
||||
> {};
|
||||
|
||||
template < typename Char >
|
||||
struct stream_char_common< boost::iterator_range< const Char* > >: public std::conditional<
|
||||
boost::detail::is_character< Char >::value,
|
||||
Char,
|
||||
boost::detail::deduce_character_type_later< boost::iterator_range< const Char* > >
|
||||
> {};
|
||||
|
||||
template < class Char, class Traits, class Alloc >
|
||||
struct stream_char_common< std::basic_string< Char, Traits, Alloc > >
|
||||
{
|
||||
using type = Char;
|
||||
};
|
||||
|
||||
template < class Char, class Traits, class Alloc >
|
||||
struct stream_char_common< boost::container::basic_string< Char, Traits, Alloc > >
|
||||
{
|
||||
using type = Char;
|
||||
};
|
||||
|
||||
template < typename Char, std::size_t N >
|
||||
struct stream_char_common< boost::array< Char, N > >: public std::conditional<
|
||||
boost::detail::is_character< Char >::value,
|
||||
Char,
|
||||
boost::detail::deduce_character_type_later< boost::array< Char, N > >
|
||||
> {};
|
||||
|
||||
template < typename Char, std::size_t N >
|
||||
struct stream_char_common< boost::array< const Char, N > >: public std::conditional<
|
||||
boost::detail::is_character< Char >::value,
|
||||
Char,
|
||||
boost::detail::deduce_character_type_later< boost::array< const Char, N > >
|
||||
> {};
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
template < typename Char, std::size_t N >
|
||||
struct stream_char_common< std::array<Char, N > >: public std::conditional<
|
||||
boost::detail::is_character< Char >::value,
|
||||
Char,
|
||||
boost::detail::deduce_character_type_later< std::array< Char, N > >
|
||||
> {};
|
||||
|
||||
template < typename Char, std::size_t N >
|
||||
struct stream_char_common< std::array< const Char, N > >: public std::conditional<
|
||||
boost::detail::is_character< Char >::value,
|
||||
Char,
|
||||
boost::detail::deduce_character_type_later< std::array< const Char, N > >
|
||||
> {};
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
|
||||
template < class Char, class Traits >
|
||||
struct stream_char_common< std::basic_string_view< Char, Traits > >
|
||||
{
|
||||
using type = Char;
|
||||
};
|
||||
#endif
|
||||
template < class Char, class Traits >
|
||||
struct stream_char_common< boost::basic_string_view< Char, Traits > >
|
||||
{
|
||||
using type = Char;
|
||||
};
|
||||
|
||||
#ifdef BOOST_HAS_INT128
|
||||
template <> struct stream_char_common< boost::int128_type >
|
||||
{
|
||||
using type = char;
|
||||
};
|
||||
template <> struct stream_char_common< boost::uint128_type >
|
||||
{
|
||||
using type = char;
|
||||
};
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T) && defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
template <>
|
||||
struct stream_char_common< wchar_t >
|
||||
{
|
||||
using type = char;
|
||||
};
|
||||
#endif
|
||||
}
|
||||
|
||||
namespace detail // deduce_source_char_impl<T>
|
||||
{
|
||||
// If type T is `deduce_character_type_later` type, then tries to deduce
|
||||
// character type using streaming metafunctions.
|
||||
// Otherwise supplied type T is a character type, that must be normalized
|
||||
// using normalize_single_byte_char<Char>.
|
||||
// Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
|
||||
template < class Char >
|
||||
struct deduce_source_char_impl
|
||||
{
|
||||
typedef typename boost::detail::normalize_single_byte_char< Char >::type type;
|
||||
};
|
||||
|
||||
template < class T >
|
||||
struct deduce_source_char_impl< deduce_character_type_later< T > >
|
||||
{
|
||||
template <class U>
|
||||
static auto left_shift_type(long)
|
||||
-> decltype( std::declval<std::basic_ostream< char >&>() << std::declval<const U&>(), char{});
|
||||
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T)
|
||||
template <class U>
|
||||
static auto left_shift_type(int)
|
||||
-> decltype( std::declval<std::basic_ostream< wchar_t >&>() << std::declval<const U&>(), wchar_t{});
|
||||
#endif
|
||||
|
||||
template <class U>
|
||||
static void left_shift_type(...);
|
||||
|
||||
using type = decltype(left_shift_type<T>(1L));
|
||||
|
||||
static_assert(!std::is_same<type, void>::value,
|
||||
#if defined(BOOST_LCAST_NO_WCHAR_T)
|
||||
"Source type is not std::ostream`able and std::wostream`s are "
|
||||
"not supported by your STL implementation"
|
||||
#else
|
||||
"Source type is neither std::ostream`able nor std::wostream`able"
|
||||
#endif
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
namespace detail // deduce_target_char_impl<T>
|
||||
{
|
||||
// If type T is `deduce_character_type_later` type, then tries to deduce
|
||||
// character type using boost::has_right_shift<T> metafunction.
|
||||
// Otherwise supplied type T is a character type, that must be normalized
|
||||
// using normalize_single_byte_char<Char>.
|
||||
// Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
|
||||
template < class Char >
|
||||
struct deduce_target_char_impl
|
||||
{
|
||||
typedef typename normalize_single_byte_char< Char >::type type;
|
||||
};
|
||||
|
||||
template < class T >
|
||||
struct deduce_target_char_impl< deduce_character_type_later<T> >
|
||||
{
|
||||
template <class U>
|
||||
static auto right_shift_type(long)
|
||||
-> decltype( std::declval<std::basic_istream< char >&>() >> std::declval<U&>(), char{});
|
||||
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T)
|
||||
template <class U>
|
||||
static auto right_shift_type(int)
|
||||
-> decltype( std::declval<std::basic_istream< wchar_t >&>() >> std::declval<U&>(), wchar_t{});
|
||||
#endif
|
||||
|
||||
template <class U>
|
||||
static void right_shift_type(...);
|
||||
|
||||
using type = decltype(right_shift_type<T>(1L));
|
||||
|
||||
static_assert(!std::is_same<type, void>::value,
|
||||
#if defined(BOOST_LCAST_NO_WCHAR_T)
|
||||
"Target type is not std::istream`able and std::wistream`s are "
|
||||
"not supported by your STL implementation"
|
||||
#else
|
||||
"Target type is neither std::istream`able nor std::wistream`able"
|
||||
#endif
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
namespace detail // deduce_target_char<T> and deduce_source_char<T>
|
||||
{
|
||||
// We deduce stream character types in two stages.
|
||||
//
|
||||
// Stage 1 is common for Target and Source. At Stage 1 we get
|
||||
// non normalized character type (may contain unsigned/signed char)
|
||||
// or deduce_character_type_later<T> where T is the original type.
|
||||
// Stage 1 is executed by stream_char_common<T>
|
||||
//
|
||||
// At Stage 2 we normalize character types or try to deduce character
|
||||
// type using metafunctions.
|
||||
// Stage 2 is executed by deduce_target_char_impl<T> and
|
||||
// deduce_source_char_impl<T>
|
||||
//
|
||||
// deduce_target_char<T> and deduce_source_char<T> functions combine
|
||||
// both stages
|
||||
|
||||
template < class T >
|
||||
struct deduce_target_char
|
||||
{
|
||||
typedef typename stream_char_common< T >::type stage1_type;
|
||||
typedef typename deduce_target_char_impl< stage1_type >::type type;
|
||||
};
|
||||
|
||||
template < class T >
|
||||
struct deduce_source_char
|
||||
{
|
||||
typedef typename stream_char_common< T >::type stage1_type;
|
||||
typedef typename deduce_source_char_impl< stage1_type >::type type;
|
||||
};
|
||||
}
|
||||
|
||||
namespace detail // array_to_pointer_decay<T>
|
||||
{
|
||||
template<class T>
|
||||
struct array_to_pointer_decay
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<class T, std::size_t N>
|
||||
struct array_to_pointer_decay<T[N]>
|
||||
{
|
||||
typedef const T * type;
|
||||
};
|
||||
}
|
||||
|
||||
namespace detail // lcast_src_length
|
||||
{
|
||||
// Return max. length of string representation of Source;
|
||||
template< class Source, // Source type of lexical_cast.
|
||||
class Enable = void // helper type
|
||||
>
|
||||
struct lcast_src_length
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(std::size_t, value = 1);
|
||||
};
|
||||
|
||||
// Helper for integral types.
|
||||
// Notes on length calculation:
|
||||
// Max length for 32bit int with grouping "\1" and thousands_sep ',':
|
||||
// "-2,1,4,7,4,8,3,6,4,7"
|
||||
// ^ - is_signed
|
||||
// ^ - 1 digit not counted by digits10
|
||||
// ^^^^^^^^^^^^^^^^^^ - digits10 * 2
|
||||
//
|
||||
// Constant is_specialized is used instead of constant 1
|
||||
// to prevent buffer overflow in a rare case when
|
||||
// <boost/limits.hpp> doesn't add missing specialization for
|
||||
// numeric_limits<T> for some integral type T.
|
||||
// When is_specialized is false, the whole expression is 0.
|
||||
template <class Source>
|
||||
struct lcast_src_length<
|
||||
Source, typename std::enable_if<boost::detail::lcast::is_integral<Source>::value >::type
|
||||
>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(std::size_t, value =
|
||||
std::numeric_limits<Source>::is_signed +
|
||||
std::numeric_limits<Source>::is_specialized + /* == 1 */
|
||||
std::numeric_limits<Source>::digits10 * 2
|
||||
);
|
||||
};
|
||||
|
||||
// Helper for floating point types.
|
||||
// -1.23456789e-123456
|
||||
// ^ sign
|
||||
// ^ leading digit
|
||||
// ^ decimal point
|
||||
// ^^^^^^^^ lcast_precision<Source>::value
|
||||
// ^ "e"
|
||||
// ^ exponent sign
|
||||
// ^^^^^^ exponent (assumed 6 or less digits)
|
||||
// sign + leading digit + decimal point + "e" + exponent sign == 5
|
||||
template<class Source>
|
||||
struct lcast_src_length<
|
||||
Source, typename std::enable_if<std::is_floating_point<Source>::value >::type
|
||||
>
|
||||
{
|
||||
static_assert(
|
||||
std::numeric_limits<Source>::max_exponent10 <= 999999L &&
|
||||
std::numeric_limits<Source>::min_exponent10 >= -999999L
|
||||
, "");
|
||||
|
||||
BOOST_STATIC_CONSTANT(std::size_t, value =
|
||||
5 + lcast_precision<Source>::value + 6
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
namespace detail // lexical_cast_stream_traits<Source, Target>
|
||||
{
|
||||
template <class Source, class Target>
|
||||
struct lexical_cast_stream_traits {
|
||||
typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
|
||||
typedef typename std::remove_cv<src>::type no_cv_src;
|
||||
|
||||
typedef boost::detail::deduce_source_char<no_cv_src> deduce_src_char_metafunc;
|
||||
typedef typename deduce_src_char_metafunc::type src_char_t;
|
||||
typedef typename boost::detail::deduce_target_char<Target>::type target_char_t;
|
||||
|
||||
typedef typename boost::detail::widest_char<
|
||||
target_char_t, src_char_t
|
||||
>::type char_type;
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
static_assert(!std::is_same<char16_t, src_char_t>::value
|
||||
&& !std::is_same<char16_t, target_char_t>::value,
|
||||
"Your compiler does not have full support for char16_t" );
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
static_assert(!std::is_same<char32_t, src_char_t>::value
|
||||
&& !std::is_same<char32_t, target_char_t>::value,
|
||||
"Your compiler does not have full support for char32_t" );
|
||||
#endif
|
||||
|
||||
typedef std::char_traits<char_type> traits;
|
||||
|
||||
typedef boost::detail::lcast_src_length<no_cv_src> len_t;
|
||||
};
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template<typename Target, typename Source>
|
||||
struct lexical_converter_impl
|
||||
{
|
||||
typedef lexical_cast_stream_traits<Source, Target> stream_trait;
|
||||
|
||||
typedef detail::lcast::optimized_src_stream<
|
||||
typename stream_trait::char_type,
|
||||
typename stream_trait::traits,
|
||||
stream_trait::len_t::value + 1
|
||||
> optimized_src_stream;
|
||||
|
||||
template <class T>
|
||||
static auto detect_type(int)
|
||||
-> decltype(std::declval<optimized_src_stream&>().stream_in(std::declval<lcast::exact<T>>()), optimized_src_stream{});
|
||||
|
||||
template <class T>
|
||||
static lcast::ios_src_stream<typename stream_trait::char_type, typename stream_trait::traits> detect_type(...);
|
||||
|
||||
using from_src_stream = decltype(detect_type<Source>(1));
|
||||
|
||||
typedef detail::lcast::to_target_stream<
|
||||
typename stream_trait::char_type,
|
||||
typename stream_trait::traits
|
||||
> to_target_stream;
|
||||
|
||||
static inline bool try_convert(const Source& arg, Target& result) {
|
||||
from_src_stream src_stream;
|
||||
if (!src_stream.stream_in(lcast::exact<Source>{arg}))
|
||||
return false;
|
||||
|
||||
to_target_stream out(src_stream.cbegin(), src_stream.cend());
|
||||
if (!out.stream_out(result))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#undef BOOST_LCAST_NO_WCHAR_T
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
|
||||
|
||||
@@ -1,763 +0,0 @@
|
||||
// Copyright Kevlin Henney, 2000-2005.
|
||||
// Copyright Alexander Nasonov, 2006-2010.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// what: lexical_cast custom keyword cast
|
||||
// who: contributed by Kevlin Henney,
|
||||
// enhanced with contributions from Terje Slettebo,
|
||||
// with additional fixes and suggestions from Gennaro Prota,
|
||||
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
|
||||
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
|
||||
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
|
||||
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014, Nowember 2016
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP
|
||||
#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
|
||||
#define BOOST_LCAST_NO_WCHAR_T
|
||||
#endif
|
||||
|
||||
#include <cstddef>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <type_traits>
|
||||
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <boost/core/snprintf.hpp>
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
# include <locale>
|
||||
#else
|
||||
# ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
|
||||
// Getting error at this point means, that your STL library is old/lame/misconfigured.
|
||||
// If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE,
|
||||
// but beware: lexical_cast will understand only 'C' locale delimeters and thousands
|
||||
// separators.
|
||||
# error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force "
|
||||
# error "boost::lexical_cast to use only 'C' locale during conversions."
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_NO_STRINGSTREAM
|
||||
#include <strstream>
|
||||
#else
|
||||
#include <sstream>
|
||||
#endif
|
||||
|
||||
|
||||
#include <array>
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
# include <cwchar>
|
||||
#endif
|
||||
#include <istream>
|
||||
|
||||
#include <boost/container/container_fwd.hpp>
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
# include <cwchar>
|
||||
#endif
|
||||
|
||||
#endif // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
|
||||
#include <boost/lexical_cast/detail/buffer_view.hpp>
|
||||
#include <boost/lexical_cast/detail/lcast_char_constants.hpp>
|
||||
#include <boost/lexical_cast/detail/lcast_unsigned_converters.hpp>
|
||||
#include <boost/lexical_cast/detail/lcast_basic_unlockedbuf.hpp>
|
||||
#include <boost/lexical_cast/detail/inf_nan.hpp>
|
||||
#include <boost/lexical_cast/detail/lcast_precision.hpp>
|
||||
#include <boost/lexical_cast/detail/type_traits.hpp>
|
||||
|
||||
// Forward declarations
|
||||
namespace boost {
|
||||
template<class T, std::size_t N>
|
||||
class array;
|
||||
template<class IteratorT>
|
||||
class iterator_range;
|
||||
|
||||
// forward declaration of boost::basic_string_view from Utility
|
||||
template<class Ch, class Tr> class basic_string_view;
|
||||
}
|
||||
|
||||
namespace boost { namespace detail { namespace lcast {
|
||||
|
||||
template <typename T>
|
||||
struct exact {
|
||||
static_assert(!std::is_const<T>::value, "");
|
||||
static_assert(!std::is_reference<T>::value, "");
|
||||
|
||||
const T& payload;
|
||||
};
|
||||
|
||||
template< class CharT // a result of widest_char transformation
|
||||
, class Traits
|
||||
, std::size_t CharacterBufferSize
|
||||
>
|
||||
class optimized_src_stream {
|
||||
CharT buffer[CharacterBufferSize];
|
||||
|
||||
// After the `stream_in(` finishes, `[start, finish)` is
|
||||
// the range to output by `operator >>`
|
||||
const CharT* start;
|
||||
const CharT* finish;
|
||||
public:
|
||||
optimized_src_stream(optimized_src_stream&&) = delete;
|
||||
optimized_src_stream(const optimized_src_stream&) = delete;
|
||||
optimized_src_stream& operator=(optimized_src_stream&&) = delete;
|
||||
optimized_src_stream& operator=(const optimized_src_stream&) = delete;
|
||||
|
||||
optimized_src_stream() noexcept
|
||||
: start(buffer)
|
||||
, finish(buffer + CharacterBufferSize)
|
||||
{}
|
||||
|
||||
const CharT* cbegin() const noexcept {
|
||||
return start;
|
||||
}
|
||||
|
||||
const CharT* cend() const noexcept {
|
||||
return finish;
|
||||
}
|
||||
|
||||
private:
|
||||
bool shl_char(CharT ch) noexcept {
|
||||
Traits::assign(buffer[0], ch);
|
||||
finish = start + 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
template <class T>
|
||||
bool shl_char(T ch) {
|
||||
static_assert(sizeof(T) <= sizeof(CharT),
|
||||
"boost::lexical_cast does not support narrowing of char types."
|
||||
"Use boost::locale instead" );
|
||||
#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
|
||||
std::locale loc;
|
||||
CharT const w = BOOST_USE_FACET(std::ctype<CharT>, loc).widen(ch);
|
||||
#else
|
||||
CharT const w = static_cast<CharT>(ch);
|
||||
#endif
|
||||
Traits::assign(buffer[0], w);
|
||||
finish = start + 1;
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
bool shl_char_array(CharT const* str_value) noexcept {
|
||||
start = str_value;
|
||||
finish = start + Traits::length(str_value);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool shl_char_array_limited(CharT const* str, std::size_t max_size) noexcept {
|
||||
start = str;
|
||||
finish = start;
|
||||
const auto zero = Traits::to_char_type(0);
|
||||
while (finish < start + max_size && zero != *finish) {
|
||||
++ finish;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline bool shl_unsigned(const T n) {
|
||||
CharT* tmp_finish = buffer + CharacterBufferSize;
|
||||
start = lcast_put_unsigned<Traits, T, CharT>(n, tmp_finish).convert();
|
||||
finish = tmp_finish;
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline bool shl_signed(const T n) {
|
||||
CharT* tmp_finish = buffer + CharacterBufferSize;
|
||||
typedef typename boost::detail::lcast::make_unsigned<T>::type utype;
|
||||
CharT* tmp_start = lcast_put_unsigned<Traits, utype, CharT>(lcast_to_unsigned(n), tmp_finish).convert();
|
||||
if (n < 0) {
|
||||
--tmp_start;
|
||||
CharT const minus = lcast_char_constants<CharT>::minus;
|
||||
Traits::assign(*tmp_start, minus);
|
||||
}
|
||||
start = tmp_start;
|
||||
finish = tmp_finish;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool shl_real_type(lcast::exact<float> val, char* begin) {
|
||||
const double val_as_double = static_cast<double>(val.payload);
|
||||
finish = start +
|
||||
boost::core::snprintf(begin, CharacterBufferSize,
|
||||
"%.*g", static_cast<int>(boost::detail::lcast_precision<float>::value), val_as_double);
|
||||
return finish > start;
|
||||
}
|
||||
|
||||
bool shl_real_type(lcast::exact<double> val, char* begin) {
|
||||
finish = start +
|
||||
boost::core::snprintf(begin, CharacterBufferSize,
|
||||
"%.*g", static_cast<int>(boost::detail::lcast_precision<double>::value), val.payload);
|
||||
return finish > start;
|
||||
}
|
||||
|
||||
#ifndef __MINGW32__
|
||||
bool shl_real_type(lcast::exact<long double> val, char* begin) {
|
||||
finish = start +
|
||||
boost::core::snprintf(begin, CharacterBufferSize,
|
||||
"%.*Lg", static_cast<int>(boost::detail::lcast_precision<long double>::value), val.payload );
|
||||
return finish > start;
|
||||
}
|
||||
#else
|
||||
bool shl_real_type(lcast::exact<long double> val, char* begin) {
|
||||
return shl_real_type(lcast::exact<double>{static_cast<double>(val.payload)}, begin);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T)
|
||||
bool shl_real_type(lcast::exact<float> val, wchar_t* begin) {
|
||||
const double val_as_double = static_cast<double>(val.payload);
|
||||
finish = start + boost::core::swprintf(
|
||||
begin, CharacterBufferSize, L"%.*g",
|
||||
static_cast<int>(boost::detail::lcast_precision<float>::value),
|
||||
val_as_double
|
||||
);
|
||||
return finish > start;
|
||||
}
|
||||
|
||||
bool shl_real_type(lcast::exact<double> val, wchar_t* begin) {
|
||||
finish = start + boost::core::swprintf(
|
||||
begin, CharacterBufferSize, L"%.*g",
|
||||
static_cast<int>(boost::detail::lcast_precision<double>::value),
|
||||
val.payload
|
||||
);
|
||||
return finish > start;
|
||||
}
|
||||
|
||||
bool shl_real_type(lcast::exact<long double> val, wchar_t* begin) {
|
||||
finish = start + boost::core::swprintf(
|
||||
begin, CharacterBufferSize, L"%.*Lg",
|
||||
static_cast<int>(boost::detail::lcast_precision<long double>::value),
|
||||
val.payload
|
||||
);
|
||||
return finish > start;
|
||||
}
|
||||
#endif
|
||||
public:
|
||||
template <class C>
|
||||
using enable_if_compatible_char_t = typename std::enable_if<
|
||||
std::is_same<const C, const CharT>::value || (
|
||||
std::is_same<const char, const CharT>::value && (
|
||||
std::is_same<const C, const unsigned char>::value ||
|
||||
std::is_same<const C, const signed char>::value
|
||||
)
|
||||
), bool
|
||||
>::type;
|
||||
|
||||
template<class CharTraits, class Alloc>
|
||||
bool stream_in(lcast::exact<std::basic_string<CharT,CharTraits,Alloc>> x) noexcept {
|
||||
start = x.payload.data();
|
||||
finish = start + x.payload.length();
|
||||
return true;
|
||||
}
|
||||
|
||||
template<class CharTraits, class Alloc>
|
||||
bool stream_in(lcast::exact<boost::container::basic_string<CharT,CharTraits,Alloc>> x) noexcept {
|
||||
start = x.payload.data();
|
||||
finish = start + x.payload.length();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool stream_in(lcast::exact<bool> x) noexcept {
|
||||
CharT const czero = lcast_char_constants<CharT>::zero;
|
||||
Traits::assign(buffer[0], Traits::to_char_type(czero + x.payload));
|
||||
finish = start + 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool stream_in(lcast::exact<boost::conversion::detail::buffer_view<CharT>> x) noexcept {
|
||||
start = x.payload.begin;
|
||||
finish = x.payload.end;
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class C>
|
||||
enable_if_compatible_char_t<C>
|
||||
stream_in(lcast::exact<boost::iterator_range<C*>> x) noexcept {
|
||||
auto buf = boost::conversion::detail::make_buffer_view(x.payload.begin(), x.payload.end());
|
||||
return stream_in(lcast::exact<decltype(buf)>{buf});
|
||||
}
|
||||
|
||||
bool stream_in(lcast::exact<char> x) { return shl_char(x.payload); }
|
||||
bool stream_in(lcast::exact<unsigned char> x) { return shl_char(static_cast<char>(x.payload)); }
|
||||
bool stream_in(lcast::exact<signed char> x) { return shl_char(static_cast<char>(x.payload)); }
|
||||
|
||||
#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
template <class C>
|
||||
typename std::enable_if<boost::detail::is_character<C>::value, bool>::type
|
||||
stream_in(lcast::exact<C> x) { return shl_char(x.payload); }
|
||||
#endif
|
||||
|
||||
template <class Type>
|
||||
enable_if_compatible_char_t<Type>
|
||||
stream_in(lcast::exact<Type*> x) { return shl_char_array(reinterpret_cast<CharT const*>(x.payload)); }
|
||||
|
||||
template <class Type>
|
||||
typename std::enable_if<!std::is_floating_point<Type>::value && boost::detail::lcast::is_signed<Type>::value && !std::is_enum<Type>::value, bool>::type
|
||||
stream_in(lcast::exact<Type> x) { return shl_signed(x.payload); }
|
||||
|
||||
template <class Type>
|
||||
typename std::enable_if<boost::detail::lcast::is_unsigned<Type>::value && !std::is_enum<Type>::value, bool>::type
|
||||
stream_in(lcast::exact<Type> x) { return shl_unsigned(x.payload); }
|
||||
|
||||
template <class Type>
|
||||
auto stream_in(lcast::exact<Type> x) -> decltype(shl_real_type(x, buffer)) {
|
||||
const CharT* inf_nan = detail::get_inf_nan(x.payload, CharT());
|
||||
if (inf_nan) {
|
||||
start = inf_nan;
|
||||
finish = start + Traits::length(inf_nan);
|
||||
return true;
|
||||
}
|
||||
return shl_real_type(x, buffer);
|
||||
}
|
||||
|
||||
template <class C, std::size_t N>
|
||||
enable_if_compatible_char_t<C>
|
||||
stream_in(lcast::exact<boost::array<C, N>> x) noexcept {
|
||||
return shl_char_array_limited(reinterpret_cast<const CharT*>(x.payload.data()), N);
|
||||
}
|
||||
|
||||
template <class C, std::size_t N>
|
||||
enable_if_compatible_char_t<C>
|
||||
stream_in(lcast::exact<std::array<C, N>> x) noexcept {
|
||||
return shl_char_array_limited(reinterpret_cast<const CharT*>(x.payload.data()), N);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
|
||||
template <class C, class CharTraits>
|
||||
enable_if_compatible_char_t<C>
|
||||
stream_in(lcast::exact<std::basic_string_view<C, CharTraits>> x) noexcept {
|
||||
start = reinterpret_cast<const CharT*>(x.payload.data());
|
||||
finish = start + x.payload.size();
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
template <class C, class CharTraits>
|
||||
enable_if_compatible_char_t<C>
|
||||
stream_in(lcast::exact<boost::basic_string_view<C, CharTraits>> x) noexcept {
|
||||
start = reinterpret_cast<const CharT*>(x.payload.data());
|
||||
finish = start + x.payload.size();
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <class CharT, class Traits>
|
||||
class ios_src_stream {
|
||||
typedef detail::lcast::out_stream_t<CharT, Traits> deduced_out_stream_t;
|
||||
typedef detail::lcast::stringbuffer_t<CharT, Traits> deduced_out_buffer_t;
|
||||
|
||||
deduced_out_buffer_t out_buffer;
|
||||
deduced_out_stream_t out_stream;
|
||||
|
||||
const CharT* start = nullptr;
|
||||
const CharT* finish = nullptr;
|
||||
public:
|
||||
ios_src_stream(ios_src_stream&&) = delete;
|
||||
ios_src_stream(const ios_src_stream&) = delete;
|
||||
ios_src_stream& operator=(ios_src_stream&&) = delete;
|
||||
ios_src_stream& operator=(const ios_src_stream&) = delete;
|
||||
|
||||
ios_src_stream(): out_buffer(), out_stream(&out_buffer) {}
|
||||
|
||||
const CharT* cbegin() const noexcept {
|
||||
return start;
|
||||
}
|
||||
|
||||
const CharT* cend() const noexcept {
|
||||
return finish;
|
||||
}
|
||||
private:
|
||||
const deduced_out_buffer_t* get_rdbuf() const {
|
||||
return static_cast<deduced_out_buffer_t*>(
|
||||
out_stream.rdbuf()
|
||||
);
|
||||
}
|
||||
|
||||
template<typename InputStreamable>
|
||||
bool shl_input_streamable(InputStreamable& input) {
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
|
||||
// If you have compilation error at this point, than your STL library
|
||||
// does not support such conversions. Try updating it.
|
||||
static_assert(std::is_same<char, CharT>::value, "");
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
out_stream.exceptions(std::ios::badbit);
|
||||
try {
|
||||
#endif
|
||||
bool const result = !(out_stream << input).fail();
|
||||
const auto* const p = get_rdbuf();
|
||||
start = p->pbase();
|
||||
finish = p->pptr();
|
||||
return result;
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
} catch (const ::std::ios_base::failure& /*f*/) {
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class T>
|
||||
bool shl_char_array(T const* str_value) {
|
||||
static_assert(sizeof(T) <= sizeof(CharT),
|
||||
"boost::lexical_cast does not support narrowing of char types."
|
||||
"Use boost::locale instead" );
|
||||
return shl_input_streamable(str_value);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
bool shl_real(T val) {
|
||||
const CharT* inf_nan = detail::get_inf_nan(val, CharT());
|
||||
if (inf_nan) {
|
||||
start = inf_nan;
|
||||
finish = start + Traits::length(inf_nan);
|
||||
return true;
|
||||
}
|
||||
|
||||
boost::detail::lcast_set_precision(out_stream, &val);
|
||||
return shl_input_streamable(val);
|
||||
}
|
||||
|
||||
public:
|
||||
template <class Type>
|
||||
typename std::enable_if<boost::detail::is_character<Type>::value && sizeof(char) == sizeof(Type), bool>::type
|
||||
stream_in(lcast::exact<const Type*> x) { return shl_char_array(reinterpret_cast<char const*>(x.payload)); }
|
||||
|
||||
template <class Type>
|
||||
typename std::enable_if<boost::detail::is_character<Type>::value && sizeof(char) != sizeof(Type), bool>::type
|
||||
stream_in(lcast::exact<const Type*> x) { return shl_char_array(x.payload); }
|
||||
|
||||
bool stream_in(lcast::exact<float> x) { return shl_real(x.payload); }
|
||||
bool stream_in(lcast::exact<double> x) { return shl_real(x.payload); }
|
||||
bool stream_in(lcast::exact<long double> x) {
|
||||
#ifndef __MINGW32__
|
||||
return shl_real(x.payload);
|
||||
#else
|
||||
return shl_real(static_cast<double>(x.payload));
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class C>
|
||||
typename std::enable_if<boost::detail::is_character<C>::value, bool>::type
|
||||
stream_in(lcast::exact<iterator_range<C*>> x) noexcept {
|
||||
auto buf = boost::conversion::detail::make_buffer_view(x.payload.begin(), x.payload.end());
|
||||
return stream_in(lcast::exact<decltype(buf)>{buf});
|
||||
}
|
||||
|
||||
template <class C>
|
||||
typename std::enable_if<boost::detail::is_character<C>::value, bool>::type
|
||||
stream_in(lcast::exact<iterator_range<const C*>> x) noexcept {
|
||||
auto buf = boost::conversion::detail::make_buffer_view(x.payload.begin(), x.payload.end());
|
||||
return stream_in(lcast::exact<decltype(buf)>{buf});
|
||||
}
|
||||
|
||||
template <class InStreamable>
|
||||
bool stream_in(lcast::exact<InStreamable> x) { return shl_input_streamable(x.payload); }
|
||||
};
|
||||
|
||||
|
||||
template <class CharT, class Traits>
|
||||
class to_target_stream {
|
||||
//`[start, finish)` is the range to output by `operator >>`
|
||||
const CharT* start;
|
||||
const CharT* const finish;
|
||||
|
||||
public:
|
||||
to_target_stream(to_target_stream&&) = delete;
|
||||
to_target_stream(const to_target_stream&) = delete;
|
||||
to_target_stream& operator=(to_target_stream&&) = delete;
|
||||
to_target_stream& operator=(const to_target_stream&) = delete;
|
||||
|
||||
to_target_stream(const CharT* begin, const CharT* end) noexcept
|
||||
: start(begin)
|
||||
, finish(end)
|
||||
{}
|
||||
|
||||
private:
|
||||
template <typename Type>
|
||||
#if defined(__clang__) && (__clang_major__ > 3 || __clang_minor__ > 6)
|
||||
__attribute__((no_sanitize("unsigned-integer-overflow")))
|
||||
#endif
|
||||
bool shr_unsigned(Type& output) {
|
||||
if (start == finish) return false;
|
||||
CharT const minus = lcast_char_constants<CharT>::minus;
|
||||
CharT const plus = lcast_char_constants<CharT>::plus;
|
||||
bool const has_minus = Traits::eq(minus, *start);
|
||||
|
||||
/* We won`t use `start' any more, so no need in decrementing it after */
|
||||
if (has_minus || Traits::eq(plus, *start)) {
|
||||
++start;
|
||||
}
|
||||
|
||||
bool const succeed = lcast_ret_unsigned<Traits, Type, CharT>(output, start, finish).convert();
|
||||
|
||||
if (has_minus) {
|
||||
output = static_cast<Type>(0u - output);
|
||||
}
|
||||
|
||||
return succeed;
|
||||
}
|
||||
|
||||
template <typename Type>
|
||||
#if defined(__clang__) && (__clang_major__ > 3 || __clang_minor__ > 6)
|
||||
__attribute__((no_sanitize("unsigned-integer-overflow")))
|
||||
#endif
|
||||
bool shr_signed(Type& output) {
|
||||
if (start == finish) return false;
|
||||
CharT const minus = lcast_char_constants<CharT>::minus;
|
||||
CharT const plus = lcast_char_constants<CharT>::plus;
|
||||
typedef typename boost::detail::lcast::make_unsigned<Type>::type utype;
|
||||
utype out_tmp = 0;
|
||||
bool const has_minus = Traits::eq(minus, *start);
|
||||
|
||||
/* We won`t use `start' any more, so no need in decrementing it after */
|
||||
if (has_minus || Traits::eq(plus, *start)) {
|
||||
++start;
|
||||
}
|
||||
|
||||
bool succeed = lcast_ret_unsigned<Traits, utype, CharT>(out_tmp, start, finish).convert();
|
||||
if (has_minus) {
|
||||
utype const comp_val = (static_cast<utype>(1) << std::numeric_limits<Type>::digits);
|
||||
succeed = succeed && out_tmp<=comp_val;
|
||||
output = static_cast<Type>(0u - out_tmp);
|
||||
} else {
|
||||
utype const comp_val = static_cast<utype>((std::numeric_limits<Type>::max)());
|
||||
succeed = succeed && out_tmp<=comp_val;
|
||||
output = static_cast<Type>(out_tmp);
|
||||
}
|
||||
return succeed;
|
||||
}
|
||||
|
||||
template<typename InputStreamable>
|
||||
bool shr_using_base_class(InputStreamable& output)
|
||||
{
|
||||
static_assert(
|
||||
!std::is_pointer<InputStreamable>::value,
|
||||
"boost::lexical_cast can not convert to pointers"
|
||||
);
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
|
||||
static_assert(std::is_same<char, CharT>::value,
|
||||
"boost::lexical_cast can not convert, because your STL library does not "
|
||||
"support such conversions. Try updating it."
|
||||
);
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM)
|
||||
std::istrstream stream(start, static_cast<std::istrstream::streamsize>(finish - start));
|
||||
#else
|
||||
typedef detail::lcast::buffer_t<CharT, Traits> buffer_t;
|
||||
buffer_t buf;
|
||||
// Usually `istream` and `basic_istream` do not modify
|
||||
// content of buffer; `buffer_t` assures that this is true
|
||||
buf.setbuf(const_cast<CharT*>(start), static_cast<typename buffer_t::streamsize>(finish - start));
|
||||
#if defined(BOOST_NO_STD_LOCALE)
|
||||
std::istream stream(&buf);
|
||||
#else
|
||||
std::basic_istream<CharT, Traits> stream(&buf);
|
||||
#endif // BOOST_NO_STD_LOCALE
|
||||
#endif // BOOST_NO_STRINGSTREAM
|
||||
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
stream.exceptions(std::ios::badbit);
|
||||
try {
|
||||
#endif
|
||||
stream.unsetf(std::ios::skipws);
|
||||
boost::detail::lcast_set_precision(stream, static_cast<InputStreamable*>(0));
|
||||
|
||||
return (stream >> output)
|
||||
&& (stream.get() == Traits::eof());
|
||||
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
} catch (const ::std::ios_base::failure& /*f*/) {
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
template<class T>
|
||||
inline bool shr_xchar(T& output) noexcept {
|
||||
static_assert(sizeof(CharT) == sizeof(T),
|
||||
"boost::lexical_cast does not support narrowing of character types."
|
||||
"Use boost::locale instead" );
|
||||
bool const ok = (finish - start == 1);
|
||||
if (ok) {
|
||||
CharT out;
|
||||
Traits::assign(out, *start);
|
||||
output = static_cast<T>(out);
|
||||
}
|
||||
return ok;
|
||||
}
|
||||
|
||||
template <std::size_t N, class ArrayT>
|
||||
bool shr_std_array(ArrayT& output) noexcept {
|
||||
const std::size_t size = static_cast<std::size_t>(finish - start);
|
||||
if (size > N - 1) { // `-1` because we need to store \0 at the end
|
||||
return false;
|
||||
}
|
||||
|
||||
std::memcpy(&output[0], start, size * sizeof(CharT));
|
||||
output[size] = Traits::to_char_type(0);
|
||||
return true;
|
||||
}
|
||||
|
||||
public:
|
||||
bool stream_out(unsigned short& output) { return shr_unsigned(output); }
|
||||
bool stream_out(unsigned int& output) { return shr_unsigned(output); }
|
||||
bool stream_out(unsigned long int& output) { return shr_unsigned(output); }
|
||||
bool stream_out(short& output) { return shr_signed(output); }
|
||||
bool stream_out(int& output) { return shr_signed(output); }
|
||||
bool stream_out(long int& output) { return shr_signed(output); }
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
bool stream_out(boost::ulong_long_type& output) { return shr_unsigned(output); }
|
||||
bool stream_out(boost::long_long_type& output) { return shr_signed(output); }
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
bool stream_out(unsigned __int64& output) { return shr_unsigned(output); }
|
||||
bool stream_out(__int64& output) { return shr_signed(output); }
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_HAS_INT128
|
||||
bool stream_out(boost::uint128_type& output) { return shr_unsigned(output); }
|
||||
bool stream_out(boost::int128_type& output) { return shr_signed(output); }
|
||||
#endif
|
||||
|
||||
bool stream_out(char& output) { return shr_xchar(output); }
|
||||
bool stream_out(unsigned char& output) { return shr_xchar(output); }
|
||||
bool stream_out(signed char& output) { return shr_xchar(output); }
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
bool stream_out(wchar_t& output) { return shr_xchar(output); }
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
bool stream_out(char16_t& output) { return shr_xchar(output); }
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
bool stream_out(char32_t& output) { return shr_xchar(output); }
|
||||
#endif
|
||||
template<class CharTraits, class Alloc>
|
||||
bool stream_out(std::basic_string<CharT,CharTraits,Alloc>& str) {
|
||||
str.assign(start, finish); return true;
|
||||
}
|
||||
|
||||
template<class CharTraits, class Alloc>
|
||||
bool stream_out(boost::container::basic_string<CharT,CharTraits,Alloc>& str) {
|
||||
str.assign(start, finish); return true;
|
||||
}
|
||||
|
||||
template <class C, std::size_t N>
|
||||
bool stream_out(std::array<C, N>& output) noexcept {
|
||||
static_assert(sizeof(C) == sizeof(CharT), "");
|
||||
return shr_std_array<N>(output);
|
||||
}
|
||||
|
||||
template <class C, std::size_t N>
|
||||
bool stream_out(boost::array<C, N>& output) noexcept {
|
||||
static_assert(sizeof(C) == sizeof(CharT), "");
|
||||
return shr_std_array<N>(output);
|
||||
}
|
||||
|
||||
bool stream_out(bool& output) noexcept {
|
||||
output = false; // Suppress warning about uninitalized variable
|
||||
|
||||
if (start == finish) return false;
|
||||
CharT const zero = lcast_char_constants<CharT>::zero;
|
||||
CharT const plus = lcast_char_constants<CharT>::plus;
|
||||
CharT const minus = lcast_char_constants<CharT>::minus;
|
||||
|
||||
const CharT* const dec_finish = finish - 1;
|
||||
output = Traits::eq(*dec_finish, zero + 1);
|
||||
if (!output && !Traits::eq(*dec_finish, zero)) {
|
||||
return false; // Does not ends on '0' or '1'
|
||||
}
|
||||
|
||||
if (start == dec_finish) return true;
|
||||
|
||||
// We may have sign at the beginning
|
||||
if (Traits::eq(plus, *start) || (Traits::eq(minus, *start) && !output)) {
|
||||
++ start;
|
||||
}
|
||||
|
||||
// Skipping zeros
|
||||
while (start != dec_finish) {
|
||||
if (!Traits::eq(zero, *start)) {
|
||||
return false; // Not a zero => error
|
||||
}
|
||||
|
||||
++ start;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private:
|
||||
// Not optimised converter
|
||||
template <class T>
|
||||
bool float_types_converter_internal(T& output) {
|
||||
if (parse_inf_nan(start, finish, output)) return true;
|
||||
bool const return_value = shr_using_base_class(output);
|
||||
|
||||
/* Some compilers and libraries successfully
|
||||
* parse 'inf', 'INFINITY', '1.0E', '1.0E-'...
|
||||
* We are trying to provide a unified behaviour,
|
||||
* so we just forbid such conversions (as some
|
||||
* of the most popular compilers/libraries do)
|
||||
* */
|
||||
CharT const minus = lcast_char_constants<CharT>::minus;
|
||||
CharT const plus = lcast_char_constants<CharT>::plus;
|
||||
CharT const capital_e = lcast_char_constants<CharT>::capital_e;
|
||||
CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
|
||||
if ( return_value &&
|
||||
(
|
||||
Traits::eq(*(finish-1), lowercase_e) // 1.0e
|
||||
|| Traits::eq(*(finish-1), capital_e) // 1.0E
|
||||
|| Traits::eq(*(finish-1), minus) // 1.0e- or 1.0E-
|
||||
|| Traits::eq(*(finish-1), plus) // 1.0e+ or 1.0E+
|
||||
)
|
||||
) return false;
|
||||
|
||||
return return_value;
|
||||
}
|
||||
|
||||
public:
|
||||
bool stream_out(float& output) { return float_types_converter_internal(output); }
|
||||
bool stream_out(double& output) { return float_types_converter_internal(output); }
|
||||
bool stream_out(long double& output) { return float_types_converter_internal(output); }
|
||||
|
||||
// Generic istream-based algorithm.
|
||||
// lcast_streambuf_for_target<InputStreamable>::value is true.
|
||||
template <typename InputStreamable>
|
||||
bool stream_out(InputStreamable& output) {
|
||||
return shr_using_base_class(output);
|
||||
}
|
||||
};
|
||||
|
||||
}}} // namespace boost::detail::lcast
|
||||
|
||||
#undef BOOST_LCAST_NO_WCHAR_T
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
|
||||
|
||||
@@ -1,190 +0,0 @@
|
||||
// Copyright Kevlin Henney, 2000-2005.
|
||||
// Copyright Alexander Nasonov, 2006-2010.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// what: lexical_cast custom keyword cast
|
||||
// who: contributed by Kevlin Henney,
|
||||
// enhanced with contributions from Terje Slettebo,
|
||||
// with additional fixes and suggestions from Gennaro Prota,
|
||||
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
|
||||
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
|
||||
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
|
||||
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2016
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
|
||||
#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <type_traits>
|
||||
#include <boost/core/cmath.hpp>
|
||||
#include <boost/limits.hpp>
|
||||
|
||||
#endif // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
|
||||
#include <boost/lexical_cast/detail/type_traits.hpp>
|
||||
|
||||
namespace boost { namespace detail {
|
||||
|
||||
template <class Source, class Target>
|
||||
bool ios_numeric_comparer_float(Source x, Source y) noexcept {
|
||||
return x == y
|
||||
|| (boost::core::isnan(x) && boost::core::isnan(y))
|
||||
|| (x < (std::numeric_limits<Target>::min)())
|
||||
;
|
||||
}
|
||||
|
||||
template <class RangeType, class T>
|
||||
constexpr bool is_out_of_range_for(T value) noexcept {
|
||||
return value > static_cast<T>((std::numeric_limits<RangeType>::max)())
|
||||
|| value < static_cast<T>((std::numeric_limits<RangeType>::min)())
|
||||
|| boost::core::isnan(value);
|
||||
}
|
||||
|
||||
|
||||
// integral -> integral
|
||||
template <typename Target, typename Source>
|
||||
typename std::enable_if<
|
||||
!std::is_floating_point<Source>::value && !std::is_floating_point<Target>::value, bool
|
||||
>::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
|
||||
const Target target_tmp = static_cast<Target>(arg);
|
||||
const Source arg_restored = static_cast<Source>(target_tmp);
|
||||
if (arg == arg_restored) {
|
||||
result = target_tmp;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// integral -> floating point
|
||||
template <typename Target, typename Source>
|
||||
typename std::enable_if<
|
||||
!std::is_floating_point<Source>::value && std::is_floating_point<Target>::value, bool
|
||||
>::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
|
||||
const Target target_tmp = static_cast<Target>(arg);
|
||||
result = target_tmp;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// floating point -> floating point
|
||||
template <typename Target, typename Source>
|
||||
typename std::enable_if<
|
||||
std::is_floating_point<Source>::value && std::is_floating_point<Target>::value, bool
|
||||
>::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
|
||||
const Target target_tmp = static_cast<Target>(arg);
|
||||
const Source arg_restored = static_cast<Source>(target_tmp);
|
||||
if (detail::ios_numeric_comparer_float<Source, Target>(arg, arg_restored)) {
|
||||
result = target_tmp;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// floating point -> integral
|
||||
template <typename Target, typename Source>
|
||||
typename std::enable_if<
|
||||
std::is_floating_point<Source>::value && !std::is_floating_point<Target>::value, bool
|
||||
>::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
|
||||
if (detail::is_out_of_range_for<Target>(arg)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const Target target_tmp = static_cast<Target>(arg);
|
||||
const Source arg_restored = static_cast<Source>(target_tmp);
|
||||
if (arg == arg_restored /* special values are handled in detail::is_out_of_range_for */) {
|
||||
result = target_tmp;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
struct lexical_cast_dynamic_num_not_ignoring_minus
|
||||
{
|
||||
template <typename Target, typename Source>
|
||||
static inline bool try_convert(Source arg, Target& result) noexcept {
|
||||
return boost::detail::noexcept_numeric_convert<Target, Source >(arg, result);
|
||||
}
|
||||
};
|
||||
|
||||
struct lexical_cast_dynamic_num_ignoring_minus
|
||||
{
|
||||
template <typename Target, typename Source>
|
||||
#if defined(__clang__) && (__clang_major__ > 3 || __clang_minor__ > 6)
|
||||
__attribute__((no_sanitize("unsigned-integer-overflow")))
|
||||
#endif
|
||||
static inline bool try_convert(Source arg, Target& result) noexcept {
|
||||
typedef typename std::conditional<
|
||||
std::is_floating_point<Source>::value,
|
||||
std::conditional<true, Source, Source>, // std::type_identity emulation
|
||||
boost::detail::lcast::make_unsigned<Source>
|
||||
>::type usource_lazy_t;
|
||||
typedef typename usource_lazy_t::type usource_t;
|
||||
|
||||
if (arg < 0) {
|
||||
const bool res = boost::detail::noexcept_numeric_convert<Target, usource_t>(
|
||||
static_cast<usource_t>(0u - static_cast<usource_t>(arg)), result
|
||||
);
|
||||
result = static_cast<Target>(0u - result);
|
||||
return res;
|
||||
} else {
|
||||
return boost::detail::noexcept_numeric_convert<Target, usource_t>(arg, result);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/*
|
||||
* dynamic_num_converter_impl follows the rules:
|
||||
* 1) If Source can be converted to Target without precision loss and
|
||||
* without overflows, then assign Source to Target and return
|
||||
*
|
||||
* 2) If Source is less than 0 and Target is an unsigned integer,
|
||||
* then negate Source, check the requirements of rule 1) and if
|
||||
* successful, assign static_casted Source to Target and return
|
||||
*
|
||||
* 3) Otherwise throw a bad_lexical_cast exception
|
||||
*
|
||||
*
|
||||
* Rule 2) required because boost::lexical_cast has the behavior of
|
||||
* stringstream, which uses the rules of scanf for conversions. And
|
||||
* in the C99 standard for unsigned input value minus sign is
|
||||
* optional, so if a negative number is read, no errors will arise
|
||||
* and the result will be the two's complement.
|
||||
*/
|
||||
template <typename Target, typename Source>
|
||||
struct dynamic_num_converter_impl
|
||||
{
|
||||
static inline bool try_convert(Source arg, Target& result) noexcept {
|
||||
typedef typename std::conditional<
|
||||
boost::detail::lcast::is_unsigned<Target>::value &&
|
||||
(boost::detail::lcast::is_signed<Source>::value || std::is_floating_point<Source>::value) &&
|
||||
!(std::is_same<Source, bool>::value) &&
|
||||
!(std::is_same<Target, bool>::value),
|
||||
lexical_cast_dynamic_num_ignoring_minus,
|
||||
lexical_cast_dynamic_num_not_ignoring_minus
|
||||
>::type caster_type;
|
||||
|
||||
return caster_type::try_convert(arg, result);
|
||||
}
|
||||
};
|
||||
|
||||
}} // namespace boost::detail
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
|
||||
|
||||
@@ -1,195 +0,0 @@
|
||||
// Copyright Kevlin Henney, 2000-2005.
|
||||
// Copyright Alexander Nasonov, 2006-2010.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// what: lexical_cast custom keyword cast
|
||||
// who: contributed by Kevlin Henney,
|
||||
// enhanced with contributions from Terje Slettebo,
|
||||
// with additional fixes and suggestions from Gennaro Prota,
|
||||
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
|
||||
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
|
||||
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
|
||||
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP
|
||||
#define BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
|
||||
#define BOOST_LCAST_NO_WCHAR_T
|
||||
#endif
|
||||
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <boost/core/cmath.hpp>
|
||||
#include <cstddef>
|
||||
#include <cstring>
|
||||
#endif // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
|
||||
#include <boost/lexical_cast/detail/lcast_char_constants.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace detail
|
||||
{
|
||||
template <class CharT>
|
||||
bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) noexcept {
|
||||
for( unsigned int i=0; i < len; ++i ) {
|
||||
if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Returns true and sets the correct value if found NaN or Inf. */
|
||||
template <class CharT, class T>
|
||||
inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
|
||||
, const CharT* lc_NAN, const CharT* lc_nan
|
||||
, const CharT* lc_INFINITY, const CharT* lc_infinity
|
||||
, const CharT opening_brace, const CharT closing_brace) noexcept
|
||||
{
|
||||
if (begin == end) return false;
|
||||
const CharT minus = lcast_char_constants<CharT>::minus;
|
||||
const CharT plus = lcast_char_constants<CharT>::plus;
|
||||
const int inifinity_size = 8; // == sizeof("infinity") - 1
|
||||
|
||||
/* Parsing +/- */
|
||||
bool const has_minus = (*begin == minus);
|
||||
if (has_minus || *begin == plus) {
|
||||
++ begin;
|
||||
}
|
||||
|
||||
if (end - begin < 3) return false;
|
||||
if (lc_iequal(begin, lc_nan, lc_NAN, 3)) {
|
||||
begin += 3;
|
||||
if (end != begin) {
|
||||
/* It is 'nan(...)' or some bad input*/
|
||||
|
||||
if (end - begin < 2) return false; // bad input
|
||||
-- end;
|
||||
if (*begin != opening_brace || *end != closing_brace) return false; // bad input
|
||||
}
|
||||
|
||||
if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN();
|
||||
else value = boost::core::copysign(std::numeric_limits<T>::quiet_NaN(), static_cast<T>(-1));
|
||||
return true;
|
||||
} else if (
|
||||
( /* 'INF' or 'inf' */
|
||||
end - begin == 3 // 3 == sizeof('inf') - 1
|
||||
&& lc_iequal(begin, lc_infinity, lc_INFINITY, 3)
|
||||
)
|
||||
||
|
||||
( /* 'INFINITY' or 'infinity' */
|
||||
end - begin == inifinity_size
|
||||
&& lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size)
|
||||
)
|
||||
)
|
||||
{
|
||||
if( !has_minus ) value = std::numeric_limits<T>::infinity();
|
||||
else value = -std::numeric_limits<T>::infinity();
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
template <class CharT, class T>
|
||||
const CharT* get_inf_nan_impl(T value
|
||||
, const CharT* lc_nan
|
||||
, const CharT* lc_minus_nan
|
||||
, const CharT* lc_infinity
|
||||
, const CharT* lc_minus_infinity) noexcept
|
||||
{
|
||||
if (boost::core::isnan(value)) {
|
||||
if (boost::core::signbit(value)) {
|
||||
return lc_minus_nan;
|
||||
}
|
||||
return lc_nan;
|
||||
} else if (boost::core::isinf(value)) {
|
||||
if (boost::core::signbit(value)) {
|
||||
return lc_minus_infinity;
|
||||
}
|
||||
return lc_infinity;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
template <class T>
|
||||
bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) noexcept {
|
||||
return parse_inf_nan_impl(begin, end, value
|
||||
, L"NAN", L"nan"
|
||||
, L"INFINITY", L"infinity"
|
||||
, L'(', L')');
|
||||
}
|
||||
|
||||
template <class T>
|
||||
const wchar_t* get_inf_nan(T value, wchar_t) noexcept {
|
||||
return detail::get_inf_nan_impl(value, L"nan", L"-nan", L"inf", L"-inf");
|
||||
}
|
||||
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
template <class T>
|
||||
bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) noexcept {
|
||||
return parse_inf_nan_impl(begin, end, value
|
||||
, u"NAN", u"nan"
|
||||
, u"INFINITY", u"infinity"
|
||||
, u'(', u')');
|
||||
}
|
||||
|
||||
template <class T>
|
||||
const char16_t* get_inf_nan(T value, char16_t) noexcept {
|
||||
return detail::get_inf_nan_impl(value, u"nan", u"-nan", u"inf", u"-inf");
|
||||
}
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
template <class T>
|
||||
bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) noexcept {
|
||||
return parse_inf_nan_impl(begin, end, value
|
||||
, U"NAN", U"nan"
|
||||
, U"INFINITY", U"infinity"
|
||||
, U'(', U')');
|
||||
}
|
||||
|
||||
template <class T>
|
||||
const char32_t* get_inf_nan(T value, char32_t) noexcept {
|
||||
return detail::get_inf_nan_impl(value, U"nan", U"-nan", U"inf", U"-inf");
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class CharT, class T>
|
||||
bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) noexcept {
|
||||
return parse_inf_nan_impl(begin, end, value
|
||||
, "NAN", "nan"
|
||||
, "INFINITY", "infinity"
|
||||
, '(', ')');
|
||||
}
|
||||
|
||||
template <class T>
|
||||
const char* get_inf_nan(T value, char) noexcept {
|
||||
return detail::get_inf_nan_impl(value, "nan", "-nan", "inf", "-inf");
|
||||
}
|
||||
}
|
||||
} // namespace boost
|
||||
|
||||
#undef BOOST_LCAST_NO_WCHAR_T
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP
|
||||
|
||||
@@ -1,60 +0,0 @@
|
||||
// Copyright Kevlin Henney, 2000-2005.
|
||||
// Copyright Alexander Nasonov, 2006-2010.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// what: lexical_cast custom keyword cast
|
||||
// who: contributed by Kevlin Henney,
|
||||
// enhanced with contributions from Terje Slettebo,
|
||||
// with additional fixes and suggestions from Gennaro Prota,
|
||||
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
|
||||
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
|
||||
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
|
||||
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP
|
||||
#define BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
#endif // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
|
||||
namespace boost { namespace detail {
|
||||
|
||||
// returns true, if T is one of the character types
|
||||
template < typename T >
|
||||
using is_character = std::integral_constant<
|
||||
bool,
|
||||
std::is_same< T, char >::value ||
|
||||
#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
|
||||
std::is_same< T, wchar_t >::value ||
|
||||
#endif
|
||||
#ifndef BOOST_NO_CXX11_CHAR16_T
|
||||
std::is_same< T, char16_t >::value ||
|
||||
#endif
|
||||
#ifndef BOOST_NO_CXX11_CHAR32_T
|
||||
std::is_same< T, char32_t >::value ||
|
||||
#endif
|
||||
std::is_same< T, unsigned char >::value ||
|
||||
std::is_same< T, signed char >::value
|
||||
>;
|
||||
|
||||
}}
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP
|
||||
|
||||
@@ -1,82 +0,0 @@
|
||||
// Copyright Kevlin Henney, 2000-2005.
|
||||
// Copyright Alexander Nasonov, 2006-2010.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_BASIC_UNLOCKEDBUF_HPP
|
||||
#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_BASIC_UNLOCKEDBUF_HPP
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef BOOST_NO_STRINGSTREAM
|
||||
#include <strstream>
|
||||
#else
|
||||
#include <sstream>
|
||||
#endif
|
||||
|
||||
#include <boost/detail/basic_pointerbuf.hpp>
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
# include <cwchar>
|
||||
#endif
|
||||
#endif // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
|
||||
namespace boost { namespace detail { namespace lcast {
|
||||
|
||||
// acts as a stream buffer which wraps around a pair of pointers
|
||||
// and gives acces to internals
|
||||
template <class BufferType, class CharT>
|
||||
class basic_unlockedbuf : public basic_pointerbuf<CharT, BufferType> {
|
||||
public:
|
||||
typedef basic_pointerbuf<CharT, BufferType> base_type;
|
||||
typedef typename base_type::streamsize streamsize;
|
||||
|
||||
using base_type::pptr;
|
||||
using base_type::pbase;
|
||||
using base_type::setbuf;
|
||||
};
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM)
|
||||
template <class CharT, class Traits>
|
||||
using out_stream_t = std::ostream;
|
||||
|
||||
template <class CharT, class Traits>
|
||||
using stringbuffer_t = basic_unlockedbuf<std::strstreambuf, char>;
|
||||
#elif defined(BOOST_NO_STD_LOCALE)
|
||||
template <class CharT, class Traits>
|
||||
using out_stream_t = std::ostream;
|
||||
|
||||
template <class CharT, class Traits>
|
||||
using stringbuffer_t = basic_unlockedbuf<std::stringbuf, char>;
|
||||
|
||||
template <class CharT, class Traits>
|
||||
using buffer_t = basic_unlockedbuf<std::streambuf, char>;
|
||||
#else
|
||||
template <class CharT, class Traits>
|
||||
using out_stream_t = std::basic_ostream<CharT, Traits>;
|
||||
|
||||
template <class CharT, class Traits>
|
||||
using stringbuffer_t = basic_unlockedbuf<std::basic_stringbuf<CharT, Traits>, CharT>;
|
||||
|
||||
template <class CharT, class Traits>
|
||||
using buffer_t = basic_unlockedbuf<std::basic_streambuf<CharT, Traits>, CharT>;
|
||||
#endif
|
||||
|
||||
}}} // namespace boost::detail::lcast
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_BASIC_UNLOCKEDBUF_HPP
|
||||
|
||||
@@ -1,53 +0,0 @@
|
||||
// Copyright Kevlin Henney, 2000-2005.
|
||||
// Copyright Alexander Nasonov, 2006-2010.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// what: lexical_cast custom keyword cast
|
||||
// who: contributed by Kevlin Henney,
|
||||
// enhanced with contributions from Terje Slettebo,
|
||||
// with additional fixes and suggestions from Gennaro Prota,
|
||||
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
|
||||
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
|
||||
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
|
||||
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_DETAIL_LCAST_CHAR_CONSTANTS_HPP
|
||||
#define BOOST_LEXICAL_CAST_DETAIL_LCAST_CHAR_CONSTANTS_HPP
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
#endif // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail // '0', '-', '+', 'e', 'E' and '.' constants
|
||||
{
|
||||
template < typename Char >
|
||||
struct lcast_char_constants {
|
||||
// We check in tests assumption that static casted character is
|
||||
// equal to correctly written C++ literal: U'0' == static_cast<char32_t>('0')
|
||||
BOOST_STATIC_CONSTANT(Char, zero = static_cast<Char>('0'));
|
||||
BOOST_STATIC_CONSTANT(Char, minus = static_cast<Char>('-'));
|
||||
BOOST_STATIC_CONSTANT(Char, plus = static_cast<Char>('+'));
|
||||
BOOST_STATIC_CONSTANT(Char, lowercase_e = static_cast<Char>('e'));
|
||||
BOOST_STATIC_CONSTANT(Char, capital_e = static_cast<Char>('E'));
|
||||
BOOST_STATIC_CONSTANT(Char, c_decimal_separator = static_cast<Char>('.'));
|
||||
};
|
||||
}
|
||||
} // namespace boost
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_DETAIL_LCAST_CHAR_CONSTANTS_HPP
|
||||
|
||||
@@ -1,95 +0,0 @@
|
||||
// Copyright Alexander Nasonov & Paul A. Bristow 2006.
|
||||
|
||||
// Use, modification and distribution are subject to 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)
|
||||
|
||||
#ifndef BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
|
||||
#define BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <climits>
|
||||
#include <ios>
|
||||
#include <limits>
|
||||
|
||||
#endif // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
|
||||
namespace boost { namespace detail {
|
||||
|
||||
// Calculate an argument to pass to std::ios_base::precision from
|
||||
// lexical_cast.
|
||||
template<class T>
|
||||
struct lcast_precision
|
||||
{
|
||||
using limits = std::numeric_limits<T>;
|
||||
|
||||
static constexpr bool use_default_precision =
|
||||
!limits::is_specialized || limits::is_exact
|
||||
;
|
||||
|
||||
static constexpr bool is_specialized_bin =
|
||||
!use_default_precision &&
|
||||
limits::radix == 2 && limits::digits > 0
|
||||
;
|
||||
|
||||
static constexpr bool is_specialized_dec =
|
||||
!use_default_precision &&
|
||||
limits::radix == 10 && limits::digits10 > 0
|
||||
;
|
||||
|
||||
static constexpr std::streamsize streamsize_max =
|
||||
(std::numeric_limits<std::streamsize>::max)()
|
||||
;
|
||||
|
||||
static constexpr unsigned int precision_dec = limits::digits10 + 1U;
|
||||
|
||||
static_assert(!is_specialized_dec ||
|
||||
precision_dec <= streamsize_max + 0UL
|
||||
, "");
|
||||
|
||||
static constexpr unsigned long precision_bin =
|
||||
2UL + limits::digits * 30103UL / 100000UL
|
||||
;
|
||||
|
||||
static_assert(!is_specialized_bin ||
|
||||
(limits::digits + 0UL < ULONG_MAX / 30103UL &&
|
||||
precision_bin > limits::digits10 + 0UL &&
|
||||
precision_bin <= streamsize_max + 0UL)
|
||||
, "");
|
||||
|
||||
static constexpr std::streamsize value =
|
||||
is_specialized_bin ? precision_bin
|
||||
: is_specialized_dec ? precision_dec : 6
|
||||
;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
inline void lcast_set_precision(std::ios_base& stream, T*)
|
||||
{
|
||||
stream.precision(lcast_precision<T>::value);
|
||||
}
|
||||
|
||||
template<class Source, class Target>
|
||||
inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
|
||||
{
|
||||
std::streamsize const s = lcast_precision<Source>::value;
|
||||
std::streamsize const t = lcast_precision<Target*>::value;
|
||||
stream.precision(s > t ? s : t);
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
|
||||
|
||||
@@ -1,308 +0,0 @@
|
||||
// Copyright Kevlin Henney, 2000-2005.
|
||||
// Copyright Alexander Nasonov, 2006-2010.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// what: lexical_cast custom keyword cast
|
||||
// who: contributed by Kevlin Henney,
|
||||
// enhanced with contributions from Terje Slettebo,
|
||||
// with additional fixes and suggestions from Gennaro Prota,
|
||||
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
|
||||
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
|
||||
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
|
||||
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_DETAIL_LCAST_UNSIGNED_CONVERTERS_HPP
|
||||
#define BOOST_LEXICAL_CAST_DETAIL_LCAST_UNSIGNED_CONVERTERS_HPP
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <climits>
|
||||
#include <cstddef>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <type_traits>
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <boost/lexical_cast/detail/type_traits.hpp>
|
||||
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
# include <locale>
|
||||
#else
|
||||
# ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
|
||||
// Getting error at this point means, that your STL library is old/lame/misconfigured.
|
||||
// If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE,
|
||||
// but beware: lexical_cast will understand only 'C' locale delimeters and thousands
|
||||
// separators.
|
||||
# error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force "
|
||||
# error "boost::lexical_cast to use only 'C' locale during conversions."
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#include <boost/lexical_cast/detail/lcast_char_constants.hpp>
|
||||
#include <boost/core/noncopyable.hpp>
|
||||
#endif // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
|
||||
#include <boost/lexical_cast/detail/lcast_char_constants.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail // lcast_to_unsigned
|
||||
{
|
||||
template<class T>
|
||||
#if defined(__clang__) && (__clang_major__ > 3 || __clang_minor__ > 6)
|
||||
__attribute__((no_sanitize("unsigned-integer-overflow")))
|
||||
#endif
|
||||
inline
|
||||
typename boost::detail::lcast::make_unsigned<T>::type lcast_to_unsigned(const T value) noexcept {
|
||||
typedef typename boost::detail::lcast::make_unsigned<T>::type result_type;
|
||||
return value < 0
|
||||
? static_cast<result_type>(0u - static_cast<result_type>(value))
|
||||
: static_cast<result_type>(value);
|
||||
}
|
||||
}
|
||||
|
||||
namespace detail // lcast_put_unsigned
|
||||
{
|
||||
template <class Traits, class T, class CharT>
|
||||
class lcast_put_unsigned: boost::noncopyable {
|
||||
typedef typename Traits::int_type int_type;
|
||||
typename std::conditional<
|
||||
(sizeof(unsigned) > sizeof(T))
|
||||
, unsigned
|
||||
, T
|
||||
>::type m_value;
|
||||
CharT* m_finish;
|
||||
CharT const m_czero;
|
||||
int_type const m_zero;
|
||||
|
||||
public:
|
||||
lcast_put_unsigned(const T n_param, CharT* finish) noexcept
|
||||
: m_value(n_param), m_finish(finish)
|
||||
, m_czero(lcast_char_constants<CharT>::zero), m_zero(Traits::to_int_type(m_czero))
|
||||
{
|
||||
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
||||
static_assert(!std::numeric_limits<T>::is_signed, "");
|
||||
#endif
|
||||
}
|
||||
|
||||
CharT* convert() {
|
||||
#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
|
||||
std::locale loc;
|
||||
if (loc == std::locale::classic()) {
|
||||
return main_convert_loop();
|
||||
}
|
||||
|
||||
typedef std::numpunct<CharT> numpunct;
|
||||
numpunct const& np = BOOST_USE_FACET(numpunct, loc);
|
||||
std::string const grouping = np.grouping();
|
||||
std::string::size_type const grouping_size = grouping.size();
|
||||
|
||||
if (!grouping_size || grouping[0] <= 0) {
|
||||
return main_convert_loop();
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
||||
// Check that ulimited group is unreachable:
|
||||
static_assert(std::numeric_limits<T>::digits10 < CHAR_MAX, "");
|
||||
#endif
|
||||
CharT const thousands_sep = np.thousands_sep();
|
||||
std::string::size_type group = 0; // current group number
|
||||
char last_grp_size = grouping[0];
|
||||
char left = last_grp_size;
|
||||
|
||||
do {
|
||||
if (left == 0) {
|
||||
++group;
|
||||
if (group < grouping_size) {
|
||||
char const grp_size = grouping[group];
|
||||
last_grp_size = (grp_size <= 0 ? static_cast<char>(CHAR_MAX) : grp_size);
|
||||
}
|
||||
|
||||
left = last_grp_size;
|
||||
--m_finish;
|
||||
Traits::assign(*m_finish, thousands_sep);
|
||||
}
|
||||
|
||||
--left;
|
||||
} while (main_convert_iteration());
|
||||
|
||||
return m_finish;
|
||||
#else
|
||||
return main_convert_loop();
|
||||
#endif
|
||||
}
|
||||
|
||||
private:
|
||||
inline bool main_convert_iteration() noexcept {
|
||||
--m_finish;
|
||||
int_type const digit = static_cast<int_type>(m_value % 10U);
|
||||
Traits::assign(*m_finish, Traits::to_char_type(m_zero + digit));
|
||||
m_value /= 10;
|
||||
return !!m_value; // suppressing warnings
|
||||
}
|
||||
|
||||
inline CharT* main_convert_loop() noexcept {
|
||||
while (main_convert_iteration());
|
||||
return m_finish;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
namespace detail // lcast_ret_unsigned
|
||||
{
|
||||
template <class Traits, class T, class CharT>
|
||||
class lcast_ret_unsigned: boost::noncopyable {
|
||||
bool m_multiplier_overflowed;
|
||||
T m_multiplier;
|
||||
T& m_value;
|
||||
const CharT* const m_begin;
|
||||
const CharT* m_end;
|
||||
|
||||
public:
|
||||
lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) noexcept
|
||||
: m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end)
|
||||
{
|
||||
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
||||
static_assert(!std::numeric_limits<T>::is_signed, "");
|
||||
|
||||
// GCC when used with flag -std=c++0x may not have std::numeric_limits
|
||||
// specializations for __int128 and unsigned __int128 types.
|
||||
// Try compilation with -std=gnu++0x or -std=gnu++11.
|
||||
//
|
||||
// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40856
|
||||
static_assert(std::numeric_limits<T>::is_specialized,
|
||||
"std::numeric_limits are not specialized for integral type passed to boost::lexical_cast"
|
||||
);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline bool convert() {
|
||||
CharT const czero = lcast_char_constants<CharT>::zero;
|
||||
--m_end;
|
||||
m_value = static_cast<T>(0);
|
||||
|
||||
if (m_begin > m_end || *m_end < czero || *m_end >= czero + 10)
|
||||
return false;
|
||||
m_value = static_cast<T>(*m_end - czero);
|
||||
--m_end;
|
||||
|
||||
#ifdef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
|
||||
return main_convert_loop();
|
||||
#else
|
||||
std::locale loc;
|
||||
if (loc == std::locale::classic()) {
|
||||
return main_convert_loop();
|
||||
}
|
||||
|
||||
typedef std::numpunct<CharT> numpunct;
|
||||
numpunct const& np = BOOST_USE_FACET(numpunct, loc);
|
||||
std::string const& grouping = np.grouping();
|
||||
std::string::size_type const grouping_size = grouping.size();
|
||||
|
||||
/* According to Programming languages - C++
|
||||
* we MUST check for correct grouping
|
||||
*/
|
||||
if (!grouping_size || grouping[0] <= 0) {
|
||||
return main_convert_loop();
|
||||
}
|
||||
|
||||
unsigned char current_grouping = 0;
|
||||
CharT const thousands_sep = np.thousands_sep();
|
||||
char remained = static_cast<char>(grouping[current_grouping] - 1);
|
||||
|
||||
for (;m_end >= m_begin; --m_end)
|
||||
{
|
||||
if (remained) {
|
||||
if (!main_convert_iteration()) {
|
||||
return false;
|
||||
}
|
||||
--remained;
|
||||
} else {
|
||||
if ( !Traits::eq(*m_end, thousands_sep) ) //|| begin == end ) return false;
|
||||
{
|
||||
/*
|
||||
* According to Programming languages - C++
|
||||
* Digit grouping is checked. That is, the positions of discarded
|
||||
* separators is examined for consistency with
|
||||
* use_facet<numpunct<charT> >(loc ).grouping()
|
||||
*
|
||||
* BUT what if there is no separators at all and grouping()
|
||||
* is not empty? Well, we have no extraced separators, so we
|
||||
* won`t check them for consistency. This will allow us to
|
||||
* work with "C" locale from other locales
|
||||
*/
|
||||
return main_convert_loop();
|
||||
} else {
|
||||
if (m_begin == m_end) return false;
|
||||
if (current_grouping < grouping_size - 1) ++current_grouping;
|
||||
remained = grouping[current_grouping];
|
||||
}
|
||||
}
|
||||
} /*for*/
|
||||
|
||||
return true;
|
||||
#endif
|
||||
}
|
||||
|
||||
private:
|
||||
// Iteration that does not care about grouping/separators and assumes that all
|
||||
// input characters are digits
|
||||
#if defined(__clang__) && (__clang_major__ > 3 || __clang_minor__ > 6)
|
||||
__attribute__((no_sanitize("unsigned-integer-overflow")))
|
||||
#endif
|
||||
inline bool main_convert_iteration() noexcept {
|
||||
CharT const czero = lcast_char_constants<CharT>::zero;
|
||||
T const maxv = (std::numeric_limits<T>::max)();
|
||||
|
||||
m_multiplier_overflowed = m_multiplier_overflowed || (maxv/10 < m_multiplier);
|
||||
m_multiplier = static_cast<T>(m_multiplier * 10);
|
||||
|
||||
T const dig_value = static_cast<T>(*m_end - czero);
|
||||
T const new_sub_value = static_cast<T>(m_multiplier * dig_value);
|
||||
|
||||
// We must correctly handle situations like `000000000000000000000000000001`.
|
||||
// So we take care of overflow only if `dig_value` is not '0'.
|
||||
if (*m_end < czero || *m_end >= czero + 10 // checking for correct digit
|
||||
|| (dig_value && ( // checking for overflow of ...
|
||||
m_multiplier_overflowed // ... multiplier
|
||||
|| static_cast<T>(maxv / dig_value) < m_multiplier // ... subvalue
|
||||
|| static_cast<T>(maxv - new_sub_value) < m_value // ... whole expression
|
||||
))
|
||||
) return false;
|
||||
|
||||
m_value = static_cast<T>(m_value + new_sub_value);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool main_convert_loop() noexcept {
|
||||
for ( ; m_end >= m_begin; --m_end) {
|
||||
if (!main_convert_iteration()) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
};
|
||||
}
|
||||
} // namespace boost
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_DETAIL_LCAST_UNSIGNED_CONVERTERS_HPP
|
||||
|
||||
@@ -1,81 +0,0 @@
|
||||
// Copyright Peter Dimov, 2025.
|
||||
// Copyright Romain Geissler, 2025.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_DETAIL_TYPE_TRAITS_HPP
|
||||
#define BOOST_LEXICAL_CAST_DETAIL_TYPE_TRAITS_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
namespace boost { namespace detail { namespace lcast {
|
||||
|
||||
// libstdc++ from gcc <= 15 doesn't provide support for __int128 in the standard traits,
|
||||
// so define them explicitly.
|
||||
// This was fixed with gcc >= 16, so we may eventually remove this workaround and use
|
||||
// directly the standard type_traits.
|
||||
|
||||
template<class T> struct is_integral: public std::is_integral<T>
|
||||
{
|
||||
};
|
||||
|
||||
template<class T> struct is_signed: public std::is_signed<T>
|
||||
{
|
||||
};
|
||||
|
||||
template<class T> struct is_unsigned: public std::is_unsigned<T>
|
||||
{
|
||||
};
|
||||
|
||||
template<class T> struct make_unsigned: public std::make_unsigned<T>
|
||||
{
|
||||
};
|
||||
|
||||
#if defined(__SIZEOF_INT128__)
|
||||
|
||||
template<> struct is_integral<__int128_t>: public std::true_type
|
||||
{
|
||||
};
|
||||
|
||||
template<> struct is_integral<__uint128_t>: public std::true_type
|
||||
{
|
||||
};
|
||||
|
||||
template<> struct is_signed<__int128_t>: public std::true_type
|
||||
{
|
||||
};
|
||||
|
||||
template<> struct is_signed<__uint128_t>: public std::false_type
|
||||
{
|
||||
};
|
||||
|
||||
template<> struct is_unsigned<__int128_t>: public std::false_type
|
||||
{
|
||||
};
|
||||
|
||||
template<> struct is_unsigned<__uint128_t>: public std::true_type
|
||||
{
|
||||
};
|
||||
|
||||
template<> struct make_unsigned<__int128_t>
|
||||
{
|
||||
typedef __uint128_t type;
|
||||
};
|
||||
|
||||
template<> struct make_unsigned<__uint128_t>
|
||||
{
|
||||
typedef __uint128_t type;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
}}} // namespace boost::detail::lcast
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_DETAIL_TYPE_TRAITS_HPP
|
||||
@@ -1,49 +0,0 @@
|
||||
// Copyright Kevlin Henney, 2000-2005.
|
||||
// Copyright Alexander Nasonov, 2006-2010.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// what: lexical_cast custom keyword cast
|
||||
// who: contributed by Kevlin Henney,
|
||||
// enhanced with contributions from Terje Slettebo,
|
||||
// with additional fixes and suggestions from Gennaro Prota,
|
||||
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
|
||||
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
|
||||
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
|
||||
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP
|
||||
#define BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
#endif // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
|
||||
namespace boost { namespace detail {
|
||||
|
||||
template <typename TargetChar, typename SourceChar>
|
||||
using widest_char = std::conditional<
|
||||
(sizeof(TargetChar) > sizeof(SourceChar))
|
||||
, TargetChar
|
||||
, SourceChar
|
||||
>;
|
||||
|
||||
}} // namespace boost::detail
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP
|
||||
|
||||
@@ -1,105 +0,0 @@
|
||||
// Copyright Kevlin Henney, 2000-2005.
|
||||
// Copyright Alexander Nasonov, 2006-2010.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// what: lexical_cast custom keyword cast
|
||||
// who: contributed by Kevlin Henney,
|
||||
// enhanced with contributions from Terje Slettebo,
|
||||
// with additional fixes and suggestions from Gennaro Prota,
|
||||
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
|
||||
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
|
||||
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
|
||||
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_TRY_LEXICAL_CONVERT_HPP
|
||||
#define BOOST_LEXICAL_CAST_TRY_LEXICAL_CONVERT_HPP
|
||||
|
||||
#include <boost/lexical_cast/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <type_traits>
|
||||
#endif
|
||||
|
||||
#include <boost/lexical_cast/detail/buffer_view.hpp>
|
||||
#include <boost/lexical_cast/detail/is_character.hpp>
|
||||
#include <boost/lexical_cast/detail/converter_numeric.hpp>
|
||||
#include <boost/lexical_cast/detail/converter_lexical.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace detail
|
||||
{
|
||||
template<typename Target, typename Source>
|
||||
using is_arithmetic_and_not_xchars = std::integral_constant<
|
||||
bool,
|
||||
!(boost::detail::is_character<Target>::value) &&
|
||||
!(boost::detail::is_character<Source>::value) &&
|
||||
std::is_arithmetic<Source>::value &&
|
||||
std::is_arithmetic<Target>::value
|
||||
>;
|
||||
}
|
||||
|
||||
namespace conversion { namespace detail {
|
||||
|
||||
BOOST_LEXICAL_CAST_BEGIN_MODULE_EXPORT
|
||||
|
||||
template <typename Target, typename Source>
|
||||
inline bool try_lexical_convert(const Source& arg, Target& result)
|
||||
{
|
||||
static_assert(
|
||||
!std::is_volatile<Source>::value,
|
||||
"Boost.LexicalCast does not support volatile input");
|
||||
|
||||
typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
|
||||
|
||||
typedef boost::detail::is_arithmetic_and_not_xchars<Target, src >
|
||||
shall_we_copy_with_dynamic_check_t;
|
||||
|
||||
typedef typename std::conditional<
|
||||
shall_we_copy_with_dynamic_check_t::value,
|
||||
boost::detail::dynamic_num_converter_impl<Target, src >,
|
||||
boost::detail::lexical_converter_impl<Target, src >
|
||||
>::type caster_type;
|
||||
|
||||
return caster_type::try_convert(arg, result);
|
||||
}
|
||||
|
||||
template <typename Target, typename CharacterT>
|
||||
inline bool try_lexical_convert(const CharacterT* chars, std::size_t count, Target& result)
|
||||
{
|
||||
static_assert(
|
||||
boost::detail::is_character<CharacterT>::value,
|
||||
"This overload of try_lexical_convert is meant to be used only with arrays of characters."
|
||||
);
|
||||
return ::boost::conversion::detail::try_lexical_convert(
|
||||
::boost::conversion::detail::make_buffer_view(chars, chars + count),
|
||||
result
|
||||
);
|
||||
}
|
||||
BOOST_LEXICAL_CAST_END_MODULE_EXPORT
|
||||
|
||||
}} // namespace conversion::detail
|
||||
|
||||
namespace conversion {
|
||||
BOOST_LEXICAL_CAST_BEGIN_MODULE_EXPORT
|
||||
// ADL barrier
|
||||
using ::boost::conversion::detail::try_lexical_convert;
|
||||
BOOST_LEXICAL_CAST_END_MODULE_EXPORT
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_TRY_LEXICAL_CONVERT_HPP
|
||||
|
||||
+34
-11
@@ -1,16 +1,39 @@
|
||||
|
||||
<!--
|
||||
Copyright 2005-2007 Daniel James.
|
||||
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)
|
||||
-->
|
||||
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=../../doc/html/boost_lexical_cast.html">
|
||||
<meta http-equiv="Content-Language" content="en-us">
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
|
||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||
<title>Boost Conversion Library</title>
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="../../doc/html/boost_lexical_cast.html">../../doc/html/boost_lexical_cast.html</a>
|
||||
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
|
||||
<h1><img border="0" src="../../boost.png" align="center" width="277" height="86">Boost
|
||||
Conversion Library</h1>
|
||||
|
||||
<p>The Conversion Library improves program safety and clarity by performing
|
||||
otherwise messy conversions. It includes cast-style function templates designed to complement the C++
|
||||
Standard's built-in casts.</p>
|
||||
<p>To reduce coupling, particularly to standard library IOStreams, the Boost
|
||||
Conversion Library is
|
||||
supplied by several headers:</p>
|
||||
<ul>
|
||||
<li>The <a href="cast.htm">boost/cast</a> header provides <b>polymorphic_cast<></b>
|
||||
and <b>polymorphic_downcast<></b> to perform safe casting between
|
||||
polymorphic types, and <b> numeric_cast</b><i><></i> to perform safe casting
|
||||
between numeric types.<br>
|
||||
</li>
|
||||
<li>The <a href="lexical_cast.htm">boost/lexical_cast</a> header provides <b>lexical_cast<></b>
|
||||
general literal text conversions, such as an <code>int</code> represented as
|
||||
a <code>string</code>, or vice-versa.</li>
|
||||
</ul>
|
||||
<hr>
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED"
|
||||
S-Format="%d %B, %Y" startspan -->06 January, 2001<!--webbot bot="Timestamp" endspan i-checksum="38320" -->
|
||||
</p>
|
||||
|
||||
</body>
|
||||
|
||||
</html>
|
||||
|
||||
@@ -0,0 +1,223 @@
|
||||
<!-- saved from url=(0022)http://internet.e-mail -->
|
||||
<!doctype html public "-//W3C//DTD HTML Transitional 4.0//EN">
|
||||
<html>
|
||||
<head>
|
||||
<title>lexical_cast</title>
|
||||
<meta name="author" content="Kevlin Henney, mailto:kevlin@curbralan.com">
|
||||
<meta name="generator" content="Microsoft FrontPage 4.0">
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="center" width="277" height="86">Header
|
||||
<a href="../../boost/lexical_cast.hpp">boost/lexical_cast.hpp</a></h1>
|
||||
<ul type="square">
|
||||
<li>
|
||||
<a href="#motivation">Motivation</a></li>
|
||||
<li>
|
||||
<a href="#examples">Examples</a></li>
|
||||
<li>
|
||||
<a href="#synopsis">Synopsis</a></li>
|
||||
<li>
|
||||
<a href="#lexical_cast"><code>lexical_cast</code></a></li>
|
||||
<li>
|
||||
<a href="#bad_lexical_cast"><code>bad_lexical_cast</code></a></li>
|
||||
<li>
|
||||
<a href="#changes">Changes</a></li>
|
||||
</ul>
|
||||
<hr>
|
||||
<h2><a name="motivation">Motivation</a></h2>
|
||||
Sometimes a value must be converted to a literal text form, such as an <code>int</code>
|
||||
represented as a <code>string</code>, or vice-versa, when a <code>string</code>
|
||||
is interpreted as an <code>int</code>. Such examples are common when converting
|
||||
between data types internal to a program and representation external to a
|
||||
program, such as windows and configuration files.
|
||||
<p>
|
||||
The standard C and C++ libraries offer a number of facilities for performing
|
||||
such conversions. However, they vary with their ease of use, extensibility, and
|
||||
safety.
|
||||
<p>
|
||||
For instance, there are a number of limitations with the family of standard C
|
||||
functions typified by <code>atoi</code>:
|
||||
<ul type="square">
|
||||
<li>
|
||||
Conversion is supported in one direction only: from text to internal data type.
|
||||
Converting the other way using the C library requires either the inconvenience
|
||||
and compromised safety of the <code>sprintf</code> function, or the loss of
|
||||
portability associated with non-standard functions such as <code>itoa</code>.
|
||||
</li>
|
||||
<li>
|
||||
The range of types supported is only a subset of the built-in numeric types,
|
||||
namely <code>int</code>, <code>long</code>, and <code>double</code>.
|
||||
</li>
|
||||
<li>
|
||||
The range of types cannot be extended in a uniform manner. For instance,
|
||||
conversion from string representation to <code>complex</code> or <code>rational</code>.
|
||||
</li>
|
||||
</ul>
|
||||
The standard C functions typified by <code>strtol</code> have the same basic
|
||||
limitations, but offer finer control over the conversion process. However, for
|
||||
the common case such control is often either not required or not used. The <code>scanf</code>
|
||||
family of functions offer even greater control, but also lack safety and ease
|
||||
of use.
|
||||
<p>
|
||||
The standard C++ library offers <code>stringstream</code> for the kind of
|
||||
in-core formatting being discussed. It offers a great deal of control over the
|
||||
formatting and conversion of I/O to and from arbitrary types through text.
|
||||
However, for simple conversions direct use of <code>stringstream</code> can be
|
||||
either clumsy (with the introduction of extra local variables and the loss of
|
||||
infix-expression convenience) or obscure (where <code>stringstream</code>
|
||||
objects are created as temporary objects in an expression). Facets provide a
|
||||
comprehensive concept and facility for controlling textual representation, but
|
||||
their perceived complexity and high entry level requires an extreme degree of
|
||||
involvement for simple conversions, and excludes all but a few programmers.
|
||||
<p>
|
||||
The <code>lexical_cast</code> function template offers a convenient and
|
||||
consistent form for supporting common conversions to and from arbitrary types
|
||||
when they are represented as text. The simplification it offers is in
|
||||
expression-level convenience for such conversions. For more involved
|
||||
conversions, such as where precision or formatting need tighter control than is
|
||||
offered by the default behavior of <code>lexical_cast</code>, the conventional <code>
|
||||
stringstream</code> approach is recommended. Where the conversions are
|
||||
numeric to numeric, <code><a href="cast.htm#numeric_cast">numeric_cast</a></code>
|
||||
may offer more reasonable behavior than <code>lexical_cast</code>.
|
||||
<p>
|
||||
For a good discussion of the options and issues involved in string-based
|
||||
formatting, including comparison of <code>stringstream</code>, <code>lexical_cast</code>,
|
||||
and others, see Herb Sutter's article, <a href="http://www.gotw.ca/publications/mill19.htm">
|
||||
<i>The String Formatters of Manor Farm</i></a>.
|
||||
<p>
|
||||
<hr>
|
||||
<h2><a name="examples">Examples</a></h2>
|
||||
The following example treats command line arguments as a sequence of numeric
|
||||
data: <blockquote>
|
||||
<pre>
|
||||
int main(int argc, char * argv[])
|
||||
{
|
||||
using boost::lexical_cast;
|
||||
using boost::bad_lexical_cast;
|
||||
|
||||
std::vector<short> args;
|
||||
|
||||
while(*++argv)
|
||||
{
|
||||
try
|
||||
{
|
||||
args.push_back(lexical_cast<short>(*argv));
|
||||
}
|
||||
catch(bad_lexical_cast &)
|
||||
{
|
||||
args.push_back(0);
|
||||
}
|
||||
}
|
||||
...
|
||||
}
|
||||
</pre>
|
||||
</blockquote>The following example uses numeric data in a string expression: <blockquote>
|
||||
<pre>
|
||||
void log_message(const std::string &);
|
||||
|
||||
void log_errno(int yoko)
|
||||
{
|
||||
log_message("Error " + boost::lexical_cast<std::string>(yoko) + ": " + strerror(yoko));
|
||||
}
|
||||
</pre>
|
||||
</blockquote>
|
||||
<hr>
|
||||
<h2><a name="synopsis">Synopsis</a></h2>
|
||||
Library features defined in <a href="../../boost/lexical_cast.hpp"><code>"boost/lexical_cast.hpp"</code></a>:
|
||||
<blockquote>
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
class <a href="#bad_lexical_cast">bad_lexical_cast</a>;
|
||||
template<typename Target, typename Source>
|
||||
Target <a href="#lexical_cast">lexical_cast</a>(Source arg);
|
||||
}
|
||||
</pre>
|
||||
</blockquote>Unit test defined in <a href="lexical_cast_test.cpp"><code>"lexical_cast_test.cpp"</code></a>.
|
||||
<p>
|
||||
<hr>
|
||||
<h2><a name="lexical_cast"><code>lexical_cast</code></a></h2>
|
||||
<blockquote>
|
||||
<pre>
|
||||
template<typename Target, typename Source>
|
||||
Target lexical_cast(Source arg);
|
||||
</pre>
|
||||
</blockquote>Returns the result of streaming <code>arg</code> into a
|
||||
standard library string-based stream and then out as a <code>Target</code> object.
|
||||
Where <code>Target</code> is either <code>std::string</code>
|
||||
or <code>std::wstring</code>, stream extraction takes the whole content
|
||||
of the string, including spaces, rather than relying on the default
|
||||
<code>operator>></code> behavior.
|
||||
If the conversion is unsuccessful, a <a href="#bad_lexical_cast">
|
||||
<code>bad_lexical_cast</code></a> exception is thrown.
|
||||
<p>
|
||||
The requirements on the argument and result types are:
|
||||
<ul type="square">
|
||||
<li>
|
||||
<code>Source</code> is <i>OutputStreamable</i>, meaning that an <code>operator<<</code>
|
||||
is defined that takes a <code>std::ostream</code> or <code>std::wostream</code> object on the
|
||||
left hand side and an instance of the argument type on the right.
|
||||
</li>
|
||||
<li>
|
||||
<code>Target</code> is <i>InputStreamable</i>, meaning that an <code>operator>></code>
|
||||
is defined that takes a <code>std::istream</code> or <code>std::wistream</code> object on the left hand side
|
||||
and an instance of the result type on the right.
|
||||
</li>
|
||||
<li>
|
||||
Both <code>Source</code> and <code>Target</code> are <i>CopyConstructible</i> [20.1.3].
|
||||
</li>
|
||||
<li>
|
||||
<code>Target</code> is <i>DefaultConstructible</i>, meaning that it is possible
|
||||
to <i>default-initialize</i> an object of that type [8.5, 20.1.4].
|
||||
</li>
|
||||
</ul>
|
||||
The character type of the underlying stream is assumed to be <code>char</code> unless
|
||||
either the <code>Source</code> or the <code>Target</code> requires wide-character
|
||||
streaming, in which case the underlying stream uses <code>wchar_t</code>.
|
||||
<code>Source</code> types that require wide-character streaming are <code>wchar_t</code>,
|
||||
<code>wchar_t *</code>, and <code>std::wstring</code>. <code>Target</code> types that
|
||||
require wide-character streaming are <code>wchar_t</code> and <code>std::wstring</code>.
|
||||
<p>
|
||||
Where a higher degree of control is required over conversions, <code>std::stringstream</code>
|
||||
and <code>std::wstringstream</code> offer a more appropriate path. Where non-stream-based conversions are
|
||||
required, <code>lexical_cast</code>
|
||||
is the wrong tool for the job and is not special-cased for such scenarios.
|
||||
<p>
|
||||
<hr>
|
||||
<h2><a name="bad_lexical_cast"><code>bad_lexical_cast</code></a></h2>
|
||||
<blockquote>
|
||||
<pre>
|
||||
class bad_lexical_cast : public std::bad_cast
|
||||
{
|
||||
public:
|
||||
... // <i>same member function interface as</i> std::exception
|
||||
};
|
||||
</pre>
|
||||
</blockquote>Exception used to indicate runtime <a href="#lexical_cast"><code>lexical_cast</code></a>
|
||||
failure.
|
||||
<hr>
|
||||
<h2><a name="changes">Changes</a></h2>
|
||||
<ul type="square">
|
||||
<li>The previous version of <code>lexical_cast</code> used the default stream precision for reading
|
||||
and writing floating-point numbers. For numerics that have a corresponding specialization of
|
||||
<code>std::numeric_limits</code>, the current version now chooses a precision to match.
|
||||
<li>The previous version of <code>lexical_cast</code> did not support conversion to or from any
|
||||
wide-character-based types. For compilers with full language and library support for wide characters,
|
||||
<code>lexical_cast</code> now supports conversions from <code>wchar_t</code>, <code>wchar_t *</code>,
|
||||
and <code>std::wstring</code> and to <code>wchar_t</code> and <code>std::wstring</code>.
|
||||
<li>The previous version of <code>lexical_cast</code> assumed that the conventional stream extractor
|
||||
operators were sufficient for reading values. However, string I/O is asymmetric, with the result
|
||||
that spaces play the role of I/O separators rather than string content. The current version fixes
|
||||
this error for <code>std::string</code> and, where supported, <code>std::wstring</code>:
|
||||
<code>lexical_cast<std::string>("Hello, World")</code> succeeds instead of failing with
|
||||
a <code>bad_lexical_cast</code> exception.
|
||||
<li>The previous version of <code>lexical_cast</code> allowed unsafe and meaningless conversions to
|
||||
pointers. The current version now throws a <code>bad_lexical_cast</code> for conversions to pointers:
|
||||
<code>lexical_cast<char *>("Goodbye, World")</code> now throws an exception instead of
|
||||
causing undefined behavior.
|
||||
</ul>
|
||||
<p>
|
||||
<hr>
|
||||
<div align="right"><small><i>© Copyright Kevlin Henney, 2000–2003</i></small></div>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,288 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Terje Slettebø and Kevlin Henney, 2003.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(__INTEL_COMPILER)
|
||||
#pragma warning(disable: 193 383 488 981 1418 1419)
|
||||
#elif defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
|
||||
#endif
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#include <boost/test/floating_point_comparison.hpp>
|
||||
#include <boost/test/included/unit_test_framework.hpp>
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || \
|
||||
defined(BOOST_NO_STD_WSTRING) || \
|
||||
defined(BOOST_NO_STD_LOCALE) || \
|
||||
defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
#define DISABLE_WIDE_CHAR_SUPPORT
|
||||
#endif
|
||||
|
||||
using namespace boost;
|
||||
|
||||
void test_conversion_to_char();
|
||||
void test_conversion_to_int();
|
||||
void test_conversion_to_double();
|
||||
void test_conversion_to_bool();
|
||||
void test_conversion_to_string();
|
||||
void test_conversion_from_to_wchar_t_alias();
|
||||
void test_conversion_to_pointer();
|
||||
void test_conversion_from_wchar_t();
|
||||
void test_conversion_to_wchar_t();
|
||||
void test_conversion_from_wstring();
|
||||
void test_conversion_to_wstring();
|
||||
|
||||
unit_test_framework::test_suite *init_unit_test_suite(int, char **)
|
||||
{
|
||||
unit_test_framework::test_suite *suite =
|
||||
BOOST_TEST_SUITE("lexical_cast unit test");
|
||||
suite->add(BOOST_TEST_CASE(test_conversion_to_char));
|
||||
suite->add(BOOST_TEST_CASE(test_conversion_to_int));
|
||||
suite->add(BOOST_TEST_CASE(test_conversion_to_double));
|
||||
suite->add(BOOST_TEST_CASE(test_conversion_to_bool));
|
||||
suite->add(BOOST_TEST_CASE(test_conversion_from_to_wchar_t_alias));
|
||||
suite->add(BOOST_TEST_CASE(test_conversion_to_pointer));
|
||||
suite->add(BOOST_TEST_CASE(test_conversion_to_string));
|
||||
#ifndef DISABLE_WIDE_CHAR_SUPPORT
|
||||
suite->add(BOOST_TEST_CASE(test_conversion_from_wchar_t));
|
||||
suite->add(BOOST_TEST_CASE(test_conversion_to_wchar_t));
|
||||
suite->add(BOOST_TEST_CASE(test_conversion_from_wstring));
|
||||
suite->add(BOOST_TEST_CASE(test_conversion_to_wstring));
|
||||
#endif
|
||||
return suite;
|
||||
}
|
||||
|
||||
void test_conversion_to_char()
|
||||
{
|
||||
BOOST_CHECK_EQUAL('A', lexical_cast<char>('A'));
|
||||
BOOST_CHECK_EQUAL(' ', lexical_cast<char>(' '));
|
||||
BOOST_CHECK_EQUAL('1', lexical_cast<char>(1));
|
||||
BOOST_CHECK_EQUAL('0', lexical_cast<char>(0));
|
||||
BOOST_CHECK_THROW(lexical_cast<char>(123), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL('1', lexical_cast<char>(1.0));
|
||||
BOOST_CHECK_EQUAL('1', lexical_cast<char>(true));
|
||||
BOOST_CHECK_EQUAL('0', lexical_cast<char>(false));
|
||||
BOOST_CHECK_EQUAL('A', lexical_cast<char>("A"));
|
||||
BOOST_CHECK_EQUAL(' ', lexical_cast<char>(" "));
|
||||
BOOST_CHECK_THROW(lexical_cast<char>(""), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<char>("Test"), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL('A', lexical_cast<char>(std::string("A")));
|
||||
BOOST_CHECK_EQUAL(' ', lexical_cast<char>(std::string(" ")));
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<char>(std::string("")), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<char>(std::string("Test")), boost::bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_conversion_to_int()
|
||||
{
|
||||
BOOST_CHECK_EQUAL(1,lexical_cast<int>('1'));
|
||||
BOOST_CHECK_EQUAL(0,lexical_cast<int>('0'));
|
||||
BOOST_CHECK_THROW(lexical_cast<int>('A'),boost::bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(1,lexical_cast<int>(1));
|
||||
BOOST_CHECK_EQUAL(
|
||||
(std::numeric_limits<int>::max)(),
|
||||
lexical_cast<int>((std::numeric_limits<int>::max)()));
|
||||
BOOST_CHECK_EQUAL(1,lexical_cast<int>(1.0));
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<int>(1.23), boost::bad_lexical_cast);
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<int>(1e20), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(1, lexical_cast<int>(true));
|
||||
BOOST_CHECK_EQUAL(0, lexical_cast<int>(false));
|
||||
BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<int>(" 123"), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<int>(""), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<int>("Test"), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
|
||||
BOOST_CHECK_EQUAL(123,lexical_cast<int>(std::string("123")));
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<int>(std::string(" 123")), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<int>(std::string("")), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<int>(std::string("Test")), boost::bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_conversion_to_double()
|
||||
{
|
||||
BOOST_CHECK_EQUAL(1.0, lexical_cast<double>('1'));
|
||||
BOOST_CHECK_THROW(lexical_cast<double>('A'), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(1));
|
||||
BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(1.23));
|
||||
BOOST_CHECK_CLOSE(
|
||||
(std::numeric_limits<double>::max)() / 2,
|
||||
lexical_cast<double>((std::numeric_limits<double>::max)() / 2),
|
||||
std::numeric_limits<double>::epsilon());
|
||||
BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(true));
|
||||
BOOST_CHECK_EQUAL(0.0, lexical_cast<double>(false));
|
||||
BOOST_CHECK_EQUAL(1.23, lexical_cast<double>("1.23"));
|
||||
BOOST_CHECK_THROW(lexical_cast<double>(""), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<double>("Test"), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(std::string("1.23")));
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<double>(std::string("")), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<double>(std::string("Test")), boost::bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_conversion_to_bool()
|
||||
{
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>('1'));
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>('0'));
|
||||
BOOST_CHECK_THROW(lexical_cast<bool>('A'), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1));
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0));
|
||||
BOOST_CHECK_THROW(lexical_cast<bool>(123), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1.0));
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0.0));
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>(true));
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>(false));
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
|
||||
BOOST_CHECK_THROW(lexical_cast<bool>(""), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<bool>("Test"), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::string("1")));
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::string("0")));
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<bool>(std::string("")), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<bool>(std::string("Test")), boost::bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_conversion_to_string()
|
||||
{
|
||||
BOOST_CHECK_EQUAL("A", lexical_cast<std::string>('A'));
|
||||
BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(' '));
|
||||
BOOST_CHECK_EQUAL("123", lexical_cast<std::string>(123));
|
||||
BOOST_CHECK_EQUAL("1.23", lexical_cast<std::string>(1.23));
|
||||
BOOST_CHECK_EQUAL("1.111111111", lexical_cast<std::string>(1.111111111));
|
||||
BOOST_CHECK_EQUAL("1",lexical_cast<std::string>(true));
|
||||
BOOST_CHECK_EQUAL("0",lexical_cast<std::string>(false));
|
||||
BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>("Test"));
|
||||
BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(" "));
|
||||
BOOST_CHECK_EQUAL("", lexical_cast<std::string>(""));
|
||||
BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>(std::string("Test")));
|
||||
BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(std::string(" ")));
|
||||
BOOST_CHECK_EQUAL("", lexical_cast<std::string>(std::string("")));
|
||||
}
|
||||
|
||||
void test_conversion_from_to_wchar_t_alias()
|
||||
{
|
||||
BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned short>("123"));
|
||||
BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned int>("123"));
|
||||
BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned long>("123"));
|
||||
BOOST_CHECK_EQUAL(std::string("123"),
|
||||
lexical_cast<std::string>(static_cast<unsigned short>(123)));
|
||||
BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123u));
|
||||
BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123ul));
|
||||
}
|
||||
|
||||
void test_conversion_to_pointer()
|
||||
{
|
||||
BOOST_CHECK_THROW(lexical_cast<char *>("Test"), boost::bad_lexical_cast);
|
||||
#ifndef DISABLE_WIDE_CHAR_SUPPORT
|
||||
BOOST_CHECK_THROW(lexical_cast<wchar_t *>("Test"), boost::bad_lexical_cast);
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_conversion_from_wchar_t()
|
||||
{
|
||||
#ifndef DISABLE_WIDE_CHAR_SUPPORT
|
||||
BOOST_CHECK_EQUAL(1, lexical_cast<int>(L'1'));
|
||||
BOOST_CHECK_THROW(lexical_cast<int>(L'A'), boost::bad_lexical_cast);
|
||||
|
||||
BOOST_CHECK_EQUAL(123, lexical_cast<int>(L"123"));
|
||||
BOOST_CHECK_THROW(lexical_cast<int>(L""), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<int>(L"Test"), boost::bad_lexical_cast);
|
||||
|
||||
BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(L'1'));
|
||||
BOOST_CHECK_THROW(lexical_cast<double>(L'A'), boost::bad_lexical_cast);
|
||||
|
||||
BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(L"1.23"));
|
||||
BOOST_CHECK_THROW(lexical_cast<double>(L""), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<double>(L"Test"), boost::bad_lexical_cast);
|
||||
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L'1'));
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L'0'));
|
||||
BOOST_CHECK_THROW(lexical_cast<bool>(L'A'), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L"1"));
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L"0"));
|
||||
BOOST_CHECK_THROW(lexical_cast<bool>(L""), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<bool>(L"Test"), boost::bad_lexical_cast);
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_conversion_to_wchar_t()
|
||||
{
|
||||
#ifndef DISABLE_WIDE_CHAR_SUPPORT
|
||||
BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1));
|
||||
BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0));
|
||||
BOOST_CHECK_THROW(lexical_cast<wchar_t>(123), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1.0));
|
||||
BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0.0));
|
||||
BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(true));
|
||||
BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(false));
|
||||
BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L'A'));
|
||||
BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L' '));
|
||||
BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L"A"));
|
||||
BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L" "));
|
||||
BOOST_CHECK_THROW(lexical_cast<wchar_t>(L""), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<wchar_t>(L"Test"), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(std::wstring(L"A")));
|
||||
BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(std::wstring(L" ")));
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<wchar_t>(std::wstring(L"")), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<wchar_t>(std::wstring(L"Test")), boost::bad_lexical_cast);
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_conversion_from_wstring()
|
||||
{
|
||||
#ifndef DISABLE_WIDE_CHAR_SUPPORT
|
||||
BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::wstring(L"123")));
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<int>(std::wstring(L"")), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<int>(std::wstring(L"Test")), boost::bad_lexical_cast);
|
||||
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::wstring(L"1")));
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::wstring(L"0")));
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<bool>(std::wstring(L"")), boost::bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<bool>(std::wstring(L"Test")), boost::bad_lexical_cast);
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_conversion_to_wstring()
|
||||
{
|
||||
#ifndef DISABLE_WIDE_CHAR_SUPPORT
|
||||
BOOST_CHECK(L"123" == lexical_cast<std::wstring>(123));
|
||||
BOOST_CHECK(L"1.23" == lexical_cast<std::wstring>(1.23));
|
||||
BOOST_CHECK(L"1.111111111" == lexical_cast<std::wstring>(1.111111111));
|
||||
BOOST_CHECK(L"1" == lexical_cast<std::wstring>(true));
|
||||
BOOST_CHECK(L"0" == lexical_cast<std::wstring>(false));
|
||||
BOOST_CHECK(L"A" == lexical_cast<std::wstring>(L'A'));
|
||||
BOOST_CHECK(L" " == lexical_cast<std::wstring>(L' '));
|
||||
BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(L"Test"));
|
||||
BOOST_CHECK(L" " == lexical_cast<std::wstring>(L" "));
|
||||
BOOST_CHECK(L"" == lexical_cast<std::wstring>(L""));
|
||||
BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(std::wstring(L"Test")));
|
||||
BOOST_CHECK(L" " == lexical_cast<std::wstring>(std::wstring(L" ")));
|
||||
BOOST_CHECK(L"" == lexical_cast<std::wstring>(std::wstring(L"")));
|
||||
#endif
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
{
|
||||
"key": "lexical_cast",
|
||||
"name": "Lexical Cast",
|
||||
"authors": [
|
||||
"Kevlin Henney"
|
||||
],
|
||||
"description": "General literal text conversions, such as an int represented a string, or vice-versa.",
|
||||
"category": [
|
||||
"Miscellaneous",
|
||||
"String"
|
||||
],
|
||||
"maintainers": [
|
||||
"Antony Polukhin <antoshkka -at- gmail.com>"
|
||||
],
|
||||
"cxxstd": "11"
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
// Copyright (c) 2016-2025 Antony Polukhin
|
||||
//
|
||||
// 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)
|
||||
|
||||
// To compile manually use a command like the folowing:
|
||||
// clang++ -I ../include -std=c++20 --precompile -x c++-module boost_lexical_cast.cppm
|
||||
|
||||
module;
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <boost/container/container_fwd.hpp>
|
||||
#include <boost/core/cmath.hpp>
|
||||
#include <boost/core/noncopyable.hpp>
|
||||
#include <boost/core/snprintf.hpp>
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
|
||||
#include <boost/detail/basic_pointerbuf.hpp>
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_USE_STD_MODULE
|
||||
#include <array>
|
||||
#include <climits>
|
||||
#include <cstddef>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
# include <cwchar>
|
||||
#endif
|
||||
#include <exception>
|
||||
#include <iosfwd>
|
||||
#include <istream>
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
# include <locale>
|
||||
#endif
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <typeinfo>
|
||||
#include <type_traits>
|
||||
#endif
|
||||
|
||||
#define BOOST_LEXICAL_CAST_INTERFACE_UNIT
|
||||
|
||||
export module boost.lexical_cast;
|
||||
|
||||
#ifdef BOOST_LEXICAL_CAST_USE_STD_MODULE
|
||||
import std;
|
||||
#endif
|
||||
|
||||
#ifdef __clang__
|
||||
# pragma clang diagnostic ignored "-Winclude-angled-in-module-purview"
|
||||
#endif
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
@@ -1,16 +0,0 @@
|
||||
// Copyright (c) 2024-2025 Antony Polukhin
|
||||
//
|
||||
// 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)
|
||||
|
||||
// To compile manually use a command like the following:
|
||||
// clang++ -std=c++20 -fmodule-file=lexical_cast.pcm lexical_cast.pcm usage_sample.cpp
|
||||
|
||||
//[lexical_cast_module_example
|
||||
import boost.lexical_cast;
|
||||
|
||||
int main() {
|
||||
return boost::lexical_cast<int>("0");
|
||||
}
|
||||
//]
|
||||
|
||||
@@ -0,0 +1,100 @@
|
||||
// boost utility cast test program -----------------------------------------//
|
||||
|
||||
// (C) Copyright Beman Dawes, Dave Abrahams 1999. 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 for most recent version including documentation.
|
||||
|
||||
// Revision History
|
||||
// 28 Set 04 factored out numeric_cast<> test (Fernando Cacciola)
|
||||
// 20 Jan 01 removed use of <limits> for portability to raw GCC (David Abrahams)
|
||||
// 28 Jun 00 implicit_cast removed (Beman Dawes)
|
||||
// 30 Aug 99 value_cast replaced by numeric_cast
|
||||
// 3 Aug 99 Initial Version
|
||||
|
||||
#include <iostream>
|
||||
#include <climits>
|
||||
#include <cfloat> // for DBL_MAX (Peter Schmid)
|
||||
#include <boost/cast.hpp>
|
||||
|
||||
#include "boost/test/minimal.hpp"
|
||||
|
||||
# if SCHAR_MAX == LONG_MAX
|
||||
# error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
|
||||
# endif
|
||||
|
||||
using namespace boost;
|
||||
using std::cout;
|
||||
|
||||
|
||||
int test_main( int argc, char * argv[] )
|
||||
{
|
||||
|
||||
# ifdef NDEBUG
|
||||
cout << "NDEBUG is defined\n";
|
||||
# else
|
||||
cout << "NDEBUG is not defined\n";
|
||||
# endif
|
||||
|
||||
cout << "\nBeginning tests...\n";
|
||||
|
||||
// test implicit_cast and numeric_cast -------------------------------------//
|
||||
|
||||
// tests which should succeed
|
||||
long small_value = 1;
|
||||
long small_negative_value = -1;
|
||||
long large_value = LONG_MAX;
|
||||
long large_negative_value = LONG_MIN;
|
||||
signed char c = 0;
|
||||
|
||||
c = large_value; // see if compiler generates warning
|
||||
|
||||
c = numeric_cast<signed char>( small_value );
|
||||
BOOST_CHECK( c == 1 );
|
||||
c = 0;
|
||||
c = numeric_cast<signed char>( small_value );
|
||||
BOOST_CHECK( c == 1 );
|
||||
c = 0;
|
||||
c = numeric_cast<signed char>( small_negative_value );
|
||||
BOOST_CHECK( c == -1 );
|
||||
|
||||
// These tests courtesy of Joe R NWP Swatosh<joe.r.swatosh@usace.army.mil>
|
||||
BOOST_CHECK( 0.0f == numeric_cast<float>( 0.0 ) );
|
||||
BOOST_CHECK( 0.0 == numeric_cast<double>( 0.0 ) );
|
||||
|
||||
// tests which should result in errors being detected
|
||||
|
||||
bool caught_exception = false;
|
||||
try { c = numeric_cast<signed char>( large_value ); }
|
||||
catch (bad_numeric_cast)
|
||||
{ cout<<"caught bad_numeric_cast #1\n"; caught_exception = true; }
|
||||
BOOST_CHECK ( caught_exception );
|
||||
|
||||
caught_exception = false;
|
||||
try { c = numeric_cast<signed char>( large_negative_value ); }
|
||||
catch (bad_numeric_cast)
|
||||
{ cout<<"caught bad_numeric_cast #2\n"; caught_exception = true; }
|
||||
BOOST_CHECK ( caught_exception );
|
||||
|
||||
unsigned long ul;
|
||||
caught_exception = false;
|
||||
try { ul = numeric_cast<unsigned long>( large_negative_value ); }
|
||||
catch (bad_numeric_cast)
|
||||
{ cout<<"caught bad_numeric_cast #3\n"; caught_exception = true; }
|
||||
BOOST_CHECK ( caught_exception );
|
||||
|
||||
caught_exception = false;
|
||||
try { ul = numeric_cast<unsigned long>( small_negative_value ); }
|
||||
catch (bad_numeric_cast)
|
||||
{ cout<<"caught bad_numeric_cast #4\n"; caught_exception = true; }
|
||||
BOOST_CHECK ( caught_exception );
|
||||
|
||||
caught_exception = false;
|
||||
try { numeric_cast<int>( DBL_MAX ); }
|
||||
catch (bad_numeric_cast)
|
||||
{ cout<<"caught bad_numeric_cast #5\n"; caught_exception = true; }
|
||||
BOOST_CHECK ( caught_exception );
|
||||
|
||||
return 0 ;
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
#==============================================================================
|
||||
# Copyright Antony Polukhin, 2012-2026.
|
||||
#
|
||||
# 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)
|
||||
#==============================================================================
|
||||
|
||||
# performance tests
|
||||
import testing ;
|
||||
import path ;
|
||||
|
||||
path-constant TEST_DIR : . ;
|
||||
|
||||
project performance/test
|
||||
: source-location ./
|
||||
: requirements
|
||||
# <library>/boost/chrono//boost_chrono
|
||||
# <library>/boost/system//boost_system
|
||||
<link>static
|
||||
<target-os>freebsd:<linkflags>"-lrt"
|
||||
<target-os>linux:<linkflags>"-lrt"
|
||||
<toolset>gcc:<cxxflags>-fvisibility=hidden
|
||||
<toolset>intel-linux:<cxxflags>-fvisibility=hidden
|
||||
<toolset>sun:<cxxflags>-xldscope=hidden
|
||||
: default-build release
|
||||
;
|
||||
|
||||
run performance_test.cpp : $(TEST_DIR) ;
|
||||
|
||||
@@ -1,393 +0,0 @@
|
||||
// (C) Copyright Antony Polukhin, 2012-2026.
|
||||
// Use, modification and distribution are subject to 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/config for most recent version.
|
||||
|
||||
//
|
||||
// Testing lexical_cast<> performance
|
||||
//
|
||||
|
||||
#define BOOST_ERROR_CODE_HEADER_ONLY
|
||||
#define BOOST_CHRONO_HEADER_ONLY
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#include <fstream>
|
||||
#include <cstring>
|
||||
#include <string_view>
|
||||
#include <type_traits>
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/chrono.hpp>
|
||||
#include <boost/container/string.hpp>
|
||||
#include <boost/range/iterator_range.hpp>
|
||||
|
||||
// File to output data
|
||||
std::fstream fout;
|
||||
|
||||
namespace boost {
|
||||
inline std::istream& operator>> (std::istream& in, boost::array<char,50>& res) {
|
||||
in >> res.begin();
|
||||
return in;
|
||||
}
|
||||
}
|
||||
|
||||
template <class OutT, class InT>
|
||||
static inline void test_lexical(const InT& in_val) {
|
||||
OutT out_val = boost::lexical_cast<OutT>(in_val);
|
||||
(void)out_val;
|
||||
}
|
||||
|
||||
template <class OutT, class InT>
|
||||
static inline void test_ss_constr(const InT& in_val) {
|
||||
OutT out_val;
|
||||
std::stringstream ss;
|
||||
ss << in_val;
|
||||
if (ss.fail()) throw std::logic_error("descr");
|
||||
ss >> out_val;
|
||||
if (ss.fail()) throw std::logic_error("descr");
|
||||
}
|
||||
|
||||
template <class OutT, class CharT, std::size_t N>
|
||||
static inline void test_ss_constr(const boost::array<CharT, N>& in_val) {
|
||||
OutT out_val;
|
||||
std::stringstream ss;
|
||||
ss << in_val.begin();
|
||||
if (ss.fail()) throw std::logic_error("descr");
|
||||
ss >> out_val;
|
||||
if (ss.fail()) throw std::logic_error("descr");
|
||||
}
|
||||
|
||||
template <class OutT, class StringStreamT, class CharT, std::size_t N>
|
||||
static inline void test_ss_noconstr(StringStreamT& ss, const boost::array<CharT, N>& in_val) {
|
||||
OutT out_val;
|
||||
ss << in_val.begin(); // ss is an instance of std::stringstream
|
||||
if (ss.fail()) throw std::logic_error("descr");
|
||||
ss >> out_val;
|
||||
if (ss.fail()) throw std::logic_error("descr");
|
||||
/* reseting std::stringstream to use it again */
|
||||
ss.str(std::string());
|
||||
ss.clear();
|
||||
}
|
||||
|
||||
template <class OutT, class StringStreamT, class InT>
|
||||
static inline void test_ss_noconstr(StringStreamT& ss, const InT& in_val) {
|
||||
OutT out_val;
|
||||
ss << in_val; // ss is an instance of std::stringstream
|
||||
if (ss.fail()) throw std::logic_error("descr");
|
||||
ss >> out_val;
|
||||
if (ss.fail()) throw std::logic_error("descr");
|
||||
/* reseting std::stringstream to use it again */
|
||||
ss.str(std::string());
|
||||
ss.clear();
|
||||
}
|
||||
|
||||
struct structure_sprintf {
|
||||
template <class OutT, class BufferT, class InT>
|
||||
static inline void test(BufferT* buffer, const InT& in_val, const char* const conv) {
|
||||
sprintf(buffer, conv, in_val);
|
||||
OutT out_val(buffer);
|
||||
}
|
||||
|
||||
template <class OutT, class BufferT>
|
||||
static inline void test(BufferT* buffer, const std::string& in_val, const char* const conv) {
|
||||
sprintf(buffer, conv, in_val.c_str());
|
||||
OutT out_val(buffer);
|
||||
}
|
||||
|
||||
template <class OutT, class BufferT>
|
||||
static inline void test(BufferT* buffer, std::string_view in_val, const char* const conv) {
|
||||
sprintf(buffer, conv, in_val.data()); // in_val is zero terminated in this program
|
||||
OutT out_val(buffer);
|
||||
}
|
||||
};
|
||||
|
||||
struct structure_sscanf {
|
||||
template <class OutT, class BufferT, class CharT, std::size_t N>
|
||||
static inline void test(BufferT* /*buffer*/, const boost::array<CharT, N>& in_val, const char* const conv) {
|
||||
OutT out_val;
|
||||
sscanf(in_val.cbegin(), conv, &out_val);
|
||||
}
|
||||
|
||||
template <class OutT, class BufferT, class InT>
|
||||
static inline void test(BufferT* /*buffer*/, const InT& in_val, const char* const conv) {
|
||||
OutT out_val;
|
||||
sscanf(reinterpret_cast<const char*>(in_val), conv, &out_val);
|
||||
}
|
||||
|
||||
template <class OutT, class BufferT>
|
||||
static inline void test(BufferT* /*buffer*/, const std::string& in_val, const char* const conv) {
|
||||
OutT out_val;
|
||||
sscanf(in_val.c_str(), conv, &out_val);
|
||||
}
|
||||
|
||||
template <class OutT, class BufferT>
|
||||
static inline void test(BufferT* /*buffer*/, const boost::iterator_range<const char*>& in_val, const char* const conv) {
|
||||
OutT out_val;
|
||||
sscanf(in_val.begin(), conv, &out_val);
|
||||
}
|
||||
|
||||
template <class OutT, class BufferT>
|
||||
static inline void test(BufferT* /*buffer*/, std::string_view in_val, const char* const conv) {
|
||||
OutT out_val;
|
||||
sscanf(in_val.data(), conv, &out_val); // in_val is zero terminated in this program
|
||||
}
|
||||
};
|
||||
|
||||
struct structure_fake {
|
||||
template <class OutT, class BufferT, class InT>
|
||||
static inline void test(BufferT* /*buffer*/, const InT& /*in_val*/, const char* const /*conv*/) {}
|
||||
};
|
||||
|
||||
static const int fake_test_value = 9999;
|
||||
|
||||
template <class T>
|
||||
static inline void min_fancy_output(T v1, T v2, T v3, T v4) {
|
||||
const char beg_mark[] = "!!! *";
|
||||
const char end_mark[] = "* !!!";
|
||||
const char no_mark[] = "";
|
||||
|
||||
unsigned int res = 4;
|
||||
if (v1 < v2 && v1 < v3 && v1 < v4) res = 1;
|
||||
if (v2 < v1 && v2 < v3 && v2 < v4) res = 2;
|
||||
if (v3 < v1 && v3 < v2 && v3 < v4) res = 3;
|
||||
|
||||
fout << "[ "
|
||||
<< (res == 1 ? beg_mark : no_mark)
|
||||
;
|
||||
|
||||
if (v1) fout << v1;
|
||||
else fout << "<1";
|
||||
|
||||
fout << (res == 1 ? end_mark : no_mark)
|
||||
<< " ][ "
|
||||
<< (res == 2 ? beg_mark : no_mark)
|
||||
;
|
||||
|
||||
if (v2) fout << v2;
|
||||
else fout << "<1";
|
||||
|
||||
fout << (res == 2 ? end_mark : no_mark)
|
||||
<< " ][ "
|
||||
<< (res == 3 ? beg_mark : no_mark)
|
||||
;
|
||||
|
||||
if (v3) fout << v3;
|
||||
else fout << "<1";
|
||||
|
||||
fout << (res == 3 ? end_mark : no_mark)
|
||||
<< " ][ "
|
||||
<< (res == 4 ? beg_mark : no_mark)
|
||||
;
|
||||
|
||||
if (!v4) fout << "<1";
|
||||
else if (v4 == fake_test_value) fout << "---";
|
||||
else fout << v4;
|
||||
|
||||
fout
|
||||
<< (res == 4 ? end_mark : no_mark)
|
||||
<< " ]";
|
||||
}
|
||||
|
||||
template <unsigned int IetartionsCountV, class ToT, class SprintfT, class FromT>
|
||||
static inline void perf_test_impl(const FromT& in_val, const char* const conv) {
|
||||
|
||||
typedef boost::chrono::steady_clock test_clock;
|
||||
test_clock::time_point start;
|
||||
typedef boost::chrono::milliseconds duration_t;
|
||||
duration_t lexical_cast_time, ss_constr_time, ss_noconstr_time, printf_time;
|
||||
|
||||
start = test_clock::now();
|
||||
for (unsigned int i = 0; i < IetartionsCountV; ++i) {
|
||||
test_lexical<ToT>(in_val);
|
||||
test_lexical<ToT>(in_val);
|
||||
test_lexical<ToT>(in_val);
|
||||
test_lexical<ToT>(in_val);
|
||||
}
|
||||
lexical_cast_time = boost::chrono::duration_cast<duration_t>(test_clock::now() - start);
|
||||
|
||||
|
||||
start = test_clock::now();
|
||||
for (unsigned int i = 0; i < IetartionsCountV; ++i) {
|
||||
test_ss_constr<ToT>(in_val);
|
||||
test_ss_constr<ToT>(in_val);
|
||||
test_ss_constr<ToT>(in_val);
|
||||
test_ss_constr<ToT>(in_val);
|
||||
}
|
||||
ss_constr_time = boost::chrono::duration_cast<duration_t>(test_clock::now() - start);
|
||||
|
||||
std::stringstream ss;
|
||||
start = test_clock::now();
|
||||
for (unsigned int i = 0; i < IetartionsCountV; ++i) {
|
||||
test_ss_noconstr<ToT>(ss, in_val);
|
||||
test_ss_noconstr<ToT>(ss, in_val);
|
||||
test_ss_noconstr<ToT>(ss, in_val);
|
||||
test_ss_noconstr<ToT>(ss, in_val);
|
||||
}
|
||||
ss_noconstr_time = boost::chrono::duration_cast<duration_t>(test_clock::now() - start);
|
||||
|
||||
|
||||
char buffer[128];
|
||||
start = test_clock::now();
|
||||
for (unsigned int i = 0; i < IetartionsCountV; ++i) {
|
||||
SprintfT::template test<ToT>(buffer, in_val, conv);
|
||||
SprintfT::template test<ToT>(buffer, in_val, conv);
|
||||
SprintfT::template test<ToT>(buffer, in_val, conv);
|
||||
SprintfT::template test<ToT>(buffer, in_val, conv);
|
||||
}
|
||||
printf_time = boost::chrono::duration_cast<duration_t>(test_clock::now() - start);
|
||||
|
||||
min_fancy_output(
|
||||
lexical_cast_time.count(),
|
||||
ss_constr_time.count(),
|
||||
ss_noconstr_time.count(),
|
||||
std::is_same<SprintfT, structure_fake>::value ? fake_test_value : printf_time.count()
|
||||
);
|
||||
}
|
||||
|
||||
template <class ToT, class SprintfT, class FromT>
|
||||
static inline void perf_test(const std::string& test_name, const FromT& in_val, const char* const conv) {
|
||||
const unsigned int ITERATIONSCOUNT = 100000;
|
||||
fout << " [[ " << test_name << " ]";
|
||||
|
||||
perf_test_impl<ITERATIONSCOUNT/4, ToT, SprintfT>(in_val, conv);
|
||||
|
||||
fout << "]\n";
|
||||
}
|
||||
|
||||
|
||||
template <class ConverterT>
|
||||
void string_like_test_set(const std::string& from) {
|
||||
typedef structure_sscanf ssc_t;
|
||||
ConverterT conv;
|
||||
|
||||
perf_test<char, ssc_t>(from + "->char", conv("c"), "%c");
|
||||
perf_test<signed char, ssc_t>(from + "->signed char", conv("c"), "%hhd");
|
||||
perf_test<unsigned char, ssc_t>(from + "->unsigned char", conv("c"), "%hhu");
|
||||
|
||||
perf_test<int, ssc_t>(from + "->int", conv("100"), "%d");
|
||||
perf_test<short, ssc_t>(from + "->short", conv("100"), "%hd");
|
||||
perf_test<long int, ssc_t>(from + "->long int", conv("100"), "%ld");
|
||||
perf_test<boost::long_long_type, ssc_t>(from + "->long long", conv("100"), "%lld");
|
||||
|
||||
perf_test<unsigned int, ssc_t>(from + "->unsigned int", conv("100"), "%u");
|
||||
perf_test<unsigned short, ssc_t>(from + "->unsigned short", conv("100"), "%hu");
|
||||
perf_test<unsigned long int, ssc_t>(from + "->unsigned long int", conv("100"), "%lu");
|
||||
perf_test<boost::ulong_long_type, ssc_t>(from + "->unsigned long long", conv("100"), "%llu");
|
||||
|
||||
// perf_test<bool, ssc_t>(from + "->bool", conv("1"), "%");
|
||||
|
||||
perf_test<float, ssc_t>(from + "->float", conv("1.123"), "%f");
|
||||
perf_test<double, ssc_t>(from + "->double", conv("1.123"), "%lf");
|
||||
perf_test<long double, ssc_t>(from + "->long double", conv("1.123"), "%Lf");
|
||||
perf_test<boost::array<char, 50>, ssc_t>(from + "->array<char, 50>", conv("1.123"), "%s");
|
||||
|
||||
perf_test<std::string, structure_fake>(from + "->string", conv("string"), "%Lf");
|
||||
perf_test<boost::container::string, structure_fake>(from + "->container::string"
|
||||
, conv("string"), "%Lf");
|
||||
|
||||
}
|
||||
|
||||
struct to_string_conv {
|
||||
std::string operator()(const char* const c) const {
|
||||
return c;
|
||||
}
|
||||
};
|
||||
|
||||
struct to_char_conv {
|
||||
const char* operator()(const char* const c) const {
|
||||
return c;
|
||||
}
|
||||
};
|
||||
|
||||
struct to_uchar_conv {
|
||||
const unsigned char* operator()(const char* const c) const {
|
||||
return reinterpret_cast<const unsigned char*>(c);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
struct to_schar_conv {
|
||||
const signed char* operator()(const char* const c) const {
|
||||
return reinterpret_cast<const signed char*>(c);
|
||||
}
|
||||
};
|
||||
|
||||
struct to_iterator_range {
|
||||
boost::iterator_range<const char*> operator()(const char* const c) const {
|
||||
return boost::make_iterator_range(c, c + std::strlen(c));
|
||||
}
|
||||
};
|
||||
|
||||
struct to_array_50 {
|
||||
boost::array<char, 50> operator()(const char* const c) const {
|
||||
boost::array<char, 50> ret;
|
||||
std::strcpy(ret.begin(), c);
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
struct to_string_view {
|
||||
std::string_view operator()(const char* const c) const {
|
||||
return std::string_view{c};
|
||||
}
|
||||
};
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
BOOST_ASSERT(argc >= 2);
|
||||
std::string output_path(argv[1]);
|
||||
output_path += "/results.txt";
|
||||
fout.open(output_path.c_str(), std::fstream::in | std::fstream::out | std::fstream::app);
|
||||
BOOST_ASSERT(fout);
|
||||
|
||||
fout << "[section " << BOOST_COMPILER << "]\n"
|
||||
<< "[table:id Performance Table ( "<< BOOST_COMPILER << ")\n"
|
||||
<< "[[From->To] [lexical_cast] [std::stringstream with construction] "
|
||||
<< "[std::stringstream without construction][scanf/printf]]\n";
|
||||
|
||||
|
||||
// From std::string to ...
|
||||
string_like_test_set<to_string_conv>("string");
|
||||
|
||||
// From ... to std::string
|
||||
perf_test<std::string, structure_sprintf>("string->char", 'c', "%c");
|
||||
perf_test<std::string, structure_sprintf>("string->signed char", static_cast<signed char>('c'), "%hhd");
|
||||
perf_test<std::string, structure_sprintf>("string->unsigned char", static_cast<unsigned char>('c'), "%hhu");
|
||||
|
||||
perf_test<std::string, structure_sprintf>("int->string", 100, "%d");
|
||||
perf_test<std::string, structure_sprintf>("short->string", static_cast<short>(100), "%hd");
|
||||
perf_test<std::string, structure_sprintf>("long int->string", 100l, "%ld");
|
||||
perf_test<std::string, structure_sprintf>("long long->string", 100ll, "%lld");
|
||||
|
||||
perf_test<std::string, structure_sprintf>("unsigned int->string", static_cast<unsigned short>(100u), "%u");
|
||||
perf_test<std::string, structure_sprintf>("unsigned short->string", 100u, "%hu");
|
||||
perf_test<std::string, structure_sprintf>("unsigned long int->string", 100ul, "%lu");
|
||||
perf_test<std::string, structure_sprintf>("unsigned long long->string", static_cast<boost::ulong_long_type>(100), "%llu");
|
||||
|
||||
// perf_test<bool, structure_sscanf>("bool->string", std::string("1"), "%");
|
||||
|
||||
perf_test<std::string, structure_sprintf>("float->string", 1.123f, "%f");
|
||||
perf_test<std::string, structure_sprintf>("double->string", 1.123, "%lf");
|
||||
perf_test<std::string, structure_sprintf>("long double->string", 1.123L, "%Lf");
|
||||
|
||||
|
||||
string_like_test_set<to_char_conv>("char*");
|
||||
string_like_test_set<to_uchar_conv>("unsigned char*");
|
||||
string_like_test_set<to_schar_conv>("signed char*");
|
||||
string_like_test_set<to_iterator_range>("iterator_range<char*>");
|
||||
string_like_test_set<to_string_view>("std::string_view");
|
||||
string_like_test_set<to_array_50>("array<char, 50>");
|
||||
|
||||
perf_test<int, structure_fake>("int->int", 100, "");
|
||||
perf_test<double, structure_fake>("float->double", 100.0f, "");
|
||||
perf_test<signed char, structure_fake>("char->signed char", 'c', "");
|
||||
|
||||
|
||||
fout << "]\n"
|
||||
<< "[endsect]\n\n";
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,308 @@
|
||||
// what: simple unit test framework
|
||||
// who: developed by Kevlin Henney
|
||||
// when: November 2000
|
||||
// where: tested with BCC 5.5, MSVC 6.0, and g++ 2.91
|
||||
//
|
||||
// ChangeLog:
|
||||
// 20 Jan 2001 - Fixed a warning for MSVC (Dave Abrahams)
|
||||
|
||||
#ifndef TEST_INCLUDED
|
||||
#define TEST_INCLUDED
|
||||
|
||||
#include <exception>
|
||||
#include <iostream>
|
||||
#include <strstream> // for out-of-the-box g++
|
||||
#include <string>
|
||||
|
||||
namespace test // test tuple comprises name and nullary function (object)
|
||||
{
|
||||
template<typename string_type, typename function_type>
|
||||
struct test
|
||||
{
|
||||
string_type name;
|
||||
function_type action;
|
||||
|
||||
static test make(string_type name, function_type action)
|
||||
{
|
||||
test result; // MSVC aggreggate initializer bugs
|
||||
result.name = name;
|
||||
result.action = action;
|
||||
return result;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
namespace test // failure exception used to indicate checked test failures
|
||||
{
|
||||
class failure : public std::exception
|
||||
{
|
||||
public: // struction (default cases are OK)
|
||||
|
||||
failure(const std::string & why)
|
||||
: reason(why)
|
||||
{
|
||||
}
|
||||
|
||||
// std::~string has no exception-specification (could throw anything),
|
||||
// but we need to be compatible with std::~exception's empty one
|
||||
// see std::15.4p13 and std::15.4p3
|
||||
~failure() throw()
|
||||
{
|
||||
}
|
||||
|
||||
public: // usage
|
||||
|
||||
virtual const char * what() const throw()
|
||||
{
|
||||
return reason.c_str();
|
||||
}
|
||||
|
||||
private: // representation
|
||||
|
||||
std::string reason;
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
namespace test // not_implemented exception used to mark unimplemented tests
|
||||
{
|
||||
class not_implemented : public std::exception
|
||||
{
|
||||
public: // usage (default ctor and dtor are OK)
|
||||
|
||||
virtual const char * what() const throw()
|
||||
{
|
||||
return "not implemented";
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
namespace test // test utilities
|
||||
{
|
||||
inline void check(bool condition, const std::string & description)
|
||||
{
|
||||
if(!condition)
|
||||
{
|
||||
throw failure(description);
|
||||
}
|
||||
}
|
||||
|
||||
inline void check_true(bool value, const std::string & description)
|
||||
{
|
||||
check(value, "expected true: " + description);
|
||||
}
|
||||
|
||||
inline void check_false(bool value, const std::string & description)
|
||||
{
|
||||
check(!value, "expected false: " + description);
|
||||
}
|
||||
|
||||
template<typename lhs_type, typename rhs_type>
|
||||
void check_equal(
|
||||
const lhs_type & lhs, const rhs_type & rhs,
|
||||
const std::string & description)
|
||||
{
|
||||
check(lhs == rhs, "expected equal values: " + description);
|
||||
}
|
||||
|
||||
template<typename lhs_type, typename rhs_type>
|
||||
void check_unequal(
|
||||
const lhs_type & lhs, const rhs_type & rhs,
|
||||
const std::string & description)
|
||||
{
|
||||
check(lhs != rhs, "expected unequal values: " + description);
|
||||
}
|
||||
|
||||
inline void check_null(const void* ptr, const std::string & description)
|
||||
{
|
||||
check(!ptr, "expected null pointer: " + description);
|
||||
}
|
||||
|
||||
inline void check_non_null(const void* ptr, const std::string & description)
|
||||
{
|
||||
check(ptr != 0, "expected non-null pointer: " + description);
|
||||
}
|
||||
}
|
||||
|
||||
#define TEST_CHECK_THROW(expression, exception, description) \
|
||||
try \
|
||||
{ \
|
||||
expression; \
|
||||
throw ::test::failure(description); \
|
||||
} \
|
||||
catch(exception &) \
|
||||
{ \
|
||||
}
|
||||
|
||||
namespace test // memory tracking (enabled if test new and delete linked in)
|
||||
{
|
||||
class allocations
|
||||
{
|
||||
public: // singleton access
|
||||
|
||||
static allocations & instance()
|
||||
{
|
||||
static allocations singleton;
|
||||
return singleton;
|
||||
}
|
||||
|
||||
public: // logging
|
||||
|
||||
void clear()
|
||||
{
|
||||
alloc_count = dealloc_count = 0;
|
||||
}
|
||||
|
||||
void allocation()
|
||||
{
|
||||
++alloc_count;
|
||||
}
|
||||
|
||||
void deallocation()
|
||||
{
|
||||
++dealloc_count;
|
||||
}
|
||||
|
||||
public: // reporting
|
||||
|
||||
unsigned long allocated() const
|
||||
{
|
||||
return alloc_count;
|
||||
}
|
||||
|
||||
unsigned long deallocated() const
|
||||
{
|
||||
return dealloc_count;
|
||||
}
|
||||
|
||||
bool balanced() const
|
||||
{
|
||||
return alloc_count == dealloc_count;
|
||||
}
|
||||
|
||||
private: // structors (default dtor is fine)
|
||||
|
||||
allocations()
|
||||
: alloc_count(0), dealloc_count(0)
|
||||
{
|
||||
}
|
||||
|
||||
private: // prevention
|
||||
|
||||
allocations(const allocations &);
|
||||
allocations & operator=(const allocations &);
|
||||
|
||||
private: // state
|
||||
|
||||
unsigned long alloc_count, dealloc_count;
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
namespace test // tester is the driver class for a sequence of tests
|
||||
{
|
||||
template<typename test_iterator>
|
||||
class tester
|
||||
{
|
||||
public: // structors (default destructor is OK)
|
||||
|
||||
tester(test_iterator first_test, test_iterator after_last_test)
|
||||
: begin(first_test), end(after_last_test)
|
||||
{
|
||||
}
|
||||
|
||||
public: // usage
|
||||
|
||||
bool operator()(); // returns true if all tests passed
|
||||
|
||||
private: // representation
|
||||
|
||||
test_iterator begin, end;
|
||||
|
||||
private: // prevention
|
||||
|
||||
tester(const tester &);
|
||||
tester &operator=(const tester &);
|
||||
|
||||
};
|
||||
|
||||
template<typename test_iterator>
|
||||
bool tester<test_iterator>::operator()()
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
unsigned long passed = 0, failed = 0, unimplemented = 0;
|
||||
|
||||
for(test_iterator current = begin; current != end; ++current)
|
||||
{
|
||||
cerr << "[" << current->name << "] " << flush;
|
||||
string result = "passed"; // optimistic
|
||||
|
||||
try
|
||||
{
|
||||
allocations::instance().clear();
|
||||
current->action();
|
||||
|
||||
if(!allocations::instance().balanced())
|
||||
{
|
||||
unsigned long allocated = allocations::instance().allocated();
|
||||
unsigned long deallocated = allocations::instance().deallocated();
|
||||
ostrstream report;
|
||||
report << "new/delete ("
|
||||
<< allocated << " allocated, "
|
||||
<< deallocated << " deallocated)"
|
||||
<< ends;
|
||||
const char * text = report.str();
|
||||
report.freeze(false);
|
||||
throw failure(text);
|
||||
}
|
||||
|
||||
++passed;
|
||||
}
|
||||
catch(const failure & caught)
|
||||
{
|
||||
(result = "failed: ") += caught.what();
|
||||
++failed;
|
||||
}
|
||||
catch(const not_implemented &)
|
||||
{
|
||||
result = "not implemented";
|
||||
++unimplemented;
|
||||
}
|
||||
catch(const exception & caught)
|
||||
{
|
||||
(result = "exception: ") += caught.what();
|
||||
++failed;
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
result = "failed with unknown exception";
|
||||
++failed;
|
||||
}
|
||||
|
||||
cerr << result << endl;
|
||||
}
|
||||
|
||||
cerr << passed + failed << " tests: "
|
||||
<< passed << " passed, "
|
||||
<< failed << " failed";
|
||||
|
||||
if(unimplemented)
|
||||
{
|
||||
cerr << " (" << unimplemented << " not implemented)";
|
||||
}
|
||||
|
||||
cerr << endl;
|
||||
|
||||
return failed == 0;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
// Copyright Kevlin Henney, 2000. All rights reserved.
|
||||
//
|
||||
// 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)
|
||||
@@ -1,84 +0,0 @@
|
||||
# Copyright Antony Polukhin, 2021-2026.
|
||||
#
|
||||
# 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
|
||||
|
||||
if(NOT TARGET tests)
|
||||
add_custom_target(tests)
|
||||
endif()
|
||||
|
||||
function(boost_lexical_cast_add_test_impl test_name test_file libs)
|
||||
add_executable(${test_name} ${test_file})
|
||||
target_link_libraries(${test_name} PRIVATE ${libs})
|
||||
add_test(NAME ${test_name} COMMAND ${test_name})
|
||||
add_dependencies(tests ${test_name})
|
||||
endfunction()
|
||||
|
||||
function(boost_lexical_cast_add_test name libs)
|
||||
set(test_name lexical_cast_${name})
|
||||
set(test_file ${name}.cpp)
|
||||
boost_lexical_cast_add_test_impl(${test_name} ${test_file} "Boost::lexical_cast;${libs}")
|
||||
endfunction()
|
||||
|
||||
boost_lexical_cast_add_test(lexical_cast_test Boost::type_traits)
|
||||
boost_lexical_cast_add_test(loopback_test "")
|
||||
boost_lexical_cast_add_test(abstract_test "")
|
||||
boost_lexical_cast_add_test(noncopyable_test "")
|
||||
boost_lexical_cast_add_test(vc8_bug_test "")
|
||||
boost_lexical_cast_add_test(implicit_convert "")
|
||||
boost_lexical_cast_add_test(wchars_test "")
|
||||
boost_lexical_cast_add_test(float_types_test "")
|
||||
|
||||
if(NOT MSVC)
|
||||
# Make sure that LexicalCast works the same way as some of the C++ Standard Libraries
|
||||
boost_lexical_cast_add_test_impl(lexical_cast_float_types_non_opt float_types_test.cpp Boost::lexical_cast)
|
||||
target_compile_definitions(lexical_cast_float_types_non_opt PRIVATE BOOST_LEXICAL_CAST_DETAIL_TEST_ON_OLD)
|
||||
endif()
|
||||
|
||||
boost_lexical_cast_add_test(inf_nan_test "")
|
||||
boost_lexical_cast_add_test(containers_test "")
|
||||
boost_lexical_cast_add_test(empty_input_test Boost::range)
|
||||
boost_lexical_cast_add_test(pointers_test "")
|
||||
|
||||
if(MSVC)
|
||||
add_executable(lexical_cast_typedefed_wchar_test_compile typedefed_wchar_test.cpp)
|
||||
target_compile_options(lexical_cast_typedefed_wchar_test_compile PRIVATE "/Zc:wchar_t-")
|
||||
|
||||
boost_lexical_cast_add_test(typedefed_wchar_test_runtime "")
|
||||
target_compile_options(lexical_cast_typedefed_wchar_test_runtime PRIVATE "/Zc:wchar_t-")
|
||||
endif()
|
||||
|
||||
boost_lexical_cast_add_test(no_locale_test Boost::range)
|
||||
target_compile_definitions(lexical_cast_no_locale_test
|
||||
PRIVATE
|
||||
BOOST_NO_STD_LOCALE
|
||||
BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
|
||||
)
|
||||
|
||||
boost_lexical_cast_add_test_impl(lexical_cast_no_exceptions_test no_exceptions_test.cpp "Boost::container;Boost::range")
|
||||
target_include_directories(lexical_cast_no_exceptions_test PRIVATE ../include)
|
||||
target_compile_definitions(lexical_cast_no_exceptions_test
|
||||
PRIVATE
|
||||
_HAS_EXCEPTIONS=0 # MSVC stdlib
|
||||
_STLP_NO_EXCEPTIONS # STLPort
|
||||
)
|
||||
if(MSVC)
|
||||
target_compile_definitions(lexical_cast_no_exceptions_test PRIVATE BOOST_NO_EXCEPTIONS)
|
||||
endif()
|
||||
target_compile_options(lexical_cast_no_exceptions_test PRIVATE "-fno-exceptions")
|
||||
|
||||
boost_lexical_cast_add_test(iterator_range_test Boost::range)
|
||||
boost_lexical_cast_add_test(string_view_test Boost::utility)
|
||||
boost_lexical_cast_add_test(arrays_test Boost::array)
|
||||
boost_lexical_cast_add_test(integral_types_test Boost::type_traits)
|
||||
boost_lexical_cast_add_test(stream_detection_test "")
|
||||
boost_lexical_cast_add_test(stream_traits_test "Boost::array;Boost::range;Boost::utility")
|
||||
|
||||
boost_lexical_cast_add_test(filesystem_test Boost::filesystem)
|
||||
boost_lexical_cast_add_test(try_lexical_convert "")
|
||||
|
||||
file(GLOB EXAMPLE_FILES "../example/*.cpp")
|
||||
foreach (testsourcefile ${EXAMPLE_FILES})
|
||||
get_filename_component(testname ${testsourcefile} NAME_WE)
|
||||
boost_lexical_cast_add_test_impl(lexical_cast_example_${testname} ${testsourcefile} "Boost::variant;Boost::date_time")
|
||||
endforeach()
|
||||
@@ -0,0 +1,34 @@
|
||||
# Signals library
|
||||
|
||||
# Copyright (C) 2001-2003 Douglas Gregor
|
||||
|
||||
# Permission to copy, use, sell and distribute this software is granted
|
||||
# provided this copyright notice appears in all copies. Permission to modify
|
||||
# the code and to distribute modified code is granted provided this copyright
|
||||
# notice appears in all copies, and a notice that the code was modified is
|
||||
# included with the copyright notice. This software is provided "as is"
|
||||
# without express or implied warranty, and with no claim as to its suitability
|
||||
# for any purpose.
|
||||
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
# Testing Jamfile autogenerated from XML source
|
||||
subproject libs/conversion/test ;
|
||||
|
||||
# bring in rules for testing
|
||||
import testing ;
|
||||
|
||||
# Make tests run by default.
|
||||
DEPENDS all : test ;
|
||||
|
||||
{
|
||||
test-suite conversion
|
||||
: [ run implicit_cast.cpp ]
|
||||
[ compile-fail implicit_cast_fail.cpp ]
|
||||
[ run ../cast_test.cpp ]
|
||||
[ run ../numeric_cast_test.cpp ]
|
||||
[ run ../lexical_cast_test.cpp ]
|
||||
;
|
||||
}
|
||||
|
||||
+18
-86
@@ -1,93 +1,25 @@
|
||||
# Signals library
|
||||
|
||||
# Copyright (C) 2001-2003 Douglas Gregor
|
||||
# Copyright Antony Polukhin, 2011-2026.
|
||||
#
|
||||
# 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)
|
||||
#
|
||||
|
||||
require-b2 5.0.1 ;
|
||||
import-search /boost/config/checks ;
|
||||
import config : requires ;
|
||||
# Permission to copy, use, sell and distribute this software is granted
|
||||
# provided this copyright notice appears in all copies. Permission to modify
|
||||
# the code and to distribute modified code is granted provided this copyright
|
||||
# notice appears in all copies, and a notice that the code was modified is
|
||||
# included with the copyright notice. This software is provided "as is"
|
||||
# without express or implied warranty, and with no claim as to its suitability
|
||||
# for any purpose.
|
||||
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
# bring in rules for testing
|
||||
import testing ;
|
||||
import feature ;
|
||||
|
||||
project
|
||||
: requirements
|
||||
<library>/boost/lexical_cast//boost_lexical_cast
|
||||
[ requires cxx11_rvalue_references cxx11_static_assert cxx11_template_aliases ]
|
||||
<link>static
|
||||
<toolset>gcc-4.7:<cxxflags>-ftrapv
|
||||
<toolset>gcc-4.6:<cxxflags>-ftrapv
|
||||
<toolset>clang:<cxxflags>-ftrapv
|
||||
# default to all warnings on:
|
||||
<warnings>all
|
||||
# set warnings as errors for those compilers we know we get warning free:
|
||||
<toolset>gcc:<cxxflags>-Wextra
|
||||
|
||||
# Not a lexical_cast related warning: boost/preprocessor/variadic/elem.hpp:29:46: warning: variadic macros are a C99 feature
|
||||
<toolset>clang:<cxxflags>-Wno-variadic-macros
|
||||
<toolset>gcc:<cxxflags>-Wno-variadic-macros
|
||||
|
||||
# Not a lexical_cast related warning: boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp:78:1: warning: empty macro arguments are a C99 feature [-Wc99-extensions]
|
||||
# boost/mpl/iter_fold.hpp:45:1: warning: empty macro arguments are a C99 feature [-Wc99-extensions]
|
||||
<toolset>clang:<cxxflags>-Wno-c99-extensions
|
||||
|
||||
<library>/boost/array//boost_array
|
||||
<library>/boost/range//boost_range
|
||||
<library>/boost/utility//boost_utility
|
||||
;
|
||||
|
||||
# Thanks to Steven Watanabe for helping with <nowchar> feature
|
||||
feature.feature nowchar : on :
|
||||
composite optional propagated link-incompatible ;
|
||||
feature.compose <nowchar>on : <cxxflags>"/Zc:wchar_t-" ;
|
||||
|
||||
test-suite conversion
|
||||
: [ run lexical_cast_test.cpp ]
|
||||
[ run loopback_test.cpp ]
|
||||
[ run abstract_test.cpp ]
|
||||
[ run noncopyable_test.cpp ]
|
||||
[ run vc8_bug_test.cpp ]
|
||||
[ run implicit_convert.cpp ]
|
||||
[ run wchars_test.cpp ]
|
||||
[ run float_types_test.cpp ]
|
||||
|
||||
# Make sure that LexicalCast works the same way as some of the C++ Standard Libraries
|
||||
[ run float_types_test.cpp : : : <define>BOOST_LEXICAL_CAST_DETAIL_TEST_ON_OLD
|
||||
<toolset>msvc:<build>no # could have outdated behavior in some border cases
|
||||
<target-os>darwin:<build>no # may have outdated behavior in some border cases
|
||||
: float_types_non_opt
|
||||
]
|
||||
|
||||
[ run inf_nan_test.cpp ]
|
||||
[ run containers_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>clang:<cxxflags>-Wno-long-long ]
|
||||
[ run empty_input_test.cpp ]
|
||||
[ run pointers_test.cpp ]
|
||||
[ compile typedefed_wchar_test.cpp : <toolset>msvc:<nowchar>on <library>/boost/date_time//boost_date_time ]
|
||||
[ run typedefed_wchar_test_runtime.cpp : : : <toolset>msvc:<nowchar>on <toolset>msvc,<stdlib>stlport:<build>no ]
|
||||
[ run no_locale_test.cpp : : : <define>BOOST_NO_STD_LOCALE <define>BOOST_LEXICAL_CAST_ASSUME_C_LOCALE ]
|
||||
[ run no_exceptions_test.cpp : : : <exception-handling>off
|
||||
<define>_HAS_EXCEPTIONS=0 # MSVC stdlib
|
||||
<define>_STLP_NO_EXCEPTIONS # STLPort
|
||||
]
|
||||
[ run iterator_range_test.cpp ]
|
||||
[ run string_view_test.cpp ]
|
||||
[ run arrays_test.cpp : : :
|
||||
<toolset>msvc:<cxxflags>/wd4512 # assignment operator could not be generated
|
||||
]
|
||||
[ run integral_types_test.cpp ]
|
||||
[ run stream_detection_test.cpp ]
|
||||
[ run stream_traits_test.cpp ]
|
||||
[ compile-fail to_pointer_test.cpp ]
|
||||
[ compile-fail from_volatile.cpp ]
|
||||
[ run filesystem_test.cpp /boost/filesystem//boost_filesystem : : : <toolset>gcc,<target-os>windows:<build>no ] # Boost.Atomic no longer supports MinGW
|
||||
[ run try_lexical_convert.cpp ]
|
||||
: [ run implicit_cast.cpp ]
|
||||
[ compile-fail implicit_cast_fail.cpp ]
|
||||
[ run ../cast_test.cpp ]
|
||||
[ run ../lexical_cast_test.cpp ]
|
||||
;
|
||||
|
||||
# Assuring that examples compile and run. Adding sources from `example` directory to the `conversion` test suite.
|
||||
for local p in [ glob ../example/*.cpp ]
|
||||
{
|
||||
conversion += [ run $(p) : : : <library>/boost/variant//boost_variant <library>/boost/date_time//boost_date_time ] ;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -1,49 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Sergey Shandar 2005, Alexander Nasonov, 2007.
|
||||
// Copyright Antony Polukhin, 2023-2026.
|
||||
//
|
||||
// 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).
|
||||
//
|
||||
// Test abstract class. Bug 1358600:
|
||||
// http://sf.net/tracker/?func=detail&aid=1358600&group_id=7586&atid=107586
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
class A
|
||||
{
|
||||
public:
|
||||
virtual void out(std::ostream &) const = 0;
|
||||
virtual ~A() {}
|
||||
};
|
||||
|
||||
class B: public A
|
||||
{
|
||||
public:
|
||||
virtual void out(std::ostream &O) const { O << "B"; }
|
||||
};
|
||||
|
||||
std::ostream &operator<<(std::ostream &O, const A &a)
|
||||
{
|
||||
a.out(O);
|
||||
return O;
|
||||
}
|
||||
|
||||
void test_abstract()
|
||||
{
|
||||
const A &a = B();
|
||||
BOOST_TEST(boost::lexical_cast<std::string>(a) == "B");
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_abstract();
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@@ -1,100 +0,0 @@
|
||||
# Use, modification, and distribution are
|
||||
# subject to 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)
|
||||
#
|
||||
# Copyright Antony Polukhin, 2016-2026.
|
||||
|
||||
#
|
||||
# See https://svn.boost.org/trac/boost/wiki/TravisCoverals for description of this file
|
||||
# and how it can be used with Boost libraries.
|
||||
#
|
||||
# File revision #6
|
||||
|
||||
init:
|
||||
# boost-local/libs/ folder to put this library into. This may be useful, if you're for example running Travis
|
||||
# from `Boost.DLL` repo while Boost already has `dll` and with to replace `dll` with content of`Boost.DLL`.
|
||||
#
|
||||
# Otherwise just leave the default value - set BOOST_LIBS_FOLDER=%APPVEYOR_PROJECT_NAME%
|
||||
- set BOOST_LIBS_FOLDER=%APPVEYOR_PROJECT_NAME%
|
||||
|
||||
###############################################################################################################
|
||||
# From this point and below code is same for all the Boost libs
|
||||
###############################################################################################################
|
||||
|
||||
version: 1.74.{build}-{branch}
|
||||
|
||||
# branches to build
|
||||
branches:
|
||||
except:
|
||||
- gh-pages
|
||||
|
||||
skip_tags: true
|
||||
|
||||
environment:
|
||||
matrix:
|
||||
# - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
|
||||
# TOOLSET: msvc # TODO: clang-win ???
|
||||
# ADDRMD: 32,64
|
||||
# CXXSTD: 17,latest
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
TOOLSET: msvc # clang-win has problems with structured bindings - it can not correclty use std::tuple_size
|
||||
ADDRMD: 32,64
|
||||
CXXSTD: 17,latest
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
TOOLSET: msvc # clang-win has problems with structured bindings - it can not correclty use std::tuple_size
|
||||
ADDRMD: 32,64
|
||||
CXXSTD: 17,latest
|
||||
CXXFLAGS: /permissive-
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
TOOLSET: msvc # clang-win has problems with structured bindings - it can not correclty use std::tuple_size
|
||||
ADDRMD: 32,64
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
ADDPATH: C:\cygwin\bin;
|
||||
TOOLSET: gcc
|
||||
CXXSTD: 14,1z
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
ADDPATH: C:\cygwin64\bin;
|
||||
TOOLSET: gcc
|
||||
CXXSTD: 14,1z
|
||||
# - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
# ADDPATH: C:\mingw\bin;
|
||||
# TOOLSET: gcc
|
||||
# CXXSTD: 14,1z
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
ADDPATH: C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;
|
||||
TOOLSET: gcc
|
||||
CXXSTD: 14,1z
|
||||
|
||||
before_build:
|
||||
- set BOOST_BRANCH=develop
|
||||
- if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
|
||||
- echo "Testing %BOOST_LIBS_FOLDER%"
|
||||
# Cloning Boost libraries (fast nondeep cloning)
|
||||
- set BOOST=C:/boost-local
|
||||
- git clone -b %BOOST_BRANCH% --depth 10 https://github.com/boostorg/boost.git %BOOST%
|
||||
- cd %BOOST%
|
||||
- git submodule update --init --depth 10 tools/build tools/boostdep
|
||||
|
||||
- echo "rm -rf %BOOST%/libs/%BOOST_LIBS_FOLDER%"
|
||||
- rm -rf %BOOST%/libs/%BOOST_LIBS_FOLDER%
|
||||
- mv %APPVEYOR_BUILD_FOLDER% %BOOST%/libs/%BOOST_LIBS_FOLDER%
|
||||
- python tools/boostdep/depinst/depinst.py --git_args "--depth 10 --jobs 2" -I example -I examples %BOOST_LIBS_FOLDER%
|
||||
|
||||
build_script:
|
||||
- cmd /c bootstrap
|
||||
- b2.exe headers
|
||||
- cd %BOOST%/libs/%BOOST_LIBS_FOLDER%/test
|
||||
|
||||
after_build:
|
||||
before_test:
|
||||
test_script:
|
||||
- PATH=%ADDPATH%%PATH%
|
||||
- if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
|
||||
- if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
|
||||
- echo "Running command ..\..\..\b2 -j3 toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release"
|
||||
- ..\..\..\b2.exe -j3 toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release cxxflags="-DBOOST_TRAVISCI_BUILD %CXXFLAGS%"
|
||||
|
||||
after_test:
|
||||
on_success:
|
||||
on_failure:
|
||||
on_finish:
|
||||
@@ -1,373 +0,0 @@
|
||||
// Testing boost::lexical_cast with boost::container::string.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2012-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/array.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
using namespace boost;
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION) && !defined(BOOST_MSVC)
|
||||
#define BOOST_LC_RUNU16
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION) && !defined(BOOST_MSVC)
|
||||
#define BOOST_LC_RUNU32
|
||||
#endif
|
||||
|
||||
template <template <class, std::size_t> class ArrayT, class T>
|
||||
static void testing_template_array_output_on_spec_value(T val)
|
||||
{
|
||||
typedef ArrayT<char, 300> arr_type;
|
||||
typedef ArrayT<char, 1> short_arr_type;
|
||||
typedef ArrayT<unsigned char, 300> uarr_type;
|
||||
typedef ArrayT<unsigned char, 1> ushort_arr_type;
|
||||
typedef ArrayT<signed char, 4> sarr_type;
|
||||
typedef ArrayT<signed char, 3> sshort_arr_type;
|
||||
|
||||
std::string ethalon("100");
|
||||
using namespace std;
|
||||
|
||||
{
|
||||
arr_type res1 = lexical_cast<arr_type>(val);
|
||||
BOOST_TEST_EQ(&res1[0], ethalon);
|
||||
const arr_type res2 = lexical_cast<arr_type>(val);
|
||||
BOOST_TEST_EQ(&res2[0], ethalon);
|
||||
BOOST_TEST_THROWS(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
|
||||
}
|
||||
|
||||
{
|
||||
uarr_type res1 = lexical_cast<uarr_type>(val);
|
||||
BOOST_TEST_EQ(reinterpret_cast<char*>(&res1[0]), ethalon);
|
||||
const uarr_type res2 = lexical_cast<uarr_type>(val);
|
||||
BOOST_TEST_EQ(reinterpret_cast<const char*>(&res2[0]), ethalon);
|
||||
BOOST_TEST_THROWS(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
|
||||
}
|
||||
|
||||
{
|
||||
sarr_type res1 = lexical_cast<sarr_type>(val);
|
||||
BOOST_TEST_EQ(reinterpret_cast<char*>(&res1[0]), ethalon);
|
||||
const sarr_type res2 = lexical_cast<sarr_type>(val);
|
||||
BOOST_TEST_EQ(reinterpret_cast<const char*>(&res2[0]), ethalon);
|
||||
BOOST_TEST_THROWS(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
|
||||
}
|
||||
|
||||
#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING) && !defined(_LIBCPP_VERSION)
|
||||
typedef ArrayT<wchar_t, 300> warr_type;
|
||||
typedef ArrayT<wchar_t, 3> wshort_arr_type;
|
||||
std::wstring wethalon(L"100");
|
||||
|
||||
{
|
||||
warr_type res = lexical_cast<warr_type>(val);
|
||||
BOOST_TEST(&res[0] == wethalon);
|
||||
}
|
||||
|
||||
{
|
||||
const warr_type res = lexical_cast<warr_type>(val);
|
||||
BOOST_TEST(&res[0] == wethalon);
|
||||
}
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_LC_RUNU16
|
||||
typedef ArrayT<char16_t, 300> u16arr_type;
|
||||
typedef ArrayT<char16_t, 3> u16short_arr_type;
|
||||
std::u16string u16ethalon(u"100");
|
||||
|
||||
{
|
||||
u16arr_type res = lexical_cast<u16arr_type>(val);
|
||||
BOOST_TEST(&res[0] == u16ethalon);
|
||||
}
|
||||
|
||||
{
|
||||
const u16arr_type res = lexical_cast<u16arr_type>(val);
|
||||
BOOST_TEST(&res[0] == u16ethalon);
|
||||
}
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_LC_RUNU32
|
||||
typedef ArrayT<char32_t, 300> u32arr_type;
|
||||
typedef ArrayT<char32_t, 3> u32short_arr_type;
|
||||
std::u32string u32ethalon(U"100");
|
||||
|
||||
{
|
||||
u32arr_type res = lexical_cast<u32arr_type>(val);
|
||||
BOOST_TEST(&res[0] == u32ethalon);
|
||||
}
|
||||
|
||||
{
|
||||
const u32arr_type res = lexical_cast<u32arr_type>(val);
|
||||
BOOST_TEST(&res[0] == u32ethalon);
|
||||
}
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<u32short_arr_type>(val), boost::bad_lexical_cast);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
template <template <class, std::size_t> class ArrayT>
|
||||
static void testing_template_array_output_on_char_value()
|
||||
{
|
||||
typedef ArrayT<char, 300> arr_type;
|
||||
typedef ArrayT<char, 1> short_arr_type;
|
||||
typedef ArrayT<unsigned char, 300> uarr_type;
|
||||
typedef ArrayT<unsigned char, 1> ushort_arr_type;
|
||||
typedef ArrayT<signed char, 4> sarr_type;
|
||||
typedef ArrayT<signed char, 3> sshort_arr_type;
|
||||
|
||||
const char val[] = "100";
|
||||
std::string ethalon("100");
|
||||
using namespace std;
|
||||
|
||||
{
|
||||
arr_type res1 = lexical_cast<arr_type>(val);
|
||||
BOOST_TEST_EQ(&res1[0], ethalon);
|
||||
const arr_type res2 = lexical_cast<arr_type>(val);
|
||||
BOOST_TEST_EQ(&res2[0], ethalon);
|
||||
BOOST_TEST_THROWS(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
|
||||
}
|
||||
|
||||
{
|
||||
uarr_type res1 = lexical_cast<uarr_type>(val);
|
||||
BOOST_TEST_EQ(reinterpret_cast<char*>(&res1[0]), ethalon);
|
||||
const uarr_type res2 = lexical_cast<uarr_type>(val);
|
||||
BOOST_TEST_EQ(reinterpret_cast<const char*>(&res2[0]), ethalon);
|
||||
BOOST_TEST_THROWS(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
|
||||
}
|
||||
|
||||
{
|
||||
sarr_type res1 = lexical_cast<sarr_type>(val);
|
||||
BOOST_TEST_EQ(reinterpret_cast<char*>(&res1[0]), ethalon);
|
||||
const sarr_type res2 = lexical_cast<sarr_type>(val);
|
||||
BOOST_TEST_EQ(reinterpret_cast<const char*>(&res2[0]), ethalon);
|
||||
BOOST_TEST_THROWS(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
|
||||
}
|
||||
|
||||
#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING) && !defined(_LIBCPP_VERSION)
|
||||
typedef ArrayT<wchar_t, 4> warr_type;
|
||||
typedef ArrayT<wchar_t, 3> wshort_arr_type;
|
||||
std::wstring wethalon(L"100");
|
||||
|
||||
{
|
||||
warr_type res = lexical_cast<warr_type>(val);
|
||||
BOOST_TEST(&res[0] == wethalon);
|
||||
warr_type res3 = lexical_cast<warr_type>(wethalon);
|
||||
BOOST_TEST(&res3[0] == wethalon);
|
||||
}
|
||||
|
||||
{
|
||||
const warr_type res = lexical_cast<warr_type>(val);
|
||||
BOOST_TEST(&res[0] == wethalon);
|
||||
const warr_type res3 = lexical_cast<warr_type>(wethalon);
|
||||
BOOST_TEST(&res3[0] == wethalon);
|
||||
}
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_LC_RUNU16
|
||||
typedef ArrayT<char16_t, 300> u16arr_type;
|
||||
typedef ArrayT<char16_t, 3> u16short_arr_type;
|
||||
std::u16string u16ethalon(u"100");
|
||||
|
||||
{
|
||||
#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
|
||||
u16arr_type res = lexical_cast<u16arr_type>(val);
|
||||
BOOST_TEST(&res[0] == u16ethalon);
|
||||
#endif
|
||||
|
||||
u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
|
||||
BOOST_TEST(&res3[0] == u16ethalon);
|
||||
}
|
||||
|
||||
{
|
||||
#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
|
||||
const u16arr_type res = lexical_cast<u16arr_type>(val);
|
||||
BOOST_TEST(&res[0] == u16ethalon);
|
||||
#endif
|
||||
const u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
|
||||
BOOST_TEST(&res3[0] == u16ethalon);
|
||||
}
|
||||
|
||||
// Some compillers may throw std::bad_alloc here
|
||||
BOOST_TEST_THROWS(lexical_cast<u16short_arr_type>(val), std::exception);
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_LC_RUNU32
|
||||
typedef ArrayT<char32_t, 300> u32arr_type;
|
||||
typedef ArrayT<char32_t, 3> u32short_arr_type;
|
||||
std::u32string u32ethalon(U"100");
|
||||
|
||||
{
|
||||
#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
|
||||
u32arr_type res = lexical_cast<u32arr_type>(val);
|
||||
BOOST_TEST(&res[0] == u32ethalon);
|
||||
#endif
|
||||
u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
|
||||
BOOST_TEST(&res3[0] == u32ethalon);
|
||||
}
|
||||
|
||||
{
|
||||
#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
|
||||
const u32arr_type res = lexical_cast<u32arr_type>(val);
|
||||
BOOST_TEST(&res[0] == u32ethalon);
|
||||
#endif
|
||||
const u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
|
||||
BOOST_TEST(&res3[0] == u32ethalon);
|
||||
}
|
||||
|
||||
// Some compillers may throw std::bad_alloc here
|
||||
BOOST_TEST_THROWS(lexical_cast<u32short_arr_type>(val), std::exception);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void testing_boost_array_output_conversion()
|
||||
{
|
||||
#ifndef _LIBCPP_VERSION
|
||||
testing_template_array_output_on_char_value<boost::array>();
|
||||
testing_template_array_output_on_spec_value<boost::array>(100);
|
||||
testing_template_array_output_on_spec_value<boost::array>(static_cast<short>(100));
|
||||
testing_template_array_output_on_spec_value<boost::array>(static_cast<unsigned short>(100));
|
||||
testing_template_array_output_on_spec_value<boost::array>(static_cast<unsigned int>(100));
|
||||
#endif
|
||||
}
|
||||
|
||||
void testing_std_array_output_conversion()
|
||||
{
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
testing_template_array_output_on_char_value<std::array>();
|
||||
testing_template_array_output_on_spec_value<std::array>(100);
|
||||
testing_template_array_output_on_spec_value<std::array>(static_cast<short>(100));
|
||||
testing_template_array_output_on_spec_value<std::array>(static_cast<unsigned short>(100));
|
||||
testing_template_array_output_on_spec_value<std::array>(static_cast<unsigned int>(100));
|
||||
#endif
|
||||
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
template <template <class, std::size_t> class ArrayT>
|
||||
static void testing_generic_array_input_conversion()
|
||||
{
|
||||
{
|
||||
ArrayT<char, 4> var_zero_terminated = {{ '1', '0', '0', '\0'}};
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(var_zero_terminated), "100");
|
||||
BOOST_TEST_EQ(lexical_cast<int>(var_zero_terminated), 100);
|
||||
|
||||
ArrayT<char, 3> var_none_terminated = {{ '1', '0', '0'}};
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(var_none_terminated), "100");
|
||||
BOOST_TEST_EQ(lexical_cast<short>(var_none_terminated), static_cast<short>(100));
|
||||
|
||||
ArrayT<const char, 4> var_zero_terminated_const_char = {{ '1', '0', '0', '\0'}};
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(var_zero_terminated_const_char), "100");
|
||||
|
||||
ArrayT<const char, 3> var_none_terminated_const_char = {{ '1', '0', '0'}};
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(var_none_terminated_const_char), "100");
|
||||
|
||||
const ArrayT<char, 4> var_zero_terminated_const_var = {{ '1', '0', '0', '\0'}};
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(var_zero_terminated_const_var), "100");
|
||||
|
||||
const ArrayT<char, 3> var_none_terminated_const_var = {{ '1', '0', '0'}};
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(var_none_terminated_const_var), "100");
|
||||
|
||||
const ArrayT<const char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}};
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
|
||||
|
||||
const ArrayT<const char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}};
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
|
||||
BOOST_TEST_EQ(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
|
||||
}
|
||||
|
||||
{
|
||||
const ArrayT<const unsigned char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}};
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
|
||||
|
||||
const ArrayT<const unsigned char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}};
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
|
||||
}
|
||||
|
||||
{
|
||||
const ArrayT<const signed char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}};
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
|
||||
|
||||
const ArrayT<const signed char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}};
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned int>(var_none_terminated_const_var_const_char), 100u);
|
||||
}
|
||||
|
||||
|
||||
#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
|
||||
{
|
||||
const ArrayT<const wchar_t, 4> var_zero_terminated_const_var_const_char = {{ L'1', L'0', L'0', L'\0'}};
|
||||
BOOST_TEST(lexical_cast<std::wstring>(var_zero_terminated_const_var_const_char) == L"100");
|
||||
|
||||
const ArrayT<const wchar_t, 3> var_none_terminated_const_var_const_char = {{ L'1', L'0', L'0'}};
|
||||
BOOST_TEST(lexical_cast<std::wstring>(var_none_terminated_const_var_const_char) == L"100");
|
||||
BOOST_TEST_EQ(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_LC_RUNU16
|
||||
{
|
||||
const ArrayT<const char16_t, 4> var_zero_terminated_const_var_const_char = {{ u'1', u'0', u'0', u'\0'}};
|
||||
BOOST_TEST(lexical_cast<std::u16string>(var_zero_terminated_const_var_const_char) == u"100");
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned short>(var_zero_terminated_const_var_const_char), static_cast<unsigned short>(100));
|
||||
|
||||
const ArrayT<const char16_t, 3> var_none_terminated_const_var_const_char = {{ u'1', u'0', u'0'}};
|
||||
BOOST_TEST(lexical_cast<std::u16string>(var_none_terminated_const_var_const_char) == u"100");
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_LC_RUNU32
|
||||
{
|
||||
const ArrayT<const char32_t, 4> var_zero_terminated_const_var_const_char = {{ U'1', U'0', U'0', U'\0'}};
|
||||
BOOST_TEST(lexical_cast<std::u32string>(var_zero_terminated_const_var_const_char) == U"100");
|
||||
|
||||
const ArrayT<const char32_t, 3> var_none_terminated_const_var_const_char = {{ U'1', U'0', U'0'}};
|
||||
BOOST_TEST(lexical_cast<std::u32string>(var_none_terminated_const_var_const_char) == U"100");
|
||||
BOOST_TEST_EQ(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void testing_boost_array_input_conversion()
|
||||
{
|
||||
#ifndef _LIBCPP_VERSION
|
||||
testing_generic_array_input_conversion<boost::array>();
|
||||
#endif
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
void testing_std_array_input_conversion()
|
||||
{
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
testing_generic_array_input_conversion<std::array>();
|
||||
#endif
|
||||
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
testing_boost_array_output_conversion();
|
||||
testing_std_array_output_conversion();
|
||||
testing_boost_array_input_conversion();
|
||||
testing_std_array_input_conversion();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@@ -1,80 +0,0 @@
|
||||
# Copyright (c) 2016-2025 Antony Polukhin
|
||||
# Copyright (c) 2025-2026 Fedor Osetrov
|
||||
# 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
|
||||
|
||||
cmake_minimum_required(VERSION 3.5...4.0)
|
||||
|
||||
project(lexical_cast_subdir_test LANGUAGES CXX)
|
||||
|
||||
set(deps
|
||||
|
||||
# Library dependencies
|
||||
config
|
||||
container
|
||||
core
|
||||
throw_exception
|
||||
|
||||
# Test dependencies
|
||||
algorithm
|
||||
array
|
||||
align
|
||||
assert
|
||||
atomic
|
||||
bind
|
||||
compat
|
||||
concept_check
|
||||
container_hash
|
||||
conversion
|
||||
date_time
|
||||
describe
|
||||
detail
|
||||
exception
|
||||
filesystem
|
||||
function
|
||||
function_types
|
||||
functional
|
||||
fusion
|
||||
integer
|
||||
intrusive
|
||||
io
|
||||
iterator
|
||||
move
|
||||
mp11
|
||||
mpl
|
||||
numeric/conversion
|
||||
optional
|
||||
predef
|
||||
preprocessor
|
||||
range
|
||||
regex
|
||||
scope
|
||||
smart_ptr
|
||||
static_assert
|
||||
system
|
||||
test
|
||||
tokenizer
|
||||
tuple
|
||||
type_index
|
||||
type_traits
|
||||
typeof
|
||||
unordered
|
||||
utility
|
||||
variant
|
||||
variant2
|
||||
winapi
|
||||
)
|
||||
|
||||
foreach(dep IN LISTS deps)
|
||||
add_subdirectory(../../../${dep} boostorg/${dep})
|
||||
endforeach()
|
||||
|
||||
enable_testing()
|
||||
add_subdirectory(../../ boostorg/lexical_cast)
|
||||
|
||||
if (BOOST_USE_MODULES)
|
||||
add_executable(boost_lexical_cast_module_usage ../modules/usage_sample.cpp)
|
||||
target_link_libraries(boost_lexical_cast_module_usage PRIVATE Boost::lexical_cast)
|
||||
add_test(NAME boost_lexical_cast_module_usage COMMAND boost_lexical_cast_module_usage)
|
||||
endif()
|
||||
|
||||
@@ -1,77 +0,0 @@
|
||||
// Testing boost::lexical_cast with boost::container::string.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/container/string.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
using namespace boost;
|
||||
|
||||
void testing_boost_containers_basic_string()
|
||||
{
|
||||
BOOST_TEST("100" == lexical_cast<boost::container::string>("100"));
|
||||
BOOST_TEST(L"100" == lexical_cast<boost::container::wstring>(L"100"));
|
||||
|
||||
BOOST_TEST("100" == lexical_cast<boost::container::string>(100));
|
||||
boost::container::string str("1000");
|
||||
BOOST_TEST(1000 == lexical_cast<int>(str));
|
||||
}
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
|
||||
#define BOOST_LCAST_NO_WCHAR_T
|
||||
#endif
|
||||
|
||||
void testing_boost_containers_string_std_string()
|
||||
{
|
||||
std::string std_str("std_str");
|
||||
boost::container::string boost_str("boost_str");
|
||||
BOOST_TEST(boost::lexical_cast<std::string>(boost_str) == "boost_str");
|
||||
BOOST_TEST(boost::lexical_cast<boost::container::string>(std_str) == "std_str");
|
||||
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
std::wstring std_wstr(L"std_wstr");
|
||||
boost::container::wstring boost_wstr(L"boost_wstr");
|
||||
|
||||
BOOST_TEST(boost::lexical_cast<std::wstring>(boost_wstr) == L"boost_wstr");
|
||||
BOOST_TEST(boost::lexical_cast<boost::container::wstring>(std_wstr) == L"std_wstr");
|
||||
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
void testing_boost_containers_string_widening()
|
||||
{
|
||||
const char char_array[] = "Test string";
|
||||
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
const wchar_t wchar_array[] = L"Test string";
|
||||
BOOST_TEST(boost::lexical_cast<boost::container::wstring>(char_array) == wchar_array);
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
const char16_t char16_array[] = u"Test string";
|
||||
BOOST_TEST(boost::lexical_cast<boost::container::basic_string<char16_t> >(char_array) == char16_array);
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
const char32_t char32_array[] = U"Test string";
|
||||
BOOST_TEST(boost::lexical_cast<boost::container::basic_string<char32_t> >(char_array) == char32_array);
|
||||
#endif
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
testing_boost_containers_basic_string();
|
||||
testing_boost_containers_string_std_string();
|
||||
testing_boost_containers_string_widening();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,150 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/range/iterator_range.hpp>
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#include "escape_struct.hpp"
|
||||
|
||||
using namespace boost;
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
|
||||
#define BOOST_LCAST_NO_WCHAR_T
|
||||
#endif
|
||||
|
||||
template <class T>
|
||||
void do_test_on_empty_input(T& v)
|
||||
{
|
||||
BOOST_TEST_THROWS(lexical_cast<int>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<float>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<double>(v), bad_lexical_cast);
|
||||
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
|
||||
BOOST_TEST_THROWS(lexical_cast<long double>(v), bad_lexical_cast);
|
||||
#endif
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned int>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned short>(v), bad_lexical_cast);
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
BOOST_TEST_THROWS(lexical_cast<boost::ulong_long_type>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<boost::long_long_type>(v), bad_lexical_cast);
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned __int64>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<__int64>(v), bad_lexical_cast);
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_empty_iterator_range()
|
||||
{
|
||||
|
||||
boost::iterator_range<char*> v;
|
||||
do_test_on_empty_input(v);
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(v), std::string());
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
|
||||
|
||||
boost::iterator_range<const char*> cv;
|
||||
do_test_on_empty_input(cv);
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(cv), std::string());
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(cv), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned char>(cv), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<signed char>(cv), bad_lexical_cast);
|
||||
|
||||
const boost::iterator_range<const char*> ccv;
|
||||
do_test_on_empty_input(ccv);
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(ccv), std::string());
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(ccv), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned char>(ccv), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<signed char>(ccv), bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_empty_string()
|
||||
{
|
||||
std::string v;
|
||||
do_test_on_empty_input(v);
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
|
||||
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
std::wstring vw;
|
||||
do_test_on_empty_input(vw);
|
||||
BOOST_TEST_THROWS(lexical_cast<wchar_t>(vw), bad_lexical_cast);
|
||||
#endif
|
||||
|
||||
// Currently, no compiler and STL library fully support char16_t and char32_t
|
||||
//#ifndef BOOST_NO_CXX11_CHAR16_T
|
||||
// std::basic_string<char16_t> v16w;
|
||||
// do_test_on_empty_input(v16w);
|
||||
// BOOST_TEST_THROWS(lexical_cast<char16_t>(v16w), bad_lexical_cast);
|
||||
//#endif
|
||||
//#ifndef BOOST_NO_CXX11_CHAR32_T
|
||||
// std::basic_string<char32_t> v32w;
|
||||
// do_test_on_empty_input(v32w);
|
||||
// BOOST_TEST_THROWS(lexical_cast<char32_t>(v32w), bad_lexical_cast);
|
||||
//#endif
|
||||
}
|
||||
|
||||
void test_empty_user_class()
|
||||
{
|
||||
EscapeStruct v("");
|
||||
do_test_on_empty_input(v);
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
|
||||
}
|
||||
|
||||
namespace std {
|
||||
inline std::ostream & operator<<(std::ostream & out, const std::vector<long> & v)
|
||||
{
|
||||
std::ostream_iterator<long> it(out);
|
||||
std::copy(v.begin(), v.end(), it);
|
||||
BOOST_TEST(out);
|
||||
return out;
|
||||
}
|
||||
}
|
||||
|
||||
void test_empty_vector()
|
||||
{
|
||||
std::vector<long> v;
|
||||
do_test_on_empty_input(v);
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
|
||||
}
|
||||
|
||||
|
||||
struct my_string {
|
||||
friend std::ostream &operator<<(std::ostream& sout, my_string const&/* st*/) {
|
||||
return sout << "";
|
||||
}
|
||||
};
|
||||
|
||||
void test_empty_zero_terminated_string()
|
||||
{
|
||||
my_string st;
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(st), std::string());;
|
||||
}
|
||||
|
||||
|
||||
int main()
|
||||
{
|
||||
test_empty_iterator_range();
|
||||
test_empty_string();
|
||||
test_empty_user_class();
|
||||
test_empty_vector();
|
||||
test_empty_zero_terminated_string();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2020-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_TEST_ESCAPE_STRUCT_HPP_
|
||||
#define BOOST_LEXICAL_CAST_TEST_ESCAPE_STRUCT_HPP_
|
||||
|
||||
#include <istream>
|
||||
#include <ostream>
|
||||
|
||||
struct EscapeStruct
|
||||
{
|
||||
EscapeStruct() {}
|
||||
EscapeStruct(const std::string& s)
|
||||
: str_(s)
|
||||
{}
|
||||
|
||||
std::string str_;
|
||||
};
|
||||
|
||||
inline std::ostream& operator<< (std::ostream& o, const EscapeStruct& rhs)
|
||||
{
|
||||
return o << rhs.str_;
|
||||
}
|
||||
|
||||
inline std::istream& operator>> (std::istream& i, EscapeStruct& rhs)
|
||||
{
|
||||
return i >> rhs.str_;
|
||||
}
|
||||
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_TEST_ESCAPE_STRUCT_HPP_
|
||||
@@ -1,60 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2013-2026.
|
||||
//
|
||||
// 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).
|
||||
//
|
||||
// Test lexical_cast usage with long filesystem::path. Bug 7704.
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/filesystem/path.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
void test_filesystem()
|
||||
{
|
||||
boost::filesystem::path p;
|
||||
std::string s1 = "aaaaaaaaaaaaaaaaaaaaaaa";
|
||||
p = boost::lexical_cast<boost::filesystem::path>(s1);
|
||||
BOOST_TEST(!p.empty());
|
||||
BOOST_TEST_EQ(p, s1);
|
||||
p.clear();
|
||||
|
||||
const char ab[] = "aaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
|
||||
p = boost::lexical_cast<boost::filesystem::path>(ab);
|
||||
BOOST_TEST(!p.empty());
|
||||
BOOST_TEST_EQ(p, ab);
|
||||
|
||||
// Tests for
|
||||
// https://github.com/boostorg/lexical_cast/issues/25
|
||||
|
||||
const char quoted_path[] = "\"/home/my user\"";
|
||||
p = boost::lexical_cast<boost::filesystem::path>(quoted_path);
|
||||
BOOST_TEST(!p.empty());
|
||||
const char unquoted_path[] = "/home/my user";
|
||||
BOOST_TEST_EQ(p, boost::filesystem::path(unquoted_path));
|
||||
|
||||
// Converting back to std::string gives the initial string
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(p), quoted_path);
|
||||
|
||||
try {
|
||||
// Without quotes the path will have only `/home/my` in it.
|
||||
// `user` remains in the stream, so an exception must be thrown.
|
||||
p = boost::lexical_cast<boost::filesystem::path>(unquoted_path);
|
||||
BOOST_TEST(false);
|
||||
} catch (const boost::bad_lexical_cast& ) {
|
||||
// Exception is expected
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_filesystem();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@@ -1,604 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <sstream>
|
||||
#include <type_traits>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_DETAIL_TEST_ON_OLD
|
||||
#include <boost/lexical_cast/detail/type_traits.hpp>
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#else
|
||||
// Make sure that tests work the same way on non-optimized version
|
||||
#include "lexical_cast_old.hpp"
|
||||
#include <boost/lexical_cast/detail/type_traits.hpp>
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef BOOST_TEST_CLOSE_FRACTION
|
||||
// Naiive, but works for most tests in this file
|
||||
#define BOOST_TEST_CLOSE_FRACTION(x, y, eps) \
|
||||
BOOST_TEST(x - y + eps <= eps * 2); \
|
||||
BOOST_TEST(y - x + eps <= eps * 2);
|
||||
#endif
|
||||
|
||||
#if (defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__NetBSD__) \
|
||||
|| (defined(__hppa) && !defined(__OpenBSD__)) || (defined(__NO_LONG_DOUBLE_MATH) && (DBL_MANT_DIG != LDBL_MANT_DIG))) \
|
||||
|| defined(__MINGW64__)
|
||||
# define BOOST_LEXICAL_CAST_NO_LONG_DOUBLE_MATH_FUNCTIONS
|
||||
#endif
|
||||
|
||||
using namespace boost;
|
||||
|
||||
|
||||
// Replace "-,999" with "-999".
|
||||
template<class CharT>
|
||||
std::basic_string<CharT> to_str_gcc_workaround(std::basic_string<CharT> str)
|
||||
{
|
||||
std::locale loc;
|
||||
std::numpunct<CharT> const& np = BOOST_USE_FACET(std::numpunct<CharT>, loc);
|
||||
std::ctype<CharT> const& ct = BOOST_USE_FACET(std::ctype<CharT>, loc);
|
||||
|
||||
if(np.grouping().empty())
|
||||
return str;
|
||||
|
||||
CharT prefix[3] = { ct.widen('-'), np.thousands_sep(), CharT() };
|
||||
|
||||
if(str.find(prefix) != 0)
|
||||
return str;
|
||||
|
||||
prefix[1] = CharT();
|
||||
str.replace(0, 2, prefix);
|
||||
return str;
|
||||
}
|
||||
|
||||
template<class CharT, class T>
|
||||
std::basic_string<CharT> to_str(T t)
|
||||
{
|
||||
std::basic_ostringstream<CharT> o;
|
||||
o << t;
|
||||
return to_str_gcc_workaround(o.str());
|
||||
}
|
||||
|
||||
|
||||
template<class T>
|
||||
void test_conversion_from_to_float_for_locale()
|
||||
{
|
||||
std::locale current_locale;
|
||||
typedef std::numpunct<char> numpunct;
|
||||
numpunct const& np = BOOST_USE_FACET(numpunct, current_locale);
|
||||
if ( !np.grouping().empty() )
|
||||
{
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<T>( std::string("100") + np.thousands_sep() + np.thousands_sep() + "0" )
|
||||
, bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( std::string("100") + np.thousands_sep() ), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( np.thousands_sep() + std::string("100") ), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( std::string("1") + np.thousands_sep() + np.decimal_point() + "e10" ), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( std::string("1e10") + np.thousands_sep() ), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( std::string("1") + np.thousands_sep() + "e10" ), bad_lexical_cast);
|
||||
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
|
||||
#endif
|
||||
// Exception must not be thrown, when we are using no separators at all
|
||||
BOOST_TEST_CLOSE_FRACTION( lexical_cast<T>("30000"), static_cast<T>(30000), (std::numeric_limits<T>::epsilon()) );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Converts char* [and wchar_t*] to float number type and checks, that generated
|
||||
* number does not exceeds allowed epsilon.
|
||||
*/
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
#define CHECK_CLOSE_ABS_DIFF(VAL,PREFIX) \
|
||||
converted_val = lexical_cast<test_t>(#VAL); \
|
||||
BOOST_TEST_CLOSE_FRACTION( (static_cast<bool>(VAL ## L)? VAL ## L : std::numeric_limits<test_t>::epsilon()), \
|
||||
(converted_val ? converted_val : std::numeric_limits<test_t>::epsilon()), \
|
||||
std::numeric_limits<test_t>::epsilon() \
|
||||
); \
|
||||
BOOST_TEST_EQ(converted_val, lexical_cast<test_t>(L## #VAL) );
|
||||
|
||||
#else
|
||||
#define CHECK_CLOSE_ABS_DIFF(VAL,TYPE) \
|
||||
converted_val = lexical_cast<test_t>(#VAL); \
|
||||
BOOST_TEST_CLOSE_FRACTION( (static_cast<bool>(VAL ## L)? VAL ## L : std::numeric_limits<test_t>::epsilon()), \
|
||||
(converted_val ? converted_val : std::numeric_limits<test_t>::epsilon()), \
|
||||
std::numeric_limits<test_t>::epsilon() \
|
||||
);
|
||||
#endif
|
||||
|
||||
template <class TestType>
|
||||
void test_converion_to_float_types()
|
||||
{
|
||||
typedef TestType test_t;
|
||||
test_t converted_val;
|
||||
|
||||
BOOST_TEST_CLOSE_FRACTION(1.0, lexical_cast<test_t>('1'), (std::numeric_limits<test_t>::epsilon()));
|
||||
BOOST_TEST_EQ(0.0, lexical_cast<test_t>('0'));
|
||||
|
||||
unsigned char const uc_one = '1';
|
||||
unsigned char const uc_zero ='0';
|
||||
BOOST_TEST_CLOSE_FRACTION(1.0, lexical_cast<test_t>(uc_one), (std::numeric_limits<test_t>::epsilon()));
|
||||
BOOST_TEST_EQ(0.0, lexical_cast<test_t>(uc_zero));
|
||||
|
||||
signed char const sc_one = '1';
|
||||
signed char const sc_zero ='0';
|
||||
BOOST_TEST_CLOSE_FRACTION(1.0, lexical_cast<test_t>(sc_one), (std::numeric_limits<test_t>::epsilon()));
|
||||
BOOST_TEST_EQ(0.0, lexical_cast<test_t>(sc_zero));
|
||||
|
||||
BOOST_TEST_CLOSE_FRACTION(1e34L, lexical_cast<test_t>( "10000000000000000000000000000000000"), (std::numeric_limits<test_t>::epsilon() * 1e34L) );
|
||||
|
||||
// VC failes the next test
|
||||
// BOOST_TEST_CLOSE_FRACTION(1e-35L, lexical_cast<test_t>("0.00000000000000000000000000000000001"), (std::numeric_limits<test_t>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(
|
||||
0.1111111111111111111111111111111111111111111111111111111111111111111111111L
|
||||
, lexical_cast<test_t>("0.1111111111111111111111111111111111111111111111111111111111111111111111111")
|
||||
, (std::numeric_limits<test_t>::epsilon()) );
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1,test_t);
|
||||
BOOST_TEST_EQ(0,lexical_cast<test_t>("0"));
|
||||
CHECK_CLOSE_ABS_DIFF(-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1.0, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0.0, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1.0,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1e1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1.0e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0.0e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1.0e1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1e-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1.0e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0.0e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1.0e-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1E1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1.0E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0.0E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1.0E1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1E-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1.0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0.0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1.0E-1, test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(.0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(.0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-.0E-1, test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10.0, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00.0, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10.0,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10e1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10.0e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00.0e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10.0e1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10e-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10.0e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00.0e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10.0e-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10E1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10.0E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00.0E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10.0E1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10E-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10.0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00.0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10.0E-1, test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(-10101.0E-011, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10101093, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(10101093, test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(-.34, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(.34, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(.34e10, test_t);
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("-1.e"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("-1.E"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("1.e"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("1.E"), bad_lexical_cast);
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("1.0e"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("1.0E"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("10E"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("10e"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("1.0e-"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("1.0E-"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("10E-"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("10e-"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("e1"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("e-1"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("e-"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>(".e"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111ee"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111e-"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("."), bad_lexical_cast);
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("-B"), bad_lexical_cast);
|
||||
|
||||
// Following two tests are not valid for C++11 compilers
|
||||
//BOOST_TEST_THROWS(lexical_cast<test_t>("0xB"), bad_lexical_cast);
|
||||
//BOOST_TEST_THROWS(lexical_cast<test_t>("0x0"), bad_lexical_cast);
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("--1.0"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("1.0e--1"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("1.0.0"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("1e1e1"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("1.0e-1e-1"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>(" 1.0"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("1.0 "), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>(""), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("-"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>('\0'), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>('-'), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>('.'), bad_lexical_cast);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_float_typess_for_overflows()
|
||||
{
|
||||
typedef T test_t;
|
||||
test_t minvalue = (std::numeric_limits<test_t>::min)();
|
||||
std::string s_min_value = lexical_cast<std::string>(minvalue);
|
||||
BOOST_TEST_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(minvalue), (std::numeric_limits<test_t>::epsilon()));
|
||||
BOOST_TEST_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(s_min_value), (std::numeric_limits<test_t>::epsilon() * 2));
|
||||
|
||||
test_t maxvalue = (std::numeric_limits<test_t>::max)();
|
||||
std::string s_max_value = lexical_cast<std::string>(maxvalue);
|
||||
BOOST_TEST_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(maxvalue), (std::numeric_limits<test_t>::epsilon()));
|
||||
BOOST_TEST_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(s_max_value), (std::numeric_limits<test_t>::epsilon()));
|
||||
|
||||
#ifndef _LIBCPP_VERSION
|
||||
// libc++ had a bug in implementation of stream conversions for values that must be represented as infinity.
|
||||
// http://llvm.org/bugs/show_bug.cgi?id=15723#c4
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>(s_max_value+"1"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>(s_max_value+"9"), bad_lexical_cast);
|
||||
|
||||
// VC9 can fail the following tests on floats and doubles when using stingstream...
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("1"+s_max_value), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>("9"+s_max_value), bad_lexical_cast);
|
||||
#endif
|
||||
#if !(defined(_LIBCPP_VERSION) && defined(BOOST_LEXICAL_CAST_DETAIL_TEST_ON_OLD))
|
||||
if ( std::is_same<test_t,float>::value )
|
||||
{
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>( (std::numeric_limits<double>::max)() ), bad_lexical_cast);
|
||||
BOOST_TEST(
|
||||
(std::numeric_limits<double>::min)() - std::numeric_limits<test_t>::epsilon()
|
||||
<= lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
|
||||
&& lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
|
||||
<= (std::numeric_limits<double>::min)() + std::numeric_limits<test_t>::epsilon()
|
||||
);
|
||||
|
||||
BOOST_TEST(
|
||||
(std::numeric_limits<double>::min)() / 2 - std::numeric_limits<test_t>::epsilon()
|
||||
<= lexical_cast<test_t>( (std::numeric_limits<double>::min)() / 2 )
|
||||
&& lexical_cast<test_t>( (std::numeric_limits<double>::min)() / 2 )
|
||||
<= (std::numeric_limits<double>::min)() / 2 + std::numeric_limits<test_t>::epsilon()
|
||||
);
|
||||
}
|
||||
|
||||
if ( sizeof(test_t) < sizeof(long double) )
|
||||
{
|
||||
BOOST_TEST_THROWS(lexical_cast<test_t>( (std::numeric_limits<long double>::max)() ), bad_lexical_cast);
|
||||
BOOST_TEST(
|
||||
(std::numeric_limits<long double>::min)() - std::numeric_limits<test_t>::epsilon()
|
||||
<= lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
|
||||
&& lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
|
||||
<= (std::numeric_limits<long double>::min)() + std::numeric_limits<test_t>::epsilon()
|
||||
);
|
||||
|
||||
BOOST_TEST(
|
||||
(std::numeric_limits<long double>::min)() / 2 - std::numeric_limits<test_t>::epsilon()
|
||||
<= lexical_cast<test_t>( (std::numeric_limits<long double>::min)() / 2 )
|
||||
&& lexical_cast<test_t>( (std::numeric_limits<long double>::min)() / 2 )
|
||||
<= (std::numeric_limits<long double>::min)() / 2 + std::numeric_limits<test_t>::epsilon()
|
||||
);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#undef CHECK_CLOSE_ABS_DIFF
|
||||
|
||||
// Epsilon is multiplied by 2 because of two lexical conversions
|
||||
#define TEST_TO_FROM_CAST_AROUND_TYPED(VAL,STRING_TYPE) \
|
||||
test_value = VAL + std::numeric_limits<test_t>::epsilon() * i ; \
|
||||
converted_val = lexical_cast<test_t>( lexical_cast<STRING_TYPE>(test_value) ); \
|
||||
BOOST_TEST_CLOSE_FRACTION( \
|
||||
test_value, \
|
||||
converted_val, \
|
||||
std::numeric_limits<test_t>::epsilon() * 2 \
|
||||
);
|
||||
|
||||
/*
|
||||
* For interval [ from_mult*epsilon+VAL, to_mult*epsilon+VAL ], converts float type
|
||||
* numbers to string[wstring] and then back to float type, then compares initial
|
||||
* values and generated.
|
||||
* Step is epsilon
|
||||
*/
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
# define TEST_TO_FROM_CAST_AROUND(VAL) \
|
||||
for(i=from_mult; i<=to_mult; ++i) { \
|
||||
TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::string) \
|
||||
TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::wstring) \
|
||||
}
|
||||
#else
|
||||
# define TEST_TO_FROM_CAST_AROUND(VAL) \
|
||||
for(i=from_mult; i<=to_mult; ++i) { \
|
||||
TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::string) \
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class TestType>
|
||||
void test_converion_from_to_float_types()
|
||||
{
|
||||
typedef TestType test_t;
|
||||
test_t test_value;
|
||||
test_t converted_val;
|
||||
|
||||
int i;
|
||||
int from_mult = -50;
|
||||
int to_mult = 50;
|
||||
|
||||
TEST_TO_FROM_CAST_AROUND( 0.0 );
|
||||
|
||||
long double val1;
|
||||
for(val1 = 1.0e-10L; val1 < 1e11; val1*=10 )
|
||||
TEST_TO_FROM_CAST_AROUND( val1 );
|
||||
|
||||
long double val2;
|
||||
for(val2 = -1.0e-10L; val2 > -1e11; val2*=10 )
|
||||
TEST_TO_FROM_CAST_AROUND( val2 );
|
||||
|
||||
from_mult = -100;
|
||||
to_mult = 0;
|
||||
TEST_TO_FROM_CAST_AROUND( (std::numeric_limits<test_t>::max)() );
|
||||
|
||||
from_mult = 0;
|
||||
to_mult = 100;
|
||||
TEST_TO_FROM_CAST_AROUND( (std::numeric_limits<test_t>::min)() );
|
||||
}
|
||||
|
||||
#undef TEST_TO_FROM_CAST_AROUND
|
||||
#undef TEST_TO_FROM_CAST_AROUND_TYPED
|
||||
|
||||
|
||||
template<class T, class CharT>
|
||||
void test_conversion_from_float_to_char(CharT zero)
|
||||
{
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(0)) == zero + 0);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(1)) == zero + 1);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(2)) == zero + 2);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(3)) == zero + 3);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(4)) == zero + 4);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(5)) == zero + 5);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(6)) == zero + 6);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(7)) == zero + 7);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(8)) == zero + 8);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(9)) == zero + 9);
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
|
||||
|
||||
T t = (std::numeric_limits<T>::max)();
|
||||
BOOST_TEST_THROWS(lexical_cast<CharT>(t), bad_lexical_cast);
|
||||
}
|
||||
|
||||
template<class T, class CharT>
|
||||
void test_conversion_from_char_to_float(CharT zero)
|
||||
{
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 0)), static_cast<T>(0), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 1)), static_cast<T>(1), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 2)), static_cast<T>(2), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 3)), static_cast<T>(3), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 4)), static_cast<T>(4), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 5)), static_cast<T>(5), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 6)), static_cast<T>(6), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 7)), static_cast<T>(7), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 8)), static_cast<T>(8), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 9)), static_cast<T>(9), (std::numeric_limits<T>::epsilon()) );
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( static_cast<CharT>(zero + 10)), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( static_cast<CharT>(zero - 1)), bad_lexical_cast);
|
||||
}
|
||||
|
||||
struct restore_oldloc
|
||||
{
|
||||
std::locale oldloc;
|
||||
~restore_oldloc() { std::locale::global(oldloc); }
|
||||
};
|
||||
|
||||
template<class T>
|
||||
void test_conversion_from_to_float()
|
||||
{ char const zero = '0';
|
||||
signed char const szero = '0';
|
||||
unsigned char const uzero = '0';
|
||||
test_conversion_from_float_to_char<T>(zero);
|
||||
test_conversion_from_char_to_float<T>(zero);
|
||||
test_conversion_from_float_to_char<T>(szero);
|
||||
test_conversion_from_char_to_float<T>(szero);
|
||||
test_conversion_from_float_to_char<T>(uzero);
|
||||
test_conversion_from_char_to_float<T>(uzero);
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
wchar_t const wzero = L'0';
|
||||
test_conversion_from_float_to_char<T>(wzero);
|
||||
test_conversion_from_char_to_float<T>(wzero);
|
||||
#endif
|
||||
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>("+1"), 1, std::numeric_limits<T>::epsilon());
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>("+9"), 9, std::numeric_limits<T>::epsilon());
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<T>("++1"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>("-+9"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>("--1"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>("+-9"), bad_lexical_cast);
|
||||
|
||||
test_converion_to_float_types<T>();
|
||||
test_float_typess_for_overflows<T>();
|
||||
test_converion_from_to_float_types<T>();
|
||||
|
||||
|
||||
typedef std::numpunct<char> numpunct;
|
||||
|
||||
restore_oldloc guard;
|
||||
std::locale const& oldloc = guard.oldloc;
|
||||
|
||||
std::string grouping1 = BOOST_USE_FACET(numpunct, oldloc).grouping();
|
||||
std::string grouping2(grouping1);
|
||||
|
||||
test_conversion_from_to_float_for_locale<T>();
|
||||
|
||||
try
|
||||
{
|
||||
std::locale newloc("");
|
||||
std::locale::global(newloc);
|
||||
|
||||
grouping2 = BOOST_USE_FACET(numpunct, newloc).grouping();
|
||||
}
|
||||
catch(std::exception const& ex)
|
||||
{
|
||||
std::string msg("Failed to set system locale: ");
|
||||
msg += ex.what();
|
||||
std::cerr << msg;
|
||||
}
|
||||
|
||||
if(grouping1 != grouping2)
|
||||
test_conversion_from_to_float_for_locale<T>();
|
||||
|
||||
if(grouping1.empty() && grouping2.empty())
|
||||
std::cerr << "Formatting with thousands_sep has not been tested";
|
||||
}
|
||||
|
||||
|
||||
|
||||
void test_conversion_from_to_float()
|
||||
{
|
||||
test_conversion_from_to_float<float>();
|
||||
}
|
||||
void test_conversion_from_to_double()
|
||||
{
|
||||
test_conversion_from_to_float<double>();
|
||||
}
|
||||
void test_conversion_from_to_long_double()
|
||||
{
|
||||
// We do not run tests on compilers and Standard Libraries with poor support of long double
|
||||
#if !defined(BOOST_LEXICAL_CAST_NO_LONG_DOUBLE_MATH_FUNCTIONS)
|
||||
test_conversion_from_to_float<long double>();
|
||||
#endif
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
template <class Integral, class Float>
|
||||
void test_conversion_integral_float()
|
||||
{
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<Float>(static_cast<Float>(1)), static_cast<Float>(1), std::numeric_limits<Float>::epsilon());
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<Float>(static_cast<Float>(1.1234)), static_cast<Float>(1.1234), std::numeric_limits<Float>::epsilon());
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<Float>(static_cast<Float>(-1.1234)), static_cast<Float>(-1.1234), std::numeric_limits<Float>::epsilon());
|
||||
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<Float>(static_cast<Integral>(0)), static_cast<Float>(0), std::numeric_limits<Float>::epsilon());
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<Float>(static_cast<Integral>(1)), static_cast<Float>(1), std::numeric_limits<Float>::epsilon());
|
||||
|
||||
#ifndef __CYGWIN__
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<Float>((std::numeric_limits<Integral>::max)()), static_cast<Float>((std::numeric_limits<Integral>::max)()), std::numeric_limits<Float>::epsilon());
|
||||
BOOST_TEST_CLOSE_FRACTION(lexical_cast<Float>((std::numeric_limits<Integral>::min)()), static_cast<Float>((std::numeric_limits<Integral>::min)()), std::numeric_limits<Float>::epsilon());
|
||||
#endif
|
||||
|
||||
BOOST_TEST_EQ(lexical_cast<Integral>(static_cast<Float>(0.0)), 0);
|
||||
BOOST_TEST_EQ(lexical_cast<Integral>(static_cast<Float>(1.0)), 1);
|
||||
BOOST_TEST_EQ(lexical_cast<Integral>(static_cast<Float>(8.0)), 8);
|
||||
BOOST_TEST_EQ(lexical_cast<Integral>(static_cast<Float>(16.0)), 16);
|
||||
|
||||
if (boost::detail::lcast::is_signed<Integral>::value) {
|
||||
BOOST_TEST_EQ(lexical_cast<Integral>(static_cast<Float>(-1.0)), -1);
|
||||
BOOST_TEST_EQ(lexical_cast<Integral>(static_cast<Float>(-8.0)), -8);
|
||||
BOOST_TEST_EQ(lexical_cast<Integral>(static_cast<Float>(-16.0)), -16);
|
||||
} else {
|
||||
BOOST_TEST_EQ(lexical_cast<Integral>(static_cast<Float>(-1.0)), (std::numeric_limits<Integral>::max)());
|
||||
BOOST_TEST_EQ(lexical_cast<Integral>(static_cast<Float>(-8.0)), (std::numeric_limits<Integral>::max)() - 7);
|
||||
BOOST_TEST_EQ(lexical_cast<Integral>(static_cast<Float>(-16.0)), (std::numeric_limits<Integral>::max)() - 15);
|
||||
}
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(static_cast<Float>(0.5)), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(static_cast<Float>(-0.5)), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(static_cast<Float>(1.5)), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(static_cast<Float>(-1.5)), bad_lexical_cast);
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>((std::numeric_limits<Float>::min)()), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>((std::numeric_limits<Float>::max)()), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>((std::numeric_limits<Float>::epsilon)()), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>((std::numeric_limits<Float>::lowest)()), bad_lexical_cast);
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(std::numeric_limits<Float>::quiet_NaN()), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(-std::numeric_limits<Float>::quiet_NaN()), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(std::numeric_limits<Float>::infinity()), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(-std::numeric_limits<Float>::infinity()), bad_lexical_cast);
|
||||
}
|
||||
|
||||
|
||||
int main()
|
||||
{
|
||||
test_conversion_from_to_float();
|
||||
test_conversion_from_to_double();
|
||||
test_conversion_from_to_long_double();
|
||||
|
||||
test_conversion_integral_float<int, float>();
|
||||
test_conversion_integral_float<int, double>();
|
||||
test_conversion_integral_float<unsigned short, float>();
|
||||
test_conversion_integral_float<unsigned short, double>();
|
||||
test_conversion_integral_float<short, float>();
|
||||
test_conversion_integral_float<short, double>();
|
||||
test_conversion_integral_float<long int, float>();
|
||||
test_conversion_integral_float<long int, double>();
|
||||
test_conversion_integral_float<long long, float>();
|
||||
test_conversion_integral_float<long long, double>();
|
||||
test_conversion_integral_float<unsigned long long, float>();
|
||||
test_conversion_integral_float<unsigned long long, double>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
// Copyright Antony Polukhin, 2013-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#include <string>
|
||||
|
||||
int main()
|
||||
{
|
||||
volatile int i = 42;
|
||||
boost::lexical_cast<std::string>(i);
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
// Copyright David Abrahams 2003.
|
||||
// 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)
|
||||
|
||||
#include <boost/implicit_cast.hpp>
|
||||
#include <cassert>
|
||||
#include <boost/type.hpp>
|
||||
|
||||
using boost::implicit_cast;
|
||||
using boost::type;
|
||||
|
||||
template <class T>
|
||||
type<T> check_return(T) { return type<T>(); }
|
||||
|
||||
struct foo
|
||||
{
|
||||
foo(char const*) {}
|
||||
operator long() const { return 0; }
|
||||
};
|
||||
|
||||
typedef type<long> long_type;
|
||||
typedef type<foo> foo_type;
|
||||
|
||||
int main()
|
||||
{
|
||||
type<long> x = check_return(boost::implicit_cast<long>(1));
|
||||
assert(boost::implicit_cast<long>(1) == 1L);
|
||||
|
||||
type<foo> f = check_return(boost::implicit_cast<foo>("hello"));
|
||||
type<long> z = check_return(boost::implicit_cast<long>(foo("hello")));
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
// Copyright David Abrahams 2003.
|
||||
// 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)
|
||||
|
||||
#include <boost/implicit_cast.hpp>
|
||||
#include <boost/type.hpp>
|
||||
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
using boost::implicit_cast;
|
||||
|
||||
struct foo
|
||||
{
|
||||
explicit foo(char const*) {}
|
||||
};
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
foo x = implicit_cast<foo>("foobar");
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
// Copyright Antony Polukhin, 2023-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
struct oops {
|
||||
operator int () const {
|
||||
return 41;
|
||||
}
|
||||
};
|
||||
|
||||
inline std::ostream& operator<<(std::ostream& os, const oops&) {
|
||||
return os << 42;
|
||||
}
|
||||
|
||||
struct oops2 {
|
||||
operator double () const {
|
||||
return 1.12;
|
||||
}
|
||||
};
|
||||
|
||||
inline std::ostream& operator<<(std::ostream& os, const oops2&) {
|
||||
return os << 2;
|
||||
}
|
||||
|
||||
struct Value {
|
||||
explicit Value(double x) : x(x) {}
|
||||
|
||||
operator double() const {
|
||||
return x;
|
||||
}
|
||||
|
||||
double x;
|
||||
};
|
||||
|
||||
int main() {
|
||||
BOOST_TEST_EQ(boost::lexical_cast<int>(oops{}), 42);
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(oops{}), "42");
|
||||
|
||||
BOOST_TEST_EQ(boost::lexical_cast<double>(oops2{}), 2);
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(oops2{}), "2");
|
||||
|
||||
Value longer_that_1_digit(128);
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(longer_that_1_digit), "128");
|
||||
|
||||
// iostreams have default precision 6, see [basic.ios.cons]
|
||||
const double precision_more_than_6_digits = 1.23456789123;
|
||||
// At the moment we do not set the precision for types that use conversion
|
||||
// operators for ostreaming, so the below test pass. We do not set precision
|
||||
// for user provided `operator<<`, types with conversion operators follow
|
||||
// the same design decision for now.
|
||||
BOOST_TEST_NE(
|
||||
boost::lexical_cast<std::string>(Value(precision_more_than_6_digits)),
|
||||
boost::lexical_cast<std::string>(precision_more_than_6_digits)
|
||||
);
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,242 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
#include <boost/core/cmath.hpp>
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
|
||||
#define BOOST_LCAST_NO_WCHAR_T
|
||||
#endif
|
||||
|
||||
using namespace boost;
|
||||
|
||||
template <class T>
|
||||
bool is_pos_inf(T value)
|
||||
{
|
||||
return (boost::core::isinf)(value) && !(boost::core::signbit)(value);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
bool is_neg_inf(T value)
|
||||
{
|
||||
return (boost::core::isinf)(value) && (boost::core::signbit)(value);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
bool is_pos_nan(T value)
|
||||
{
|
||||
return (boost::core::isnan)(value) && !(boost::core::signbit)(value);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
bool is_neg_nan(T value)
|
||||
{
|
||||
/* There is some strange behaviour on Itanium platform with -nan nuber for long double.
|
||||
* It is a IA64 feature, or it is a boost::math feature, not a lexical_cast bug */
|
||||
#if defined(__ia64__) || defined(_M_IA64)
|
||||
return (boost::core::isnan)(value)
|
||||
&& ( std::is_same<T, long double >::value || (boost::core::signbit)(value) );
|
||||
#else
|
||||
return (boost::core::isnan)(value) && (boost::core::signbit)(value);
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_inf_nan_templated()
|
||||
{
|
||||
typedef T test_t;
|
||||
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>("inf") ) );
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>("INF") ) );
|
||||
|
||||
BOOST_TEST( is_neg_inf( lexical_cast<test_t>("-inf") ) );
|
||||
BOOST_TEST( is_neg_inf( lexical_cast<test_t>("-INF") ) );
|
||||
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>("+inf") ) );
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>("+INF") ) );
|
||||
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>("infinity") ) );
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>("INFINITY") ) );
|
||||
|
||||
BOOST_TEST( is_neg_inf( lexical_cast<test_t>("-infinity") ) );
|
||||
BOOST_TEST( is_neg_inf( lexical_cast<test_t>("-INFINITY") ) );
|
||||
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>("+infinity") ) );
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>("+INFINITY") ) );
|
||||
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>("iNfiNity") ) );
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>("INfinity") ) );
|
||||
|
||||
BOOST_TEST( is_neg_inf( lexical_cast<test_t>("-inFINITY") ) );
|
||||
BOOST_TEST( is_neg_inf( lexical_cast<test_t>("-INFINITY") ) );
|
||||
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>("nan") ) );
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>("NAN") ) );
|
||||
|
||||
BOOST_TEST( is_neg_nan( lexical_cast<test_t>("-nan") ) );
|
||||
BOOST_TEST( is_neg_nan( lexical_cast<test_t>("-NAN") ) );
|
||||
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>("+nan") ) );
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>("+NAN") ) );
|
||||
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>("nAn") ) );
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>("NaN") ) );
|
||||
|
||||
BOOST_TEST( is_neg_nan( lexical_cast<test_t>("-nAn") ) );
|
||||
BOOST_TEST( is_neg_nan( lexical_cast<test_t>("-NaN") ) );
|
||||
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>("+Nan") ) );
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>("+nAN") ) );
|
||||
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>("nan()") ) );
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>("NAN(some string)") ) );
|
||||
BOOST_TEST_THROWS( lexical_cast<test_t>("NAN(some string"), bad_lexical_cast );
|
||||
|
||||
BOOST_TEST(lexical_cast<std::string>( (boost::core::copysign)(std::numeric_limits<test_t >::infinity(), static_cast<test_t>(-1.0)))
|
||||
== "-inf" );
|
||||
BOOST_TEST(lexical_cast<std::string>( std::numeric_limits<test_t >::infinity()) == "inf" );
|
||||
BOOST_TEST(lexical_cast<std::string>( std::numeric_limits<test_t >::quiet_NaN()) == "nan" );
|
||||
#if !defined(__ia64__) && !defined(_M_IA64)
|
||||
BOOST_TEST(lexical_cast<std::string>(
|
||||
(boost::core::copysign)(std::numeric_limits<test_t >::quiet_NaN(), static_cast<test_t>(-1.0)))
|
||||
== "-nan" );
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"inf") ) );
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"INF") ) );
|
||||
|
||||
BOOST_TEST( is_neg_inf( lexical_cast<test_t>(L"-inf") ) );
|
||||
BOOST_TEST( is_neg_inf( lexical_cast<test_t>(L"-INF") ) );
|
||||
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"+inf") ) );
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"+INF") ) );
|
||||
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"infinity") ) );
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"INFINITY") ) );
|
||||
|
||||
BOOST_TEST( is_neg_inf( lexical_cast<test_t>(L"-infinity") ) );
|
||||
BOOST_TEST( is_neg_inf( lexical_cast<test_t>(L"-INFINITY") ) );
|
||||
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"+infinity") ) );
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"+INFINITY") ) );
|
||||
|
||||
BOOST_TEST( is_neg_inf( lexical_cast<test_t>(L"-infINIty") ) );
|
||||
BOOST_TEST( is_neg_inf( lexical_cast<test_t>(L"-INFiniTY") ) );
|
||||
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"+inFINIty") ) );
|
||||
BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"+INfinITY") ) );
|
||||
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>(L"nan") ) );
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>(L"NAN") ) );
|
||||
|
||||
BOOST_TEST( is_neg_nan( lexical_cast<test_t>(L"-nan") ) );
|
||||
BOOST_TEST( is_neg_nan( lexical_cast<test_t>(L"-NAN") ) );
|
||||
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>(L"+nan") ) );
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>(L"+NAN") ) );
|
||||
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>(L"nan()") ) );
|
||||
BOOST_TEST( is_pos_nan( lexical_cast<test_t>(L"NAN(some string)") ) );
|
||||
BOOST_TEST_THROWS( lexical_cast<test_t>(L"NAN(some string"), bad_lexical_cast );
|
||||
|
||||
BOOST_TEST(lexical_cast<std::wstring>( (boost::core::copysign)(std::numeric_limits<test_t >::infinity(), static_cast<test_t>(-1.0)))
|
||||
== L"-inf" );
|
||||
BOOST_TEST(lexical_cast<std::wstring>( std::numeric_limits<test_t >::infinity()) == L"inf" );
|
||||
BOOST_TEST(lexical_cast<std::wstring>( std::numeric_limits<test_t >::quiet_NaN()) == L"nan" );
|
||||
#if !defined(__ia64__) && !defined(_M_IA64)
|
||||
BOOST_TEST(lexical_cast<std::wstring>(
|
||||
(boost::core::copysign)(std::numeric_limits<test_t >::quiet_NaN(), static_cast<test_t>(-1.0)))
|
||||
== L"-nan" );
|
||||
#endif
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_inf_nan_float()
|
||||
{
|
||||
test_inf_nan_templated<float >();
|
||||
|
||||
BOOST_TEST(is_pos_nan(lexical_cast<float>(std::numeric_limits<float>::quiet_NaN())));
|
||||
BOOST_TEST(is_neg_nan(lexical_cast<float>(-std::numeric_limits<float>::quiet_NaN())));
|
||||
BOOST_TEST(is_pos_inf(lexical_cast<float>(std::numeric_limits<float>::infinity())));
|
||||
BOOST_TEST(is_neg_inf(lexical_cast<float>(-std::numeric_limits<float>::infinity())));
|
||||
|
||||
BOOST_TEST(is_pos_nan(lexical_cast<float>(std::numeric_limits<double>::quiet_NaN())));
|
||||
BOOST_TEST(is_neg_nan(lexical_cast<float>(-std::numeric_limits<double>::quiet_NaN())));
|
||||
BOOST_TEST(is_pos_inf(lexical_cast<float>(std::numeric_limits<double>::infinity())));
|
||||
BOOST_TEST(is_neg_inf(lexical_cast<float>(-std::numeric_limits<double>::infinity())));
|
||||
}
|
||||
|
||||
void test_inf_nan_double()
|
||||
{
|
||||
test_inf_nan_templated<double >();
|
||||
|
||||
BOOST_TEST(is_pos_nan(lexical_cast<double>(std::numeric_limits<float>::quiet_NaN())));
|
||||
BOOST_TEST(is_neg_nan(lexical_cast<double>(-std::numeric_limits<float>::quiet_NaN())));
|
||||
BOOST_TEST(is_pos_inf(lexical_cast<double>(std::numeric_limits<float>::infinity())));
|
||||
BOOST_TEST(is_neg_inf(lexical_cast<double>(-std::numeric_limits<float>::infinity())));
|
||||
|
||||
BOOST_TEST(is_pos_nan(lexical_cast<double>(std::numeric_limits<double>::quiet_NaN())));
|
||||
BOOST_TEST(is_neg_nan(lexical_cast<double>(-std::numeric_limits<double>::quiet_NaN())));
|
||||
BOOST_TEST(is_pos_inf(lexical_cast<double>(std::numeric_limits<double>::infinity())));
|
||||
BOOST_TEST(is_neg_inf(lexical_cast<double>(-std::numeric_limits<double>::infinity())));
|
||||
|
||||
BOOST_TEST(is_pos_nan(lexical_cast<double>(std::numeric_limits<long double>::quiet_NaN())));
|
||||
BOOST_TEST(is_neg_nan(lexical_cast<double>(-std::numeric_limits<long double>::quiet_NaN())));
|
||||
BOOST_TEST(is_pos_inf(lexical_cast<double>(std::numeric_limits<long double>::infinity())));
|
||||
BOOST_TEST(is_neg_inf(lexical_cast<double>(-std::numeric_limits<long double>::infinity())));
|
||||
}
|
||||
|
||||
void test_inf_nan_long_double()
|
||||
{
|
||||
// We do not run tests on compilers with bugs
|
||||
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
|
||||
test_inf_nan_templated<long double >();
|
||||
#endif
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
template <class Integral>
|
||||
void test_inf_nan_to_integral()
|
||||
{
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(std::numeric_limits<float>::quiet_NaN()), boost::bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(-std::numeric_limits<float>::quiet_NaN()), boost::bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(std::numeric_limits<float>::infinity()), boost::bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(-std::numeric_limits<float>::infinity()), boost::bad_lexical_cast);
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(std::numeric_limits<double>::quiet_NaN()), boost::bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(-std::numeric_limits<double>::quiet_NaN()), boost::bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(std::numeric_limits<double>::infinity()), boost::bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(-std::numeric_limits<double>::infinity()), boost::bad_lexical_cast);
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(std::numeric_limits<long double>::quiet_NaN()), boost::bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(-std::numeric_limits<long double>::quiet_NaN()), boost::bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(std::numeric_limits<long double>::infinity()), boost::bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<Integral>(-std::numeric_limits<long double>::infinity()), boost::bad_lexical_cast);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_inf_nan_float();
|
||||
test_inf_nan_double();
|
||||
test_inf_nan_long_double();
|
||||
|
||||
test_inf_nan_to_integral<int>();
|
||||
test_inf_nan_to_integral<bool>();
|
||||
test_inf_nan_to_integral<short>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,657 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Terje Sletteb and Kevlin Henney, 2005.
|
||||
// Copyright Alexander Nasonov, 2006.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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).
|
||||
//
|
||||
// Note: The unit test no longer compile on MSVC 6, but lexical_cast itself works for it.
|
||||
|
||||
//
|
||||
// We need this #define before any #includes: otherwise msvc will emit warnings
|
||||
// deep within std::string, resulting from our (perfectly legal) use of basic_string
|
||||
// with a custom traits class:
|
||||
//
|
||||
#define _SCL_SECURE_NO_WARNINGS
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/lexical_cast/detail/type_traits.hpp>
|
||||
|
||||
#include <boost/type_traits/integral_promotion.hpp>
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <vector>
|
||||
#include <memory>
|
||||
#include <type_traits>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) \
|
||||
&& !(defined(BOOST_MSVC) && BOOST_MSVC < 1300)
|
||||
#define LCAST_TEST_LONGLONG
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
|
||||
#define BOOST_LCAST_NO_WCHAR_T
|
||||
#endif
|
||||
|
||||
// There's no typeinfo for unsigned __int128 in Xcode_15.0.1
|
||||
#if defined(BOOST_HAS_INT128) && !defined(BOOST_LEXICAL_CAST_TEST_NO_128_INTS) && !defined(__APPLE__)
|
||||
# define BOOST_LCAST_TEST_128 1
|
||||
#endif
|
||||
|
||||
// Test all 65536 values if true:
|
||||
bool const lcast_test_small_integral_types_completely = false;
|
||||
|
||||
// lcast_integral_test_counter: use when testing all values of an integral
|
||||
// types is not possible. Max. portable value is 32767.
|
||||
int const lcast_integral_test_counter=500;
|
||||
|
||||
using namespace boost;
|
||||
|
||||
template<class T, class CharT>
|
||||
void test_conversion_from_integral_to_char(CharT zero)
|
||||
{
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(0)) == zero + 0);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(1)) == zero + 1);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(2)) == zero + 2);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(3)) == zero + 3);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(4)) == zero + 4);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(5)) == zero + 5);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(6)) == zero + 6);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(7)) == zero + 7);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(8)) == zero + 8);
|
||||
BOOST_TEST(lexical_cast<CharT>(static_cast<T>(9)) == zero + 9);
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
|
||||
|
||||
T t = (std::numeric_limits<T>::max)();
|
||||
BOOST_TEST_THROWS(lexical_cast<CharT>(t), bad_lexical_cast);
|
||||
}
|
||||
|
||||
template<class T, class CharT>
|
||||
void test_conversion_from_char_to_integral(CharT zero)
|
||||
{
|
||||
BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 0)) == static_cast<T>(0) );
|
||||
BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 1)) == static_cast<T>(1) );
|
||||
BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 2)) == static_cast<T>(2) );
|
||||
BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 3)) == static_cast<T>(3) );
|
||||
BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 4)) == static_cast<T>(4) );
|
||||
BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 5)) == static_cast<T>(5) );
|
||||
BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 6)) == static_cast<T>(6) );
|
||||
BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 7)) == static_cast<T>(7) );
|
||||
BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 8)) == static_cast<T>(8) );
|
||||
BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 9)) == static_cast<T>(9) );
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( static_cast<CharT>(zero + 10)), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( static_cast<CharT>(zero - 1)), bad_lexical_cast);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void test_conversion_from_integral_to_integral()
|
||||
{
|
||||
T t = 0;
|
||||
BOOST_TEST(lexical_cast<T>(t) == t);
|
||||
|
||||
// Next two variables are used to suppress warnings.
|
||||
int st = 32767; unsigned int ut = st;
|
||||
t = st;
|
||||
BOOST_TEST(lexical_cast<short>(t) == st);
|
||||
BOOST_TEST(lexical_cast<unsigned short>(t) == ut);
|
||||
BOOST_TEST(lexical_cast<int>(t) == st);
|
||||
BOOST_TEST(lexical_cast<unsigned int>(t) == ut);
|
||||
BOOST_TEST(lexical_cast<long>(t) == st);
|
||||
BOOST_TEST(lexical_cast<unsigned long>(t) == ut);
|
||||
|
||||
t = (std::numeric_limits<T>::max)();
|
||||
BOOST_TEST(lexical_cast<T>(t) == t);
|
||||
|
||||
t = (std::numeric_limits<T>::min)();
|
||||
BOOST_TEST(lexical_cast<T>(t) == t);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
// Replace "-,999" with "-999".
|
||||
template<class CharT>
|
||||
std::basic_string<CharT> to_str_gcc_workaround(std::basic_string<CharT> str)
|
||||
{
|
||||
std::locale loc;
|
||||
std::numpunct<CharT> const& np = BOOST_USE_FACET(std::numpunct<CharT>, loc);
|
||||
std::ctype<CharT> const& ct = BOOST_USE_FACET(std::ctype<CharT>, loc);
|
||||
|
||||
if(np.grouping().empty())
|
||||
return str;
|
||||
|
||||
CharT prefix[3] = { ct.widen('-'), np.thousands_sep(), CharT() };
|
||||
|
||||
if(str.find(prefix) != 0)
|
||||
return str;
|
||||
|
||||
prefix[1] = CharT();
|
||||
str.replace(0, 2, prefix);
|
||||
return str;
|
||||
}
|
||||
|
||||
template<class CharT, class T>
|
||||
std::basic_string<CharT> to_str(T t)
|
||||
{
|
||||
std::basic_ostringstream<CharT> o;
|
||||
o << t;
|
||||
return to_str_gcc_workaround(o.str());
|
||||
}
|
||||
|
||||
|
||||
template<class T, class CharT>
|
||||
void test_conversion_from_integral_to_string(CharT)
|
||||
{
|
||||
typedef std::numeric_limits<T> limits;
|
||||
typedef std::basic_string<CharT> string_type;
|
||||
|
||||
T t;
|
||||
|
||||
t = (limits::min)();
|
||||
BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
|
||||
|
||||
t = (limits::max)();
|
||||
BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
|
||||
|
||||
if(limits::digits <= 16 && lcast_test_small_integral_types_completely)
|
||||
// min and max have already been tested.
|
||||
for(t = 1 + (limits::min)(); t != (limits::max)(); ++t)
|
||||
BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
|
||||
else
|
||||
{
|
||||
T const min_val = (limits::min)();
|
||||
T const max_val = (limits::max)();
|
||||
T const half_max_val = max_val / 2;
|
||||
T const cnt = lcast_integral_test_counter; // to suppress warnings
|
||||
T const counter = cnt < half_max_val ? cnt : half_max_val;
|
||||
|
||||
T i = 0;
|
||||
|
||||
// Test values around min:
|
||||
t = min_val;
|
||||
for(i = 0; i < counter; ++i, ++t)
|
||||
BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
|
||||
|
||||
// Test values around max:
|
||||
t = max_val;
|
||||
for(i = 0; i < counter; ++i, --t)
|
||||
BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
|
||||
|
||||
// Test values around zero:
|
||||
if(limits::is_signed)
|
||||
for(t = static_cast<T>(-counter); t < static_cast<T>(counter); ++t)
|
||||
BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
|
||||
|
||||
// Test values around 100, 1000, 10000, ...
|
||||
T ten_power = 100;
|
||||
for(int e = 2; e < limits::digits10; ++e, ten_power *= 10)
|
||||
{
|
||||
// ten_power + 100 probably never overflows
|
||||
for(t = ten_power - 100; t != ten_power + 100; ++t)
|
||||
BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class CharT>
|
||||
void test_conversion_from_string_to_integral(CharT)
|
||||
{
|
||||
typedef std::numeric_limits<T> limits;
|
||||
typedef std::basic_string<CharT> string_type;
|
||||
|
||||
string_type s;
|
||||
string_type const zero = to_str<CharT>(0);
|
||||
string_type const nine = to_str<CharT>(9);
|
||||
T const min_val = (limits::min)();
|
||||
T const max_val = (limits::max)();
|
||||
|
||||
s = to_str<CharT>(min_val);
|
||||
BOOST_TEST_EQ(lexical_cast<T>(s), min_val);
|
||||
if(limits::is_signed)
|
||||
{
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(s + zero), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(s + nine), bad_lexical_cast);
|
||||
}
|
||||
|
||||
s = to_str<CharT>(max_val);
|
||||
BOOST_TEST_EQ(lexical_cast<T>(s), max_val);
|
||||
{
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(s + zero), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(s + nine), bad_lexical_cast);
|
||||
|
||||
s = to_str<CharT>(max_val);
|
||||
for (int i =1; i <=10; ++i) {
|
||||
s[s.size()-1] += 1;
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( s ), bad_lexical_cast);
|
||||
}
|
||||
|
||||
s = to_str<CharT>(max_val);
|
||||
std::locale loc;
|
||||
typedef std::numpunct<char> numpunct;
|
||||
if ( BOOST_USE_FACET(numpunct, loc).grouping().empty() ) {
|
||||
// Following tests work well for locale C
|
||||
BOOST_TEST_EQ(lexical_cast<T>(to_str<CharT>(0)+s), max_val);
|
||||
BOOST_TEST_EQ(lexical_cast<T>(to_str<CharT>(0)+to_str<CharT>(0)+s), max_val);
|
||||
BOOST_TEST_EQ(lexical_cast<T>(to_str<CharT>(0)+to_str<CharT>(0)+to_str<CharT>(0)+s), max_val);
|
||||
}
|
||||
|
||||
for (int i =1; i <=256; ++i) {
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( to_str<CharT>(i)+s ), bad_lexical_cast);
|
||||
}
|
||||
|
||||
typedef typename boost::integral_promotion<T>::type promoted;
|
||||
if ( !(std::is_same<T, promoted>::value) )
|
||||
{
|
||||
promoted prom = max_val;
|
||||
s = to_str<CharT>(max_val);
|
||||
for (int i =1; i <=256; ++i) {
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( to_str<CharT>(prom+i) ), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( to_str<CharT>(i)+s ), bad_lexical_cast);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(limits::digits <= 16 && lcast_test_small_integral_types_completely)
|
||||
// min and max have already been tested.
|
||||
for(T t = 1 + min_val; t != max_val; ++t)
|
||||
BOOST_TEST(lexical_cast<T>(to_str<CharT>(t)) == t);
|
||||
else
|
||||
{
|
||||
T const half_max_val = max_val / 2;
|
||||
T const cnt = lcast_integral_test_counter; // to suppress warnings
|
||||
T const counter = cnt < half_max_val ? cnt : half_max_val;
|
||||
|
||||
T t;
|
||||
T i;
|
||||
|
||||
// Test values around min:
|
||||
t = min_val;
|
||||
for(i = 0; i < counter; ++i, ++t)
|
||||
BOOST_TEST(lexical_cast<T>(to_str<CharT>(t)) == t);
|
||||
|
||||
// Test values around max:
|
||||
t = max_val;
|
||||
for(i = 0; i < counter; ++i, --t)
|
||||
BOOST_TEST(lexical_cast<T>(to_str<CharT>(t)) == t);
|
||||
|
||||
// Test values around zero:
|
||||
if(limits::is_signed)
|
||||
for(t = static_cast<T>(-counter); t < static_cast<T>(counter); ++t)
|
||||
BOOST_TEST(lexical_cast<T>(to_str<CharT>(t)) == t);
|
||||
|
||||
// Test values around 100, 1000, 10000, ...
|
||||
T ten_power = 100;
|
||||
for(int e = 2; e < limits::digits10; ++e, ten_power *= 10)
|
||||
{
|
||||
// ten_power + 100 probably never overflows
|
||||
for(t = ten_power - 100; t != ten_power + 100; ++t)
|
||||
BOOST_TEST(lexical_cast<T>(to_str<CharT>(t)) == t);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void test_conversion_from_to_integral_for_locale()
|
||||
{
|
||||
std::locale current_locale;
|
||||
typedef std::numpunct<char> numpunct;
|
||||
numpunct const& np = BOOST_USE_FACET(numpunct, current_locale);
|
||||
if ( !np.grouping().empty() )
|
||||
{
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<T>( std::string("100") + np.thousands_sep() + np.thousands_sep() + "0" )
|
||||
, bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( std::string("100") + np.thousands_sep() ), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>( np.thousands_sep() + std::string("100") ), bad_lexical_cast);
|
||||
|
||||
// Exception must not be thrown, when we are using no separators at all
|
||||
BOOST_TEST( lexical_cast<T>("30000") == static_cast<T>(30000) );
|
||||
}
|
||||
|
||||
|
||||
test_conversion_from_integral_to_integral<T>();
|
||||
|
||||
// This is a part of test_conversion_from_integral_to_string<T>('0') method,
|
||||
// but with BOOST_TEST_EQ instead of BOOST_TEST. It is required to see
|
||||
// what is produced by the to_str<char>(t) method in situations when result
|
||||
// is different. BOOST_TEST does not work with wchar_t.
|
||||
typedef std::numeric_limits<T> limits;
|
||||
T t = (limits::min)();
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(t), to_str<char>(t));
|
||||
|
||||
test_conversion_from_integral_to_string<T>('0');
|
||||
test_conversion_from_string_to_integral<T>('0');
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T)
|
||||
if (lexical_cast<std::wstring>(t) != to_str<wchar_t>(t)) {
|
||||
// Something went wrong, and now we are attempting to find and print the
|
||||
// difference.
|
||||
std::wstring wstr = to_str<wchar_t>(t);
|
||||
std::string lcast_str = lexical_cast<std::string>(t);
|
||||
std::string str;
|
||||
str.reserve(wstr.size());
|
||||
for (std::size_t i = 0; i < wstr.size(); ++i) {
|
||||
str.push_back(static_cast<char>(wstr[i]));
|
||||
}
|
||||
|
||||
BOOST_TEST_EQ(lcast_str.length(), lexical_cast<std::wstring>(t).length());
|
||||
BOOST_TEST_EQ(to_str<char>(t), str);
|
||||
BOOST_TEST_EQ(lcast_str, str);
|
||||
}
|
||||
|
||||
test_conversion_from_integral_to_string<T>(L'0');
|
||||
test_conversion_from_string_to_integral<T>(L'0');
|
||||
#endif
|
||||
}
|
||||
|
||||
struct restore_oldloc
|
||||
{
|
||||
std::locale oldloc;
|
||||
~restore_oldloc() { std::locale::global(oldloc); }
|
||||
};
|
||||
|
||||
template<class T>
|
||||
void test_conversion_from_to_integral_minimal()
|
||||
{
|
||||
char const zero = '0';
|
||||
signed char const szero = '0';
|
||||
unsigned char const uzero = '0';
|
||||
test_conversion_from_integral_to_char<T>(zero);
|
||||
test_conversion_from_char_to_integral<T>(zero);
|
||||
test_conversion_from_integral_to_char<T>(szero);
|
||||
test_conversion_from_char_to_integral<T>(szero);
|
||||
test_conversion_from_integral_to_char<T>(uzero);
|
||||
test_conversion_from_char_to_integral<T>(uzero);
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
wchar_t const wzero = L'0';
|
||||
test_conversion_from_integral_to_char<T>(wzero);
|
||||
test_conversion_from_char_to_integral<T>(wzero);
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION) && !defined(BOOST_MSVC)
|
||||
char16_t const u16zero = u'0';
|
||||
test_conversion_from_integral_to_char<T>(u16zero);
|
||||
test_conversion_from_char_to_integral<T>(u16zero);
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION) && !defined(BOOST_MSVC)
|
||||
char32_t const u32zero = u'0';
|
||||
test_conversion_from_integral_to_char<T>(u32zero);
|
||||
test_conversion_from_char_to_integral<T>(u32zero);
|
||||
#endif
|
||||
|
||||
BOOST_TEST(lexical_cast<T>("-1") == static_cast<T>(-1));
|
||||
BOOST_TEST(lexical_cast<T>("-9") == static_cast<T>(-9));
|
||||
BOOST_TEST(lexical_cast<T>(-1) == static_cast<T>(-1));
|
||||
BOOST_TEST(lexical_cast<T>(-9) == static_cast<T>(-9));
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<T>("-1.0"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>("-9.0"), bad_lexical_cast);
|
||||
BOOST_TEST(lexical_cast<T>(-1.0) == static_cast<T>(-1));
|
||||
BOOST_TEST(lexical_cast<T>(-9.0) == static_cast<T>(-9));
|
||||
|
||||
BOOST_TEST(lexical_cast<T>(static_cast<T>(1)) == static_cast<T>(1));
|
||||
BOOST_TEST(lexical_cast<T>(static_cast<T>(9)) == static_cast<T>(9));
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(1.1f), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(1.1), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(1.1L), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(1.0001f), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(1.0001), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(1.0001L), bad_lexical_cast);
|
||||
|
||||
BOOST_TEST(lexical_cast<T>("+1") == static_cast<T>(1) );
|
||||
BOOST_TEST(lexical_cast<T>("+9") == static_cast<T>(9) );
|
||||
BOOST_TEST(lexical_cast<T>("+10") == static_cast<T>(10) );
|
||||
BOOST_TEST(lexical_cast<T>("+90") == static_cast<T>(90) );
|
||||
BOOST_TEST_THROWS(lexical_cast<T>("++1"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>("-+9"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>("--1"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>("+-9"), bad_lexical_cast);
|
||||
// test_conversion_from_to_integral_for_locale
|
||||
|
||||
// Overflow test case from David W. Birdsall
|
||||
std::string must_owerflow_str = (sizeof(T) < 16 ? "160000000000000000000" : "1600000000000000000000000000000000000000");
|
||||
std::string must_owerflow_negative_str = (sizeof(T) < 16 ? "-160000000000000000000" : "-1600000000000000000000000000000000000000");
|
||||
for (int i = 0; i < 15; ++i) {
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(must_owerflow_str), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(must_owerflow_negative_str), bad_lexical_cast);
|
||||
|
||||
must_owerflow_str += '0';
|
||||
must_owerflow_negative_str += '0';
|
||||
}
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void test_conversion_from_to_integral()
|
||||
{
|
||||
test_conversion_from_to_integral_minimal<T>();
|
||||
typedef std::numpunct<char> numpunct;
|
||||
|
||||
restore_oldloc guard;
|
||||
std::locale const& oldloc = guard.oldloc;
|
||||
|
||||
std::string grouping1 = BOOST_USE_FACET(numpunct, oldloc).grouping();
|
||||
std::string grouping2(grouping1);
|
||||
|
||||
test_conversion_from_to_integral_for_locale<T>();
|
||||
|
||||
try
|
||||
{
|
||||
std::locale newloc("");
|
||||
std::locale::global(newloc);
|
||||
|
||||
grouping2 = BOOST_USE_FACET(numpunct, newloc).grouping();
|
||||
}
|
||||
catch(std::exception const& ex)
|
||||
{
|
||||
std::string msg("Failed to set system locale: ");
|
||||
msg += ex.what();
|
||||
std::cerr << msg;
|
||||
}
|
||||
|
||||
if(grouping1 != grouping2)
|
||||
test_conversion_from_to_integral_for_locale<T>();
|
||||
|
||||
if(grouping1.empty() && grouping2.empty())
|
||||
std::cerr << "Formatting with thousands_sep has not been tested";
|
||||
}
|
||||
|
||||
void test_conversion_from_to_short()
|
||||
{
|
||||
test_conversion_from_to_integral<short>();
|
||||
}
|
||||
|
||||
void test_conversion_from_to_ushort()
|
||||
{
|
||||
test_conversion_from_to_integral<unsigned short>();
|
||||
}
|
||||
|
||||
void test_conversion_from_to_int()
|
||||
{
|
||||
test_conversion_from_to_integral<int>();
|
||||
}
|
||||
|
||||
void test_conversion_from_to_uint()
|
||||
{
|
||||
test_conversion_from_to_integral<unsigned int>();
|
||||
}
|
||||
|
||||
void test_conversion_from_to_long()
|
||||
{
|
||||
test_conversion_from_to_integral<long>();
|
||||
}
|
||||
|
||||
void test_conversion_from_to_ulong()
|
||||
{
|
||||
test_conversion_from_to_integral<unsigned long>();
|
||||
}
|
||||
|
||||
void test_conversion_from_to_intmax_t()
|
||||
{
|
||||
test_conversion_from_to_integral<boost::intmax_t>();
|
||||
}
|
||||
|
||||
void test_conversion_from_to_uintmax_t()
|
||||
{
|
||||
test_conversion_from_to_integral<boost::uintmax_t>();
|
||||
}
|
||||
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
|
||||
void test_conversion_from_to_longlong()
|
||||
{
|
||||
test_conversion_from_to_integral<boost::long_long_type>();
|
||||
}
|
||||
|
||||
void test_conversion_from_to_ulonglong()
|
||||
{
|
||||
test_conversion_from_to_integral<boost::ulong_long_type>();
|
||||
}
|
||||
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
|
||||
void test_conversion_from_to_longlong()
|
||||
{
|
||||
test_conversion_from_to_integral<__int64>();
|
||||
}
|
||||
|
||||
void test_conversion_from_to_ulonglong()
|
||||
{
|
||||
test_conversion_from_to_integral<unsigned __int64>();
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef BOOST_LCAST_TEST_128
|
||||
|
||||
template <bool Specialized, class T>
|
||||
struct test_if_specialized {
|
||||
static void test() {}
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct test_if_specialized<true, T> {
|
||||
static void test() {
|
||||
test_conversion_from_to_integral_minimal<T>();
|
||||
}
|
||||
};
|
||||
|
||||
void test_conversion_from_to_int128()
|
||||
{
|
||||
test_if_specialized<
|
||||
std::numeric_limits<boost::int128_type>::is_specialized,
|
||||
boost::int128_type
|
||||
>::test();
|
||||
}
|
||||
|
||||
void test_conversion_from_to_uint128()
|
||||
{
|
||||
test_if_specialized<
|
||||
std::numeric_limits<boost::int128_type>::is_specialized,
|
||||
boost::uint128_type
|
||||
>::test();
|
||||
}
|
||||
#endif
|
||||
|
||||
template <typename SignedT>
|
||||
void test_integral_conversions_on_min_max_impl()
|
||||
{
|
||||
typedef SignedT signed_t;
|
||||
typedef typename boost::detail::lcast::make_unsigned<signed_t>::type unsigned_t;
|
||||
|
||||
typedef std::numeric_limits<signed_t> s_limits;
|
||||
typedef std::numeric_limits<unsigned_t> uns_limits;
|
||||
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned_t>((uns_limits::max)()), (uns_limits::max)());
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned_t>((uns_limits::min)()), (uns_limits::min)());
|
||||
|
||||
BOOST_TEST_EQ(lexical_cast<signed_t>((s_limits::max)()), (s_limits::max)());
|
||||
BOOST_TEST_EQ(lexical_cast<signed_t>((uns_limits::min)()), static_cast<signed_t>((uns_limits::min)()));
|
||||
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned_t>((s_limits::max)()), static_cast<unsigned_t>((s_limits::max)()));
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned_t>((s_limits::min)()), static_cast<unsigned_t>((s_limits::min)()));
|
||||
}
|
||||
|
||||
void test_integral_conversions_on_min_max()
|
||||
{
|
||||
test_integral_conversions_on_min_max_impl<int>();
|
||||
test_integral_conversions_on_min_max_impl<short>();
|
||||
|
||||
#ifdef _MSC_VER
|
||||
test_integral_conversions_on_min_max_impl<long int>();
|
||||
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
test_integral_conversions_on_min_max_impl<boost::long_long_type>();
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
test_integral_conversions_on_min_max_impl<__int64>();
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_LCAST_TEST_128
|
||||
test_integral_conversions_on_min_max_impl<boost::int128_type>();
|
||||
#endif
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
void test_negative_integral() {
|
||||
// From https://github.com/boostorg/lexical_cast/issues/45
|
||||
BOOST_TEST_EQ(boost::lexical_cast<int>("-6575543"), -6575543);
|
||||
|
||||
BOOST_TEST_EQ(boost::lexical_cast<int>(-6575543), -6575543);
|
||||
|
||||
BOOST_TEST_EQ(boost::lexical_cast<int>("+6575543"), +6575543);
|
||||
BOOST_TEST_EQ(boost::lexical_cast<int>(6575543), 6575543);
|
||||
|
||||
if (sizeof(short) == 2 && CHAR_BIT == 8) {
|
||||
BOOST_TEST_EQ(boost::lexical_cast<short>("-32768"), -32768);
|
||||
BOOST_TEST_EQ(boost::lexical_cast<short>(-32768), -32768);
|
||||
BOOST_TEST_EQ(boost::lexical_cast<unsigned short>("-32768"), 32768);
|
||||
BOOST_TEST_EQ(boost::lexical_cast<unsigned short>(-32768), 32768);
|
||||
|
||||
BOOST_TEST_EQ(boost::lexical_cast<unsigned short>(65535), 65535);
|
||||
|
||||
BOOST_TEST_THROWS(boost::lexical_cast<unsigned short>(-65536), bad_lexical_cast);
|
||||
BOOST_TEST_EQ(boost::lexical_cast<unsigned short>(-65535), 1);
|
||||
BOOST_TEST_EQ(boost::lexical_cast<unsigned short>(-65534), 2);
|
||||
|
||||
BOOST_TEST_THROWS(boost::lexical_cast<short>(65535), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(boost::lexical_cast<short>(-65536), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(boost::lexical_cast<short>(-65535), bad_lexical_cast);
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_conversion_from_to_short();
|
||||
test_conversion_from_to_ushort();
|
||||
test_conversion_from_to_int();
|
||||
test_conversion_from_to_uint();
|
||||
test_conversion_from_to_long();
|
||||
test_conversion_from_to_ulong();
|
||||
test_conversion_from_to_intmax_t();
|
||||
test_conversion_from_to_uintmax_t();
|
||||
#ifdef LCAST_TEST_LONGLONG
|
||||
test_conversion_from_to_longlong();
|
||||
test_conversion_from_to_ulonglong();
|
||||
#endif
|
||||
#ifdef BOOST_LCAST_TEST_128
|
||||
test_conversion_from_to_int128();
|
||||
test_conversion_from_to_uint128();
|
||||
#endif
|
||||
test_integral_conversions_on_min_max();
|
||||
|
||||
test_negative_integral();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@@ -1,238 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2012-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
|
||||
#include <boost/range/iterator_range.hpp>
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
using namespace boost;
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
|
||||
#define BOOST_LCAST_NO_WCHAR_T
|
||||
#endif
|
||||
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION) && !defined(BOOST_MSVC)
|
||||
#define BOOST_LC_RUNU16
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION) && !defined(BOOST_MSVC)
|
||||
#define BOOST_LC_RUNU32
|
||||
#endif
|
||||
|
||||
struct class_with_user_defined_sream_operators {
|
||||
int i;
|
||||
|
||||
operator int() const {
|
||||
return i;
|
||||
}
|
||||
};
|
||||
|
||||
template <class CharT>
|
||||
inline std::basic_istream<CharT>& operator >> (std::basic_istream<CharT>& istr, class_with_user_defined_sream_operators& rhs)
|
||||
{
|
||||
return istr >> rhs.i;
|
||||
}
|
||||
|
||||
|
||||
template <class RngT>
|
||||
void do_test_iterator_range_impl(const RngT& rng)
|
||||
{
|
||||
BOOST_TEST_EQ(lexical_cast<int>(rng), 1);
|
||||
BOOST_TEST_EQ(lexical_cast<int>(rng.begin(), rng.size()), 1);
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned int>(rng), 1u);
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned int>(rng.begin(), rng.size()), 1u);
|
||||
BOOST_TEST_EQ(lexical_cast<short>(rng), 1);
|
||||
BOOST_TEST_EQ(lexical_cast<short>(rng.begin(), rng.size()), 1);
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned short>(rng), 1u);
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned short>(rng.begin(), rng.size()), 1u);
|
||||
BOOST_TEST_EQ(lexical_cast<long int>(rng), 1);
|
||||
BOOST_TEST_EQ(lexical_cast<long int>(rng.begin(), rng.size()), 1);
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned long int>(rng), 1u);
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned long int>(rng.begin(), rng.size()), 1u);
|
||||
|
||||
#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
|
||||
BOOST_TEST_EQ(lexical_cast<float>(rng), 1.0f);
|
||||
BOOST_TEST_EQ(lexical_cast<float>(rng.begin(), rng.size()), 1.0f);
|
||||
BOOST_TEST_EQ(lexical_cast<double>(rng), 1.0);
|
||||
BOOST_TEST_EQ(lexical_cast<double>(rng.begin(), rng.size()), 1.0);
|
||||
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
|
||||
BOOST_TEST_EQ(lexical_cast<long double>(rng), 1.0L);
|
||||
BOOST_TEST_EQ(lexical_cast<long double>(rng.begin(), rng.size()), 1.0L);
|
||||
#endif
|
||||
BOOST_TEST_EQ(lexical_cast<class_with_user_defined_sream_operators>(rng), 1);
|
||||
#endif
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
BOOST_TEST_EQ(lexical_cast<boost::ulong_long_type>(rng), 1u);
|
||||
BOOST_TEST_EQ(lexical_cast<boost::ulong_long_type>(rng.begin(), rng.size()), 1u);
|
||||
BOOST_TEST_EQ(lexical_cast<boost::long_long_type>(rng), 1);
|
||||
BOOST_TEST_EQ(lexical_cast<boost::long_long_type>(rng.begin(), rng.size()), 1);
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned __int64>(rng), 1u);
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned __int64>(rng.begin(), rng.size()), 1u);
|
||||
BOOST_TEST_EQ(lexical_cast<__int64>(rng), 1);
|
||||
BOOST_TEST_EQ(lexical_cast<__int64>(rng.begin(), rng.size()), 1);
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class CharT>
|
||||
void test_it_range_using_any_chars(CharT* one, CharT* eleven)
|
||||
{
|
||||
typedef CharT test_char_type;
|
||||
|
||||
// Zero terminated
|
||||
iterator_range<test_char_type*> rng1(one, one + 1);
|
||||
do_test_iterator_range_impl(rng1);
|
||||
|
||||
iterator_range<const test_char_type*> crng1(one, one + 1);
|
||||
do_test_iterator_range_impl(crng1);
|
||||
|
||||
// Non zero terminated
|
||||
iterator_range<test_char_type*> rng2(eleven, eleven + 1);
|
||||
do_test_iterator_range_impl(rng2);
|
||||
|
||||
iterator_range<const test_char_type*> crng2(eleven, eleven + 1);
|
||||
do_test_iterator_range_impl(crng2);
|
||||
}
|
||||
|
||||
template <class CharT>
|
||||
void test_it_range_using_char(CharT* one, CharT* eleven)
|
||||
{
|
||||
typedef CharT test_char_type;
|
||||
|
||||
iterator_range<test_char_type*> rng1(one, one + 1);
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(rng1), "1");
|
||||
|
||||
iterator_range<const test_char_type*> crng1(one, one + 1);
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(crng1), "1");
|
||||
|
||||
iterator_range<test_char_type*> rng2(eleven, eleven + 1);
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(rng2), "1");
|
||||
|
||||
iterator_range<const test_char_type*> crng2(eleven, eleven + 1);
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(crng2), "1");
|
||||
|
||||
BOOST_TEST_EQ(lexical_cast<float>(rng1), 1.0f);
|
||||
BOOST_TEST_EQ(lexical_cast<double>(rng1), 1.0);
|
||||
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
|
||||
BOOST_TEST_EQ(lexical_cast<long double>(rng1), 1.0L);
|
||||
#endif
|
||||
BOOST_TEST_EQ(lexical_cast<class_with_user_defined_sream_operators>(rng1), 1);
|
||||
|
||||
BOOST_TEST_EQ(lexical_cast<float>(crng2), 1.0f);
|
||||
BOOST_TEST_EQ(lexical_cast<double>(crng2), 1.0);
|
||||
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
|
||||
BOOST_TEST_EQ(lexical_cast<long double>(crng2), 1.0L);
|
||||
#endif
|
||||
BOOST_TEST_EQ(lexical_cast<class_with_user_defined_sream_operators>(crng2), 1);
|
||||
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(_LIBCPP_VERSION)
|
||||
BOOST_TEST(lexical_cast<std::wstring>(rng1) == L"1");
|
||||
BOOST_TEST(lexical_cast<std::wstring>(crng1) == L"1");
|
||||
BOOST_TEST(lexical_cast<std::wstring>(rng2) == L"1");
|
||||
BOOST_TEST(lexical_cast<std::wstring>(crng2) == L"1");
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_LC_RUNU16) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
typedef std::basic_string<char16_t> my_char16_string;
|
||||
BOOST_TEST(lexical_cast<my_char16_string>(rng1) == u"1");
|
||||
BOOST_TEST(lexical_cast<my_char16_string>(crng1) == u"1");
|
||||
BOOST_TEST(lexical_cast<my_char16_string>(rng2) == u"1");
|
||||
BOOST_TEST(lexical_cast<my_char16_string>(crng2) == u"1");
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_LC_RUNU32) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
typedef std::basic_string<char32_t> my_char32_string;
|
||||
BOOST_TEST(lexical_cast<my_char32_string>(rng1) == U"1");
|
||||
BOOST_TEST(lexical_cast<my_char32_string>(crng1) == U"1");
|
||||
BOOST_TEST(lexical_cast<my_char32_string>(rng2) == U"1");
|
||||
BOOST_TEST(lexical_cast<my_char32_string>(crng2) == U"1");
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_char_iterator_ranges()
|
||||
{
|
||||
typedef char test_char_type;
|
||||
test_char_type data1[] = "1";
|
||||
test_char_type data2[] = "11";
|
||||
test_it_range_using_any_chars(data1, data2);
|
||||
test_it_range_using_char(data1, data2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void test_unsigned_char_iterator_ranges()
|
||||
{
|
||||
typedef unsigned char test_char_type;
|
||||
test_char_type data1[] = "1";
|
||||
test_char_type data2[] = "11";
|
||||
test_it_range_using_any_chars(data1, data2);
|
||||
test_it_range_using_char(data1, data2);
|
||||
}
|
||||
|
||||
void test_signed_char_iterator_ranges()
|
||||
{
|
||||
typedef signed char test_char_type;
|
||||
test_char_type data1[] = "1";
|
||||
test_char_type data2[] = "11";
|
||||
test_it_range_using_any_chars(data1, data2);
|
||||
test_it_range_using_char(data1, data2);
|
||||
}
|
||||
|
||||
void test_wchar_iterator_ranges()
|
||||
{
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(_LIBCPP_VERSION)
|
||||
typedef wchar_t test_char_type;
|
||||
test_char_type data1[] = L"1";
|
||||
test_char_type data2[] = L"11";
|
||||
test_it_range_using_any_chars(data1, data2);
|
||||
#endif
|
||||
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
void test_char16_iterator_ranges()
|
||||
{
|
||||
#if defined(BOOST_LC_RUNU16)
|
||||
typedef char16_t test_char_type;
|
||||
test_char_type data1[] = u"1";
|
||||
test_char_type data2[] = u"11";
|
||||
test_it_range_using_any_chars(data1, data2);
|
||||
#endif
|
||||
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
void test_char32_iterator_ranges()
|
||||
{
|
||||
#if defined(BOOST_LC_RUNU32)
|
||||
typedef char32_t test_char_type;
|
||||
test_char_type data1[] = U"1";
|
||||
test_char_type data2[] = U"11";
|
||||
test_it_range_using_any_chars(data1, data2);
|
||||
#endif
|
||||
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_char_iterator_ranges();
|
||||
test_unsigned_char_iterator_ranges();
|
||||
test_signed_char_iterator_ranges();
|
||||
test_wchar_iterator_ranges();
|
||||
test_char16_iterator_ranges();
|
||||
test_char32_iterator_ranges();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,177 +0,0 @@
|
||||
// Copyright Kevlin Henney, 2000-2005.
|
||||
// Copyright Alexander Nasonov, 2006-2010.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// what: lexical_cast custom keyword cast
|
||||
// who: contributed by Kevlin Henney,
|
||||
// enhanced with contributions from Terje Slettebo,
|
||||
// with additional fixes and suggestions from Gennaro Prota,
|
||||
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
|
||||
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
|
||||
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
|
||||
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
|
||||
|
||||
#ifndef BOOST_LEXICAL_CAST_LEXICAL_CAST_OLD_HPP
|
||||
#define BOOST_LEXICAL_CAST_LEXICAL_CAST_OLD_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
|
||||
#define BOOST_LCAST_NO_WCHAR_T
|
||||
#endif
|
||||
|
||||
#include <climits>
|
||||
#include <cstddef>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <type_traits>
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
|
||||
#ifdef BOOST_NO_STRINGSTREAM
|
||||
#include <strstream>
|
||||
#else
|
||||
#include <sstream>
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_USE_MODULES)
|
||||
#undef BOOST_USE_MODULES
|
||||
#endif
|
||||
#include <boost/lexical_cast/detail/lcast_precision.hpp>
|
||||
#include <boost/lexical_cast/bad_lexical_cast.hpp>
|
||||
#include <boost/lexical_cast/detail/widest_char.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace detail
|
||||
{
|
||||
|
||||
// selectors for choosing stream character type
|
||||
template<typename Type>
|
||||
struct stream_char
|
||||
{
|
||||
typedef char type;
|
||||
};
|
||||
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
template<>
|
||||
struct stream_char<wchar_t>
|
||||
{
|
||||
typedef wchar_t type;
|
||||
};
|
||||
#endif
|
||||
|
||||
template<>
|
||||
struct stream_char<wchar_t *>
|
||||
{
|
||||
typedef wchar_t type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct stream_char<const wchar_t *>
|
||||
{
|
||||
typedef wchar_t type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct stream_char<std::wstring>
|
||||
{
|
||||
typedef wchar_t type;
|
||||
};
|
||||
#endif
|
||||
|
||||
// stream wrapper for handling lexical conversions
|
||||
template<typename Target, typename Source, typename Traits>
|
||||
class lexical_stream
|
||||
{
|
||||
private:
|
||||
typedef typename widest_char<
|
||||
typename stream_char<Target>::type,
|
||||
typename stream_char<Source>::type>::type char_type;
|
||||
|
||||
typedef Traits traits_type;
|
||||
|
||||
public:
|
||||
lexical_stream(char_type* = 0, char_type* = 0)
|
||||
{
|
||||
stream.unsetf(std::ios::skipws);
|
||||
lcast_set_precision(stream, static_cast<Source*>(0), static_cast<Target*>(0) );
|
||||
}
|
||||
~lexical_stream()
|
||||
{
|
||||
#if defined(BOOST_NO_STRINGSTREAM)
|
||||
stream.freeze(false);
|
||||
#endif
|
||||
}
|
||||
bool operator<<(const Source &input)
|
||||
{
|
||||
return !(stream << input).fail();
|
||||
}
|
||||
template<typename InputStreamable>
|
||||
bool operator>>(InputStreamable &output)
|
||||
{
|
||||
return !std::is_pointer<InputStreamable>::value &&
|
||||
stream >> output &&
|
||||
stream.get() == traits_type::eof();
|
||||
}
|
||||
|
||||
bool operator>>(std::string &output)
|
||||
{
|
||||
#if defined(BOOST_NO_STRINGSTREAM)
|
||||
stream << '\0';
|
||||
#endif
|
||||
stream.str().swap(output);
|
||||
return true;
|
||||
}
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
bool operator>>(std::wstring &output)
|
||||
{
|
||||
stream.str().swap(output);
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
private:
|
||||
#if defined(BOOST_NO_STRINGSTREAM)
|
||||
std::strstream stream;
|
||||
#elif defined(BOOST_NO_STD_LOCALE)
|
||||
std::stringstream stream;
|
||||
#else
|
||||
std::basic_stringstream<char_type,traits_type> stream;
|
||||
#endif
|
||||
};
|
||||
}
|
||||
|
||||
// call-by-value fallback version (deprecated)
|
||||
|
||||
template<typename Target, typename Source>
|
||||
Target lexical_cast(Source arg)
|
||||
{
|
||||
typedef typename detail::widest_char<
|
||||
typename detail::stream_char<Target>::type
|
||||
, typename detail::stream_char<Source>::type
|
||||
>::type char_type;
|
||||
|
||||
typedef std::char_traits<char_type> traits;
|
||||
detail::lexical_stream<Target, Source, traits> interpreter;
|
||||
Target result{};
|
||||
|
||||
if(!(interpreter << arg && interpreter >> result))
|
||||
boost::conversion::detail::throw_bad_cast<Source, Target>();
|
||||
return result;
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#undef BOOST_LCAST_NO_WCHAR_T
|
||||
|
||||
#endif // BOOST_LEXICAL_CAST_LEXICAL_CAST_OLD_HPP
|
||||
|
||||
@@ -1,601 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Terje Sletteb and Kevlin Henney, 2005.
|
||||
// Copyright Alexander Nasonov, 2006.
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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).
|
||||
//
|
||||
// Note: The unit test no longer compile on MSVC 6, but lexical_cast itself works for it.
|
||||
|
||||
//
|
||||
// We need this #define before any #includes: otherwise msvc will emit warnings
|
||||
// deep within std::string, resulting from our (perfectly legal) use of basic_string
|
||||
// with a custom traits class:
|
||||
//
|
||||
#define _SCL_SECURE_NO_WARNINGS
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/type_traits/integral_promotion.hpp>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <algorithm> // std::transform
|
||||
#include <memory>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) \
|
||||
&& !(defined(BOOST_MSVC) && BOOST_MSVC < 1300)
|
||||
#define LCAST_TEST_LONGLONG
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
|
||||
#define BOOST_LCAST_NO_WCHAR_T
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_TEST_CLOSE_FRACTION
|
||||
// Naiive, but works for tests in this file
|
||||
#define BOOST_TEST_CLOSE_FRACTION(x, y, eps) BOOST_TEST(x - y + eps <= eps * 2)
|
||||
#endif
|
||||
|
||||
template<class CharT>
|
||||
struct my_traits : std::char_traits<CharT>
|
||||
{
|
||||
};
|
||||
|
||||
template<class CharT>
|
||||
struct my_allocator : std::allocator<CharT>
|
||||
{
|
||||
typedef std::allocator<CharT> base_t;
|
||||
|
||||
my_allocator(){}
|
||||
template <class U> my_allocator(const my_allocator<U>& v) : base_t(v) {}
|
||||
|
||||
template <class U> struct rebind { typedef my_allocator<U> other; };
|
||||
};
|
||||
|
||||
using namespace boost;
|
||||
|
||||
void test_conversion_to_char()
|
||||
{
|
||||
BOOST_TEST_EQ('A', lexical_cast<char>('A'));
|
||||
BOOST_TEST_EQ(' ', lexical_cast<char>(' '));
|
||||
BOOST_TEST_EQ('1', lexical_cast<char>(1));
|
||||
BOOST_TEST_EQ('0', lexical_cast<char>(0));
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(123), bad_lexical_cast);
|
||||
BOOST_TEST_EQ('1', lexical_cast<char>(1.0));
|
||||
BOOST_TEST_EQ('1', lexical_cast<char>(true));
|
||||
BOOST_TEST_EQ('0', lexical_cast<char>(false));
|
||||
BOOST_TEST_EQ('A', lexical_cast<char>("A"));
|
||||
BOOST_TEST_EQ(' ', lexical_cast<char>(" "));
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(""), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<char>("Test"), bad_lexical_cast);
|
||||
BOOST_TEST_EQ('A', lexical_cast<char>(std::string("A")));
|
||||
BOOST_TEST_EQ(' ', lexical_cast<char>(std::string(" ")));
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<char>(std::string("")), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<char>(std::string("Test")), bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_conversion_to_int()
|
||||
{
|
||||
BOOST_TEST_EQ(1, lexical_cast<int>('1'));
|
||||
BOOST_TEST_EQ(0, lexical_cast<int>('0'));
|
||||
BOOST_TEST_THROWS(lexical_cast<int>('A'), bad_lexical_cast);
|
||||
BOOST_TEST_EQ(1, lexical_cast<int>(1));
|
||||
BOOST_TEST_EQ(1, lexical_cast<int>(1.0));
|
||||
|
||||
BOOST_TEST_EQ(
|
||||
(std::numeric_limits<int>::max)(),
|
||||
lexical_cast<int>((std::numeric_limits<int>::max)()));
|
||||
|
||||
BOOST_TEST_EQ(
|
||||
(std::numeric_limits<int>::min)(),
|
||||
lexical_cast<int>((std::numeric_limits<int>::min)()));
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<int>(1.23), bad_lexical_cast);
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<int>(1e20), bad_lexical_cast);
|
||||
BOOST_TEST_EQ(1, lexical_cast<int>(true));
|
||||
BOOST_TEST_EQ(0, lexical_cast<int>(false));
|
||||
BOOST_TEST_EQ(123, lexical_cast<int>("123"));
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<int>(" 123"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<int>(""), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<int>("Test"), bad_lexical_cast);
|
||||
BOOST_TEST_EQ(123, lexical_cast<int>("123"));
|
||||
BOOST_TEST_EQ(123, lexical_cast<int>(std::string("123")));
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<int>(std::string(" 123")), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<int>(std::string("")), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<int>(std::string("Test")), bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_conversion_with_nonconst_char()
|
||||
{
|
||||
std::vector<char> buffer;
|
||||
buffer.push_back('1');
|
||||
buffer.push_back('\0');
|
||||
BOOST_TEST_EQ(boost::lexical_cast<int>(&buffer[0]), 1);
|
||||
|
||||
std::vector<unsigned char> buffer2;
|
||||
buffer2.push_back('1');
|
||||
buffer2.push_back('\0');
|
||||
BOOST_TEST_EQ(boost::lexical_cast<int>(&buffer2[0]), 1);
|
||||
|
||||
std::vector<unsigned char> buffer3;
|
||||
buffer3.push_back('1');
|
||||
buffer3.push_back('\0');
|
||||
BOOST_TEST_EQ(boost::lexical_cast<int>(&buffer3[0]), 1);
|
||||
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
std::vector<wchar_t> buffer4;
|
||||
buffer4.push_back(L'1');
|
||||
buffer4.push_back(L'\0');
|
||||
BOOST_TEST_EQ(boost::lexical_cast<int>(&buffer4[0]), 1);
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_conversion_to_double()
|
||||
{
|
||||
BOOST_TEST_CLOSE_FRACTION(1.0, lexical_cast<double>('1'), (std::numeric_limits<double>::epsilon()));
|
||||
BOOST_TEST_THROWS(lexical_cast<double>('A'), bad_lexical_cast);
|
||||
BOOST_TEST_CLOSE_FRACTION(1.0, lexical_cast<double>(1), (std::numeric_limits<double>::epsilon()));
|
||||
BOOST_TEST_CLOSE_FRACTION(1.23, lexical_cast<double>(1.23), (std::numeric_limits<double>::epsilon()));
|
||||
BOOST_TEST_CLOSE_FRACTION(1.234567890, lexical_cast<double>(1.234567890), std::numeric_limits<double>::epsilon());
|
||||
BOOST_TEST_CLOSE_FRACTION(1.234567890, lexical_cast<double>("1.234567890"), std::numeric_limits<double>::epsilon());
|
||||
BOOST_TEST_CLOSE_FRACTION(1.0, lexical_cast<double>(true), (std::numeric_limits<double>::epsilon()));
|
||||
BOOST_TEST_CLOSE_FRACTION(0.0, lexical_cast<double>(false), (std::numeric_limits<double>::epsilon()));
|
||||
BOOST_TEST_CLOSE_FRACTION(1.23, lexical_cast<double>("1.23"), (std::numeric_limits<double>::epsilon()));
|
||||
BOOST_TEST_THROWS(lexical_cast<double>(""), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<double>("Test"), bad_lexical_cast);
|
||||
BOOST_TEST_CLOSE_FRACTION(1.23, lexical_cast<double>(std::string("1.23")), (std::numeric_limits<double>::epsilon()));
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<double>(std::string("")), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<double>(std::string("Test")), bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_conversion_to_bool()
|
||||
{
|
||||
BOOST_TEST_EQ(true, lexical_cast<bool>('1'));
|
||||
BOOST_TEST_EQ(false, lexical_cast<bool>('0'));
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>('A'), bad_lexical_cast);
|
||||
BOOST_TEST_EQ(true, lexical_cast<bool>(1));
|
||||
BOOST_TEST_EQ(false, lexical_cast<bool>(0));
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>(123), bad_lexical_cast);
|
||||
BOOST_TEST_EQ(true, lexical_cast<bool>(1.0));
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>(-123), bad_lexical_cast);
|
||||
BOOST_TEST_EQ(false, lexical_cast<bool>(0.0));
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>(1234), bad_lexical_cast);
|
||||
#if !defined(_CRAYC)
|
||||
// Looks like a bug in CRAY compiler (throws bad_lexical_cast)
|
||||
// TODO: localize the bug and report it to developers.
|
||||
BOOST_TEST_EQ(true, lexical_cast<bool>(true));
|
||||
BOOST_TEST_EQ(false, lexical_cast<bool>(false));
|
||||
#endif
|
||||
BOOST_TEST_EQ(true, lexical_cast<bool>("1"));
|
||||
BOOST_TEST_EQ(false, lexical_cast<bool>("0"));
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>(""), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("Test"), bad_lexical_cast);
|
||||
BOOST_TEST_EQ(true, lexical_cast<bool>("1"));
|
||||
BOOST_TEST_EQ(false, lexical_cast<bool>("0"));
|
||||
BOOST_TEST_EQ(true, lexical_cast<bool>(std::string("1")));
|
||||
BOOST_TEST_EQ(false, lexical_cast<bool>(std::string("0")));
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>(1.0001L), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>(2), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>(2u), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>(-1), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>(-2), bad_lexical_cast);
|
||||
|
||||
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<bool>(std::string("")), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<bool>(std::string("Test")), bad_lexical_cast);
|
||||
|
||||
BOOST_TEST(lexical_cast<bool>("+1") == true);
|
||||
BOOST_TEST(lexical_cast<bool>("+0") == false);
|
||||
BOOST_TEST(lexical_cast<bool>("-0") == false);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("--0"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("-+-0"), bad_lexical_cast);
|
||||
|
||||
BOOST_TEST(lexical_cast<bool>("0") == false);
|
||||
BOOST_TEST(lexical_cast<bool>("1") == true);
|
||||
BOOST_TEST(lexical_cast<bool>("00") == false);
|
||||
BOOST_TEST(lexical_cast<bool>("00000000000") == false);
|
||||
BOOST_TEST(lexical_cast<bool>("000000000001") == true);
|
||||
BOOST_TEST(lexical_cast<bool>("+00") == false );
|
||||
BOOST_TEST(lexical_cast<bool>("-00") == false );
|
||||
BOOST_TEST(lexical_cast<bool>("+00000000001") == true );
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("020"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("00200"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("-00200"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("+00200"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("000000000002"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("-1"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("-0000000001"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("00000000011"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("001001"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("-00000000010"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>("-000000000100"), bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_conversion_to_string()
|
||||
{
|
||||
char buf[] = "hello";
|
||||
char* str = buf;
|
||||
BOOST_TEST_EQ(str, lexical_cast<std::string>(str));
|
||||
BOOST_TEST_EQ("A", lexical_cast<std::string>('A'));
|
||||
BOOST_TEST_EQ(" ", lexical_cast<std::string>(' '));
|
||||
BOOST_TEST_EQ("123", lexical_cast<std::string>(123));
|
||||
BOOST_TEST_EQ("1.23", lexical_cast<std::string>(1.23));
|
||||
BOOST_TEST_EQ("1.111111111", lexical_cast<std::string>(1.111111111));
|
||||
BOOST_TEST_EQ("1", lexical_cast<std::string>(true));
|
||||
BOOST_TEST_EQ("0", lexical_cast<std::string>(false));
|
||||
BOOST_TEST_EQ("Test", lexical_cast<std::string>("Test"));
|
||||
BOOST_TEST_EQ(" ", lexical_cast<std::string>(" "));
|
||||
BOOST_TEST_EQ("", lexical_cast<std::string>(""));
|
||||
BOOST_TEST_EQ("Test", lexical_cast<std::string>(std::string("Test")));
|
||||
BOOST_TEST_EQ(" ", lexical_cast<std::string>(std::string(" ")));
|
||||
BOOST_TEST_EQ("", lexical_cast<std::string>(std::string("")));
|
||||
}
|
||||
|
||||
void test_conversion_from_to_wchar_t_alias()
|
||||
{
|
||||
BOOST_TEST_EQ(123u, lexical_cast<unsigned short>("123"));
|
||||
BOOST_TEST_EQ(123u, lexical_cast<unsigned int>("123"));
|
||||
BOOST_TEST_EQ(123u, lexical_cast<unsigned long>("123"));
|
||||
BOOST_TEST_EQ(std::string("123"),
|
||||
lexical_cast<std::string>(static_cast<unsigned short>(123)));
|
||||
BOOST_TEST_EQ(std::string("123"), lexical_cast<std::string>(123u));
|
||||
BOOST_TEST_EQ(std::string("123"), lexical_cast<std::string>(123ul));
|
||||
}
|
||||
|
||||
void test_conversion_from_wchar_t()
|
||||
{
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
BOOST_TEST_EQ(1, lexical_cast<int>(L'1'));
|
||||
BOOST_TEST_THROWS(lexical_cast<int>(L'A'), bad_lexical_cast);
|
||||
#endif
|
||||
|
||||
BOOST_TEST_EQ(123, lexical_cast<int>(L"123"));
|
||||
BOOST_TEST_THROWS(lexical_cast<int>(L""), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<int>(L"Test"), bad_lexical_cast);
|
||||
|
||||
#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
BOOST_TEST_EQ(1.0, lexical_cast<double>(L'1'));
|
||||
BOOST_TEST_THROWS(lexical_cast<double>(L'A'), bad_lexical_cast);
|
||||
#endif
|
||||
|
||||
BOOST_TEST_EQ(1.23, lexical_cast<double>(L"1.23"));
|
||||
BOOST_TEST_THROWS(lexical_cast<double>(L""), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<double>(L"Test"), bad_lexical_cast);
|
||||
|
||||
#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
BOOST_TEST_EQ(true, lexical_cast<bool>(L'1'));
|
||||
BOOST_TEST_EQ(false, lexical_cast<bool>(L'0'));
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>(L'A'), bad_lexical_cast);
|
||||
#endif
|
||||
BOOST_TEST_EQ(true, lexical_cast<bool>(L"1"));
|
||||
BOOST_TEST_EQ(false, lexical_cast<bool>(L"0"));
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>(L""), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<bool>(L"Test"), bad_lexical_cast);
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_conversion_to_wchar_t()
|
||||
{
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
BOOST_TEST(L'1' == lexical_cast<wchar_t>(1));
|
||||
BOOST_TEST(L'0' == lexical_cast<wchar_t>(0));
|
||||
BOOST_TEST(L'1' == lexical_cast<wchar_t>('1'));
|
||||
BOOST_TEST(L'0' == lexical_cast<wchar_t>('0'));
|
||||
BOOST_TEST_THROWS(lexical_cast<wchar_t>(123), bad_lexical_cast);
|
||||
BOOST_TEST(L'1' == lexical_cast<wchar_t>(1.0));
|
||||
BOOST_TEST(L'0' == lexical_cast<wchar_t>(0.0));
|
||||
BOOST_TEST(L'1' == lexical_cast<wchar_t>(true));
|
||||
BOOST_TEST(L'0' == lexical_cast<wchar_t>(false));
|
||||
BOOST_TEST(L'A' == lexical_cast<wchar_t>(L'A'));
|
||||
BOOST_TEST(L' ' == lexical_cast<wchar_t>(L' '));
|
||||
BOOST_TEST(L'A' == lexical_cast<wchar_t>(L"A"));
|
||||
BOOST_TEST(L' ' == lexical_cast<wchar_t>(L" "));
|
||||
BOOST_TEST_THROWS(lexical_cast<wchar_t>(L""), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<wchar_t>(L"Test"), bad_lexical_cast);
|
||||
BOOST_TEST(L'A' == lexical_cast<wchar_t>(std::wstring(L"A")));
|
||||
BOOST_TEST(L' ' == lexical_cast<wchar_t>(std::wstring(L" ")));
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<wchar_t>(std::wstring(L"")), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<wchar_t>(std::wstring(L"Test")), bad_lexical_cast);
|
||||
#endif
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
void test_conversion_from_wstring()
|
||||
{
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
BOOST_TEST_EQ(123, lexical_cast<int>(std::wstring(L"123")));
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<int>(std::wstring(L"")), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<int>(std::wstring(L"Test")), bad_lexical_cast);
|
||||
|
||||
BOOST_TEST_EQ(true, lexical_cast<bool>(std::wstring(L"1")));
|
||||
BOOST_TEST_EQ(false, lexical_cast<bool>(std::wstring(L"0")));
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<bool>(std::wstring(L"")), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(
|
||||
lexical_cast<bool>(std::wstring(L"Test")), bad_lexical_cast);
|
||||
#endif
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
void test_conversion_to_wstring()
|
||||
{
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
wchar_t buf[] = L"hello";
|
||||
wchar_t* str = buf;
|
||||
BOOST_TEST(str == lexical_cast<std::wstring>(str));
|
||||
BOOST_TEST(L"123" == lexical_cast<std::wstring>(123));
|
||||
BOOST_TEST(L"1.23" == lexical_cast<std::wstring>(1.23));
|
||||
BOOST_TEST(L"1" == lexical_cast<std::wstring>(true));
|
||||
BOOST_TEST(L"0" == lexical_cast<std::wstring>(false));
|
||||
#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
BOOST_TEST(L"A" == lexical_cast<std::wstring>(L'A'));
|
||||
BOOST_TEST(L" " == lexical_cast<std::wstring>(L' '));
|
||||
BOOST_TEST(L"A" == lexical_cast<std::wstring>('A'));
|
||||
#endif
|
||||
BOOST_TEST(L"Test" == lexical_cast<std::wstring>(L"Test"));
|
||||
BOOST_TEST(L" " == lexical_cast<std::wstring>(L" "));
|
||||
BOOST_TEST(L"" == lexical_cast<std::wstring>(L""));
|
||||
BOOST_TEST(L"Test" == lexical_cast<std::wstring>(std::wstring(L"Test")));
|
||||
BOOST_TEST(L" " == lexical_cast<std::wstring>(std::wstring(L" ")));
|
||||
BOOST_TEST(L"" == lexical_cast<std::wstring>(std::wstring(L"")));
|
||||
#endif
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
void test_bad_lexical_cast()
|
||||
{
|
||||
try
|
||||
{
|
||||
lexical_cast<int>(std::string("Test"));
|
||||
|
||||
BOOST_TEST(false); // Exception expected
|
||||
}
|
||||
catch(const bad_lexical_cast &e)
|
||||
{
|
||||
BOOST_TEST(e.source_type() == typeid(std::string));
|
||||
BOOST_TEST(e.target_type() == typeid(int));
|
||||
}
|
||||
}
|
||||
|
||||
void test_no_whitespace_stripping()
|
||||
{
|
||||
BOOST_TEST_THROWS(lexical_cast<int>(" 123"), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<int>("123 "), bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_traits()
|
||||
{
|
||||
typedef std::basic_string<char, my_traits<char> > my_string;
|
||||
|
||||
my_string const s("s");
|
||||
BOOST_TEST(boost::lexical_cast<char>(s) == s[0]);
|
||||
BOOST_TEST(boost::lexical_cast<my_string>(s) == s);
|
||||
BOOST_TEST(boost::lexical_cast<my_string>(-1) == "-1");
|
||||
BOOST_TEST(boost::lexical_cast<int>(my_string("42")) == 42);
|
||||
BOOST_TEST(boost::lexical_cast<double>(my_string("1.0")) == 1.0);
|
||||
}
|
||||
|
||||
void test_wtraits()
|
||||
{
|
||||
typedef std::basic_string<wchar_t, my_traits<wchar_t> > my_string;
|
||||
|
||||
my_string const s(L"s");
|
||||
BOOST_TEST(boost::lexical_cast<wchar_t>(s) == s[0]);
|
||||
BOOST_TEST(boost::lexical_cast<my_string>(s) == s);
|
||||
BOOST_TEST(boost::lexical_cast<my_string>(-1) == L"-1");
|
||||
BOOST_TEST(boost::lexical_cast<int>(my_string(L"42")) == 42);
|
||||
BOOST_TEST(boost::lexical_cast<double>(my_string(L"1.0")) == 1.0);
|
||||
}
|
||||
|
||||
void test_allocator()
|
||||
{
|
||||
// Following test cause compilation error on MSVC2012:
|
||||
// (Reason: cannot convert from 'std::_Wrap_alloc<_Alloc>' to 'const my_allocator<CharT>')
|
||||
//
|
||||
// MSVC developer is notified about this issue
|
||||
#if !defined(_MSC_VER) || (_MSC_VER < 1700)
|
||||
typedef std::basic_string< char
|
||||
, std::char_traits<char>
|
||||
, my_allocator<char>
|
||||
> my_string;
|
||||
|
||||
my_string s("s");
|
||||
BOOST_TEST(boost::lexical_cast<char>(s) == s[0]);
|
||||
BOOST_TEST(boost::lexical_cast<std::string>(s) == "s");
|
||||
BOOST_TEST(boost::lexical_cast<my_string>(s) == s);
|
||||
BOOST_TEST(boost::lexical_cast<my_string>(1) == "1");
|
||||
BOOST_TEST(boost::lexical_cast<my_string>("s") == s);
|
||||
BOOST_TEST(boost::lexical_cast<my_string>(std::string("s")) == s);
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_wallocator()
|
||||
{
|
||||
// Following test cause compilation error on MSVC2012:
|
||||
// (Reason: cannot convert from 'std::_Wrap_alloc<_Alloc>' to 'const my_allocator<CharT>')
|
||||
//
|
||||
// MSVC developer is notified about this issue
|
||||
#if !defined(_MSC_VER) || (_MSC_VER < 1700)
|
||||
typedef std::basic_string< wchar_t
|
||||
, std::char_traits<wchar_t>
|
||||
, my_allocator<wchar_t>
|
||||
> my_string;
|
||||
|
||||
my_string s(L"s");
|
||||
BOOST_TEST(boost::lexical_cast<wchar_t>(s) == s[0]);
|
||||
BOOST_TEST(boost::lexical_cast<std::wstring>(s) == L"s");
|
||||
BOOST_TEST(boost::lexical_cast<my_string>(s) == s);
|
||||
BOOST_TEST(boost::lexical_cast<my_string>(1) == L"1");
|
||||
BOOST_TEST(boost::lexical_cast<my_string>(L"s") == s);
|
||||
BOOST_TEST(boost::lexical_cast<my_string>(std::wstring(L"s")) == s);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void test_char_types_conversions()
|
||||
{
|
||||
const char c_arr[] = "Test array of chars";
|
||||
const unsigned char uc_arr[] = "Test array of chars";
|
||||
const signed char sc_arr[] = "Test array of chars";
|
||||
|
||||
BOOST_TEST(boost::lexical_cast<std::string>(c_arr) == std::string(c_arr));
|
||||
BOOST_TEST(boost::lexical_cast<std::string>(uc_arr) == std::string(c_arr));
|
||||
BOOST_TEST(boost::lexical_cast<std::string>(sc_arr) == std::string(c_arr));
|
||||
|
||||
BOOST_TEST(boost::lexical_cast<char>(c_arr[0]) == c_arr[0]);
|
||||
BOOST_TEST(boost::lexical_cast<char>(uc_arr[0]) == c_arr[0]);
|
||||
BOOST_TEST(boost::lexical_cast<char>(sc_arr[0]) == c_arr[0]);
|
||||
|
||||
BOOST_TEST(boost::lexical_cast<unsigned char>(c_arr[0]) == uc_arr[0]);
|
||||
BOOST_TEST(boost::lexical_cast<unsigned char>(uc_arr[0]) == uc_arr[0]);
|
||||
BOOST_TEST(boost::lexical_cast<unsigned char>(sc_arr[0]) == uc_arr[0]);
|
||||
|
||||
BOOST_TEST(boost::lexical_cast<signed char>(c_arr[0]) == sc_arr[0]);
|
||||
BOOST_TEST(boost::lexical_cast<signed char>(uc_arr[0]) == sc_arr[0]);
|
||||
BOOST_TEST(boost::lexical_cast<signed char>(sc_arr[0]) == sc_arr[0]);
|
||||
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
const wchar_t wc_arr[]=L"Test array of chars";
|
||||
|
||||
BOOST_TEST(boost::lexical_cast<std::wstring>(wc_arr) == std::wstring(wc_arr));
|
||||
BOOST_TEST(boost::lexical_cast<wchar_t>(wc_arr[0]) == wc_arr[0]);
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
struct foo_operators_test
|
||||
{
|
||||
foo_operators_test() : f(2) {}
|
||||
int f;
|
||||
};
|
||||
|
||||
template <typename OStream>
|
||||
OStream& operator<<(OStream& ostr, const foo_operators_test& foo)
|
||||
{
|
||||
ostr << foo.f;
|
||||
return ostr;
|
||||
}
|
||||
|
||||
template <typename IStream>
|
||||
IStream& operator>>(IStream& istr, foo_operators_test& foo)
|
||||
{
|
||||
istr >> foo.f;
|
||||
return istr;
|
||||
}
|
||||
|
||||
void operators_overload_test()
|
||||
{
|
||||
foo_operators_test foo;
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(foo), "2");
|
||||
BOOST_TEST_EQ((boost::lexical_cast<foo_operators_test>("2")).f, 2);
|
||||
|
||||
// Must compile
|
||||
(void)boost::lexical_cast<foo_operators_test>(foo);
|
||||
}
|
||||
|
||||
|
||||
void test_char16_conversions()
|
||||
{
|
||||
// There's no std::ctype<char16_t> in Xcode_15.0.1
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(__APPLE__)
|
||||
BOOST_TEST(u"100" == lexical_cast<std::u16string>(u"100"));
|
||||
#if !defined(_LIBCPP_VERSION) // libc++ also does not have std::ctype<char16_t>
|
||||
BOOST_TEST(u"1" == lexical_cast<std::u16string>(u'1'));
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_char32_conversions()
|
||||
{
|
||||
// There's no std::ctype<char32_t> in Xcode_15.0.1
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(__APPLE__)
|
||||
BOOST_TEST(U"100" == lexical_cast<std::u32string>(U"100"));
|
||||
#if !defined(_LIBCPP_VERSION) // libc++ also does not have std::ctype<char32_t>
|
||||
BOOST_TEST(U"1" == lexical_cast<std::u32string>(U'1'));
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_getting_pointer_to_function()
|
||||
{
|
||||
// Just checking that &lexical_cast<To, From> is not ambiguous
|
||||
typedef char char_arr[4];
|
||||
typedef int(*f1)(const char_arr&);
|
||||
f1 p1 = &boost::lexical_cast<int, char_arr>;
|
||||
BOOST_TEST(p1);
|
||||
|
||||
typedef int(*f2)(const std::string&);
|
||||
f2 p2 = &boost::lexical_cast<int, std::string>;
|
||||
BOOST_TEST(p2);
|
||||
|
||||
typedef std::string(*f3)(const int&);
|
||||
f3 p3 = &boost::lexical_cast<std::string, int>;
|
||||
BOOST_TEST(p3);
|
||||
|
||||
std::vector<int> values;
|
||||
std::vector<std::string> ret;
|
||||
std::transform(values.begin(), values.end(), ret.begin(), boost::lexical_cast<std::string, int>);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_conversion_to_char();
|
||||
test_conversion_to_int();
|
||||
test_conversion_to_double();
|
||||
test_conversion_to_bool();
|
||||
test_conversion_from_to_wchar_t_alias();
|
||||
test_conversion_to_string();
|
||||
test_conversion_with_nonconst_char();
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
test_conversion_from_wchar_t();
|
||||
test_conversion_to_wchar_t();
|
||||
test_conversion_from_wstring();
|
||||
test_conversion_to_wstring();
|
||||
#endif
|
||||
test_bad_lexical_cast();
|
||||
test_no_whitespace_stripping();
|
||||
|
||||
test_traits();
|
||||
test_wtraits();
|
||||
test_allocator();
|
||||
test_wallocator();
|
||||
|
||||
test_char_types_conversions();
|
||||
operators_overload_test();
|
||||
test_char16_conversions();
|
||||
test_char32_conversions();
|
||||
test_getting_pointer_to_function();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
|
||||
@@ -1,88 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Alexander Nasonov, 2006.
|
||||
// Copyright Antony Polukhin, 2023-2026.
|
||||
//
|
||||
// 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).
|
||||
//
|
||||
// Test round-tripping conversion FPT -> string -> FPT,
|
||||
// where FPT is Floating Point Type.
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#if (defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__NetBSD__) \
|
||||
|| (defined(__hppa) && !defined(__OpenBSD__)) || (defined(__NO_LONG_DOUBLE_MATH) && (DBL_MANT_DIG != LDBL_MANT_DIG))) \
|
||||
|| defined(__MINGW64__)
|
||||
# define BOOST_LEXICAL_CAST_NO_LONG_DOUBLE_MATH_FUNCTIONS
|
||||
#endif
|
||||
|
||||
template<class T>
|
||||
void test_round_conversion()
|
||||
{
|
||||
T epsilon = std::numeric_limits<T>::epsilon();
|
||||
std::string const epsilon_s = boost::lexical_cast<std::string>(epsilon);
|
||||
BOOST_TEST(epsilon == boost::lexical_cast<T>(epsilon_s));
|
||||
|
||||
T max_ = (std::numeric_limits<T>::max)();
|
||||
std::string const max_s = boost::lexical_cast<std::string>(max_);
|
||||
BOOST_TEST(max_ == boost::lexical_cast<T>(max_s));
|
||||
|
||||
T min_ = (std::numeric_limits<T>::min)();
|
||||
std::string const min_s = boost::lexical_cast<std::string>(min_);
|
||||
BOOST_TEST(min_ == boost::lexical_cast<T>(min_s));
|
||||
|
||||
T max_div137 = max_ / 137;
|
||||
std::string max_div137_s = boost::lexical_cast<std::string>(max_div137);
|
||||
BOOST_TEST(max_div137 == boost::lexical_cast<T>(max_div137_s));
|
||||
|
||||
T epsilon_mult137 = epsilon * 137;
|
||||
std::string epsilon_mult137_s(boost::lexical_cast<std::string>(epsilon_mult137));
|
||||
BOOST_TEST(epsilon_mult137 == boost::lexical_cast<T>(epsilon_mult137_s));
|
||||
|
||||
}
|
||||
|
||||
// See bug http://tinyurl.com/vhpvo
|
||||
template<class T>
|
||||
void test_msvc_magic_values()
|
||||
{
|
||||
T magic_msvc = 0.00010000433948393407;
|
||||
std::string magic_msvc_s = boost::lexical_cast<std::string>(magic_msvc);
|
||||
BOOST_TEST(magic_msvc == boost::lexical_cast<T>(magic_msvc_s));
|
||||
}
|
||||
|
||||
void test_round_conversion_float()
|
||||
{
|
||||
test_round_conversion<float>();
|
||||
}
|
||||
|
||||
void test_round_conversion_double()
|
||||
{
|
||||
test_round_conversion<double>();
|
||||
test_msvc_magic_values<double>();
|
||||
}
|
||||
|
||||
void test_round_conversion_long_double()
|
||||
{
|
||||
// We do not run tests on compilers and Standard Libraries with poor support of long double
|
||||
#if !defined(BOOST_LEXICAL_CAST_NO_LONG_DOUBLE_MATH_FUNCTIONS)
|
||||
test_round_conversion<long double>();
|
||||
test_msvc_magic_values<long double>();
|
||||
#endif
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_round_conversion_float();
|
||||
test_round_conversion_double();
|
||||
test_round_conversion_long_double();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@@ -1,78 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2012-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(__INTEL_COMPILER)
|
||||
#pragma warning(disable: 193 383 488 981 1418 1419)
|
||||
#elif defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
|
||||
#endif
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/range/iterator_range.hpp>
|
||||
|
||||
#include <cstdlib>
|
||||
|
||||
#if defined(BOOST_USE_MODULES)
|
||||
#undef BOOST_USE_MODULES
|
||||
#endif
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#include "escape_struct.hpp"
|
||||
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
#error "This test must be compiled with -DBOOST_NO_EXCEPTIONS"
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
BOOST_NORETURN void throw_exception(std::exception const & ) {
|
||||
static int state = 0;
|
||||
++ state;
|
||||
|
||||
EscapeStruct v("");
|
||||
switch(state) {
|
||||
case 1:
|
||||
lexical_cast<char>(v); // should call boost::throw_exception
|
||||
std::exit(1);
|
||||
case 2:
|
||||
lexical_cast<unsigned char>(v); // should call boost::throw_exception
|
||||
std::exit(2);
|
||||
}
|
||||
std::exit(boost::report_errors());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void test_exceptions_off() {
|
||||
using namespace boost;
|
||||
EscapeStruct v("");
|
||||
|
||||
v = lexical_cast<EscapeStruct>(100);
|
||||
BOOST_TEST_EQ(lexical_cast<int>(v), 100);
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned int>(v), 100u);
|
||||
|
||||
v = lexical_cast<EscapeStruct>(0.0);
|
||||
BOOST_TEST_EQ(lexical_cast<double>(v), 0.0);
|
||||
|
||||
BOOST_TEST_EQ(lexical_cast<short>(100), 100);
|
||||
BOOST_TEST_EQ(lexical_cast<float>(0.0), 0.0);
|
||||
|
||||
lexical_cast<short>(700000); // should call boost::throw_exception
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
|
||||
int main() {
|
||||
test_exceptions_off();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@@ -1,143 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2012-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/range/iterator_range.hpp>
|
||||
|
||||
#include "escape_struct.hpp"
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
using namespace boost;
|
||||
|
||||
// Testing compilation and some basic usage with BOOST_NO_STD_LOCALE
|
||||
// Tests are mainly copyied from empty_input_test.cpp (something
|
||||
// new added to test_empty_3)
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
#error "This test must be compiled with -DBOOST_NO_STD_LOCALE"
|
||||
#endif
|
||||
|
||||
|
||||
template <class T>
|
||||
void do_test_on_empty_input(T& v)
|
||||
{
|
||||
BOOST_TEST_THROWS(lexical_cast<int>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<float>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<double>(v), bad_lexical_cast);
|
||||
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
|
||||
BOOST_TEST_THROWS(lexical_cast<long double>(v), bad_lexical_cast);
|
||||
#endif
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned int>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned short>(v), bad_lexical_cast);
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
BOOST_TEST_THROWS(lexical_cast<boost::ulong_long_type>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<boost::long_long_type>(v), bad_lexical_cast);
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned __int64>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<__int64>(v), bad_lexical_cast);
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_empty_1()
|
||||
{
|
||||
boost::iterator_range<char*> v;
|
||||
do_test_on_empty_input(v);
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(v), std::string());
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
|
||||
|
||||
boost::iterator_range<const char*> cv;
|
||||
do_test_on_empty_input(cv);
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(cv), std::string());
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(cv), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned char>(cv), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<signed char>(cv), bad_lexical_cast);
|
||||
|
||||
const boost::iterator_range<const char*> ccv;
|
||||
do_test_on_empty_input(ccv);
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(ccv), std::string());
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(ccv), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned char>(ccv), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<signed char>(ccv), bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_empty_2()
|
||||
{
|
||||
std::string v;
|
||||
do_test_on_empty_input(v);
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_empty_3()
|
||||
{
|
||||
EscapeStruct v("");
|
||||
do_test_on_empty_input(v);
|
||||
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
|
||||
|
||||
v = lexical_cast<EscapeStruct>(100);
|
||||
BOOST_TEST_EQ(lexical_cast<int>(v), 100);
|
||||
BOOST_TEST_EQ(lexical_cast<unsigned int>(v), 100u);
|
||||
|
||||
v = lexical_cast<EscapeStruct>(0.0);
|
||||
BOOST_TEST_EQ(lexical_cast<double>(v), 0.0);
|
||||
}
|
||||
|
||||
namespace std {
|
||||
inline std::ostream & operator<<(std::ostream & out, const std::vector<long> & v)
|
||||
{
|
||||
std::ostream_iterator<long> it(out);
|
||||
std::copy(v.begin(), v.end(), it);
|
||||
BOOST_TEST(out);
|
||||
return out;
|
||||
}
|
||||
}
|
||||
|
||||
void test_empty_4()
|
||||
{
|
||||
std::vector<long> v;
|
||||
do_test_on_empty_input(v);
|
||||
BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
|
||||
BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
|
||||
}
|
||||
|
||||
|
||||
struct my_string {
|
||||
friend std::ostream &operator<<(std::ostream& sout, my_string const&/* st*/) {
|
||||
return sout << "";
|
||||
}
|
||||
};
|
||||
|
||||
void test_empty_5()
|
||||
{
|
||||
my_string st;
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(st), std::string());;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_empty_1();
|
||||
test_empty_2();
|
||||
test_empty_3();
|
||||
test_empty_4();
|
||||
test_empty_5();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@@ -1,41 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Alexander Nasonov, 2007.
|
||||
// Copyright Antony Polukhin, 2023-2026.
|
||||
//
|
||||
// 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).
|
||||
//
|
||||
// Test that Source can be non-copyable.
|
||||
|
||||
#include <boost/core/noncopyable.hpp>
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
class Noncopyable : private boost::noncopyable
|
||||
{
|
||||
public:
|
||||
Noncopyable() {}
|
||||
};
|
||||
|
||||
inline std::ostream &operator<<(std::ostream &out, const Noncopyable&)
|
||||
{
|
||||
return out << "Noncopyable";
|
||||
}
|
||||
|
||||
void test_noncopyable()
|
||||
{
|
||||
Noncopyable x;
|
||||
BOOST_TEST(boost::lexical_cast<std::string>(x) == "Noncopyable");
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_noncopyable();
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,88 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2012-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <sstream>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM)
|
||||
typedef std::strstream ss_t;
|
||||
#else
|
||||
typedef std::stringstream ss_t;
|
||||
#endif
|
||||
|
||||
void test_void_pointers_conversions()
|
||||
{
|
||||
void *p_to_null = NULL;
|
||||
const void *cp_to_data = "Some data";
|
||||
char nonconst_data[5];
|
||||
void *p_to_data = nonconst_data;
|
||||
ss_t ss;
|
||||
|
||||
ss << p_to_null;
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(p_to_null), ss.str());
|
||||
ss.str(std::string());
|
||||
|
||||
ss << cp_to_data;
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(cp_to_data), ss.str());
|
||||
ss.str(std::string());
|
||||
|
||||
ss << p_to_data;
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(p_to_data), ss.str());
|
||||
ss.str(std::string());
|
||||
}
|
||||
|
||||
struct incomplete_type;
|
||||
|
||||
void test_incomplete_type_pointers_conversions()
|
||||
{
|
||||
incomplete_type *p_to_null = NULL;
|
||||
const incomplete_type *cp_to_data = NULL;
|
||||
char nonconst_data[5];
|
||||
incomplete_type *p_to_data = reinterpret_cast<incomplete_type*>(nonconst_data);
|
||||
ss_t ss;
|
||||
|
||||
ss << p_to_null;
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(p_to_null), ss.str());
|
||||
ss.str(std::string());
|
||||
|
||||
ss << cp_to_data;
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(cp_to_data), ss.str());
|
||||
ss.str(std::string());
|
||||
|
||||
ss << p_to_data;
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(p_to_data), ss.str());
|
||||
ss.str(std::string());
|
||||
}
|
||||
|
||||
struct ble;
|
||||
typedef struct ble *meh;
|
||||
std::ostream& operator <<(std::ostream &o, meh) {
|
||||
o << "yay";
|
||||
return o;
|
||||
}
|
||||
|
||||
void test_inomplete_type_with_overloaded_ostream_op() {
|
||||
meh heh = NULL;
|
||||
ss_t ss;
|
||||
ss << heh;
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(heh), ss.str());
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_void_pointers_conversions();
|
||||
test_incomplete_type_pointers_conversions();
|
||||
test_inomplete_type_with_overloaded_ostream_op();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,298 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <iostream>
|
||||
#include <type_traits>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
|
||||
///////////////////////// char streamable classes ///////////////////////////////////////////
|
||||
|
||||
struct streamable_easy { enum ENU {value = 0}; };
|
||||
std::ostream& operator << (std::ostream& ostr, const streamable_easy&) {
|
||||
return ostr << streamable_easy::value;
|
||||
}
|
||||
std::istream& operator >> (std::istream& istr, const streamable_easy&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, streamable_easy::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct streamable_medium { enum ENU {value = 1}; };
|
||||
template <class CharT>
|
||||
typename std::enable_if<std::is_same<CharT, char>::value, std::basic_ostream<CharT>&>::type
|
||||
operator << (std::basic_ostream<CharT>& ostr, const streamable_medium&) {
|
||||
return ostr << streamable_medium::value;
|
||||
}
|
||||
template <class CharT>
|
||||
typename std::enable_if<std::is_same<CharT, char>::value, std::basic_istream<CharT>&>::type
|
||||
operator >> (std::basic_istream<CharT>& istr, const streamable_medium&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, streamable_medium::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct streamable_hard { enum ENU {value = 2}; };
|
||||
template <class CharT, class TraitsT>
|
||||
typename std::enable_if<std::is_same<CharT, char>::value, std::basic_ostream<CharT, TraitsT>&>::type
|
||||
operator << (std::basic_ostream<CharT, TraitsT>& ostr, const streamable_hard&) {
|
||||
return ostr << streamable_hard::value;
|
||||
}
|
||||
template <class CharT, class TraitsT>
|
||||
typename std::enable_if<std::is_same<CharT, char>::value, std::basic_istream<CharT, TraitsT>&>::type
|
||||
operator >> (std::basic_istream<CharT, TraitsT>& istr, const streamable_hard&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, streamable_hard::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct streamable_hard2 { enum ENU {value = 3}; };
|
||||
template <class TraitsT>
|
||||
std::basic_ostream<char, TraitsT>& operator << (std::basic_ostream<char, TraitsT>& ostr, const streamable_hard2&) {
|
||||
return ostr << streamable_hard2::value;
|
||||
}
|
||||
template <class TraitsT>
|
||||
std::basic_istream<char, TraitsT>& operator >> (std::basic_istream<char, TraitsT>& istr, const streamable_hard2&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, streamable_hard2::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
|
||||
///////////////////////// wchar_t streamable classes ///////////////////////////////////////////
|
||||
|
||||
struct wstreamable_easy { enum ENU {value = 4}; };
|
||||
std::wostream& operator << (std::wostream& ostr, const wstreamable_easy&) {
|
||||
return ostr << wstreamable_easy::value;
|
||||
}
|
||||
std::wistream& operator >> (std::wistream& istr, const wstreamable_easy&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, wstreamable_easy::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct wstreamable_medium { enum ENU {value = 5}; };
|
||||
template <class CharT>
|
||||
typename std::enable_if<std::is_same<CharT, wchar_t>::value, std::basic_ostream<CharT>& >::type
|
||||
operator << (std::basic_ostream<CharT>& ostr, const wstreamable_medium&) {
|
||||
return ostr << wstreamable_medium::value;
|
||||
}
|
||||
template <class CharT>
|
||||
typename std::enable_if<std::is_same<CharT, wchar_t>::value, std::basic_istream<CharT>& >::type
|
||||
operator >> (std::basic_istream<CharT>& istr, const wstreamable_medium&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, wstreamable_medium::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct wstreamable_hard { enum ENU {value = 6}; };
|
||||
template <class CharT, class TraitsT>
|
||||
typename std::enable_if<std::is_same<CharT, wchar_t>::value, std::basic_ostream<CharT, TraitsT>&>::type
|
||||
operator << (std::basic_ostream<CharT, TraitsT>& ostr, const wstreamable_hard&) {
|
||||
return ostr << wstreamable_hard::value;
|
||||
}
|
||||
template <class CharT, class TraitsT>
|
||||
typename std::enable_if<std::is_same<CharT, wchar_t>::value, std::basic_istream<CharT, TraitsT>&>::type
|
||||
operator >> (std::basic_istream<CharT, TraitsT>& istr, const wstreamable_hard&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, wstreamable_hard::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct wstreamable_hard2 { enum ENU {value = 7}; };
|
||||
template <class TraitsT>
|
||||
std::basic_ostream<wchar_t, TraitsT>& operator << (std::basic_ostream<wchar_t, TraitsT>& ostr, const wstreamable_hard2&) {
|
||||
return ostr << wstreamable_hard2::value;
|
||||
}
|
||||
template <class TraitsT>
|
||||
std::basic_istream<wchar_t, TraitsT>& operator >> (std::basic_istream<wchar_t, TraitsT>& istr, const wstreamable_hard2&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, wstreamable_hard2::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
///////////////////////// char and wchar_t streamable classes ///////////////////////////////////////////
|
||||
|
||||
|
||||
struct bistreamable_easy { enum ENU {value = 8}; };
|
||||
std::ostream& operator << (std::ostream& ostr, const bistreamable_easy&) {
|
||||
return ostr << bistreamable_easy::value;
|
||||
}
|
||||
std::istream& operator >> (std::istream& istr, const bistreamable_easy&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, bistreamable_easy::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
std::wostream& operator << (std::wostream& ostr, const bistreamable_easy&) {
|
||||
return ostr << bistreamable_easy::value + 100;
|
||||
}
|
||||
std::wistream& operator >> (std::wistream& istr, const bistreamable_easy&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, bistreamable_easy::value + 100);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct bistreamable_medium { enum ENU {value = 9}; };
|
||||
template <class CharT>
|
||||
std::basic_ostream<CharT>& operator << (std::basic_ostream<CharT>& ostr, const bistreamable_medium&) {
|
||||
return ostr << bistreamable_medium::value + (sizeof(CharT) == 1 ? 0 : 100);
|
||||
}
|
||||
template <class CharT>
|
||||
std::basic_istream<CharT>& operator >> (std::basic_istream<CharT>& istr, const bistreamable_medium&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, bistreamable_medium::value + (sizeof(CharT) == 1 ? 0 : 100));
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct bistreamable_hard { enum ENU {value = 10}; };
|
||||
template <class CharT, class TraitsT>
|
||||
std::basic_ostream<CharT, TraitsT>& operator << (std::basic_ostream<CharT, TraitsT>& ostr, const bistreamable_hard&) {
|
||||
return ostr << bistreamable_hard::value + (sizeof(CharT) == 1 ? 0 : 100);
|
||||
}
|
||||
template <class CharT, class TraitsT>
|
||||
std::basic_istream<CharT, TraitsT>& operator >> (std::basic_istream<CharT, TraitsT>& istr, const bistreamable_hard&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, bistreamable_hard::value + (sizeof(CharT) == 1 ? 0 : 100));
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct bistreamable_hard2 { enum ENU {value = 11}; };
|
||||
template <class TraitsT>
|
||||
std::basic_ostream<char, TraitsT>& operator << (std::basic_ostream<char, TraitsT>& ostr, const bistreamable_hard2&) {
|
||||
return ostr << bistreamable_hard2::value;
|
||||
}
|
||||
template <class TraitsT>
|
||||
std::basic_istream<char, TraitsT>& operator >> (std::basic_istream<char, TraitsT>& istr, const bistreamable_hard2&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, bistreamable_hard2::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
template <class TraitsT>
|
||||
std::basic_ostream<wchar_t, TraitsT>& operator << (std::basic_ostream<wchar_t, TraitsT>& ostr, const bistreamable_hard2&) {
|
||||
return ostr << bistreamable_hard2::value + 100;
|
||||
}
|
||||
template <class TraitsT>
|
||||
std::basic_istream<wchar_t, TraitsT>& operator >> (std::basic_istream<wchar_t, TraitsT>& istr, const bistreamable_hard2&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, bistreamable_hard2::value + 100);
|
||||
return istr;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
static void test_ostr_impl() {
|
||||
T streamable;
|
||||
BOOST_TEST_EQ(T::value, boost::lexical_cast<int>(streamable));
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(T::value), boost::lexical_cast<std::string>(streamable));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
static void test_wostr_impl() {
|
||||
T streamable;
|
||||
BOOST_TEST_EQ(T::value, boost::lexical_cast<int>(streamable));
|
||||
// BOOST_TEST_EQ(boost::lexical_cast<std::string>(T::value), boost::lexical_cast<std::string>(streamable)); // Shall not compile???
|
||||
BOOST_TEST(boost::lexical_cast<std::wstring>(T::value) == boost::lexical_cast<std::wstring>(streamable));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
static void test_bistr_impl() {
|
||||
T streamable;
|
||||
|
||||
BOOST_TEST_EQ(T::value, boost::lexical_cast<int>(streamable));
|
||||
BOOST_TEST_EQ(boost::lexical_cast<std::string>(T::value), boost::lexical_cast<std::string>(streamable));
|
||||
|
||||
BOOST_TEST(boost::lexical_cast<std::wstring>(T::value + 100) == boost::lexical_cast<std::wstring>(streamable));
|
||||
}
|
||||
|
||||
void test_ostream_character_detection() {
|
||||
test_ostr_impl<streamable_easy>();
|
||||
test_ostr_impl<streamable_medium>();
|
||||
test_ostr_impl<streamable_hard>();
|
||||
test_ostr_impl<streamable_hard2>();
|
||||
|
||||
test_wostr_impl<wstreamable_easy>();
|
||||
test_wostr_impl<wstreamable_medium>();
|
||||
test_wostr_impl<wstreamable_hard>();
|
||||
test_wostr_impl<wstreamable_hard2>();
|
||||
|
||||
test_bistr_impl<bistreamable_easy>();
|
||||
test_bistr_impl<bistreamable_medium>();
|
||||
test_bistr_impl<bistreamable_hard>();
|
||||
test_bistr_impl<bistreamable_hard2>();
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
static void test_istr_impl() {
|
||||
boost::lexical_cast<T>(T::value);
|
||||
boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
static void test_wistr_impl() {
|
||||
boost::lexical_cast<T>(T::value);
|
||||
//boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value)); // Shall not compile???
|
||||
boost::lexical_cast<T>(boost::lexical_cast<std::wstring>(T::value));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
static void test_bistr_instr_impl() {
|
||||
boost::lexical_cast<T>(T::value);
|
||||
boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value));
|
||||
boost::lexical_cast<T>(boost::lexical_cast<std::wstring>(T::value + 100));
|
||||
}
|
||||
|
||||
void test_istream_character_detection() {
|
||||
test_istr_impl<streamable_easy>();
|
||||
test_istr_impl<streamable_medium>();
|
||||
test_istr_impl<streamable_hard>();
|
||||
test_istr_impl<streamable_hard2>();
|
||||
|
||||
test_wistr_impl<wstreamable_easy>();
|
||||
test_wistr_impl<wstreamable_medium>();
|
||||
test_wistr_impl<wstreamable_hard>();
|
||||
test_wistr_impl<wstreamable_hard2>();
|
||||
|
||||
test_bistr_instr_impl<bistreamable_easy>();
|
||||
test_bistr_instr_impl<bistreamable_medium>();
|
||||
test_bistr_instr_impl<bistreamable_hard>();
|
||||
test_bistr_instr_impl<bistreamable_hard2>();
|
||||
}
|
||||
|
||||
struct wistreamble_ostreamable { enum ENU {value = 200}; };
|
||||
std::ostream& operator << (std::ostream& ostr, const wistreamble_ostreamable&) {
|
||||
return ostr << wistreamble_ostreamable::value;
|
||||
}
|
||||
std::wistream& operator >> (std::wistream& istr, const wistreamble_ostreamable&) {
|
||||
int i = 100;
|
||||
istr >> i;
|
||||
BOOST_TEST_EQ(i, wistreamble_ostreamable::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct istreamble_wostreamable { enum ENU {value = 201}; };
|
||||
std::wostream& operator << (std::wostream& ostr, const istreamble_wostreamable&) {
|
||||
return ostr << istreamble_wostreamable::value;
|
||||
}
|
||||
std::istream& operator >> (std::istream& istr, const istreamble_wostreamable&) {
|
||||
int i; istr >> i; BOOST_TEST_EQ(i, istreamble_wostreamable::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
void test_mixed_stream_character_detection() {
|
||||
//boost::lexical_cast<std::wstring>(std::string("qwe")); // TODO: ALLOW IT AS EXTENSION!
|
||||
|
||||
BOOST_TEST_EQ(boost::lexical_cast<int>(wistreamble_ostreamable::value), wistreamble_ostreamable::value);
|
||||
boost::lexical_cast<wistreamble_ostreamable>(wistreamble_ostreamable::value);
|
||||
BOOST_TEST_EQ(boost::lexical_cast<int>(wistreamble_ostreamable()), wistreamble_ostreamable::value);
|
||||
|
||||
boost::lexical_cast<istreamble_wostreamable>(istreamble_wostreamable::value);
|
||||
BOOST_TEST_EQ(boost::lexical_cast<int>(istreamble_wostreamable()), istreamble_wostreamable::value);
|
||||
}
|
||||
|
||||
|
||||
int main()
|
||||
{
|
||||
test_ostream_character_detection();
|
||||
test_istream_character_detection();
|
||||
test_mixed_stream_character_detection();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,195 +0,0 @@
|
||||
// Copyright Antony Polukhin, 2012-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#if defined(BOOST_USE_MODULES)
|
||||
#undef BOOST_USE_MODULES
|
||||
#endif
|
||||
#include <boost/lexical_cast/detail/converter_lexical.hpp>
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/container/string.hpp>
|
||||
#include <boost/range/iterator_range.hpp>
|
||||
#include <boost/utility/string_view.hpp>
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
struct is_optimized_stream : std::false_type {};
|
||||
|
||||
template <class CharT, class Traits, std::size_t CharacterBufferSize>
|
||||
struct is_optimized_stream< boost::detail::lcast::optimized_src_stream<CharT, Traits, CharacterBufferSize> > : std::true_type {};
|
||||
|
||||
template <class Source, class Target>
|
||||
static void assert_optimized_stream()
|
||||
{
|
||||
BOOST_TEST((is_optimized_stream<
|
||||
typename boost::detail::lexical_converter_impl<Source, Target>::from_src_stream
|
||||
>::value));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
static void test_optimized_types_to_string_const()
|
||||
{
|
||||
namespace de = boost::detail;
|
||||
typedef de::lexical_cast_stream_traits<T, std::string> trait_1;
|
||||
BOOST_TEST((std::is_same<typename trait_1::src_char_t, char>::value));
|
||||
BOOST_TEST((std::is_same<typename trait_1::target_char_t, char>::value));
|
||||
BOOST_TEST((std::is_same<typename trait_1::char_type, char>::value));
|
||||
assert_optimized_stream<T, std::string>();
|
||||
assert_optimized_stream<T, boost::container::string>();
|
||||
|
||||
typedef de::lexical_cast_stream_traits<const T, std::string> trait_2;
|
||||
BOOST_TEST((std::is_same<typename trait_2::src_char_t, char>::value));
|
||||
BOOST_TEST((std::is_same<typename trait_2::target_char_t, char>::value));
|
||||
BOOST_TEST((std::is_same<typename trait_2::char_type, char>::value));
|
||||
|
||||
typedef de::lexical_cast_stream_traits<T, std::wstring> trait_3;
|
||||
BOOST_TEST((std::is_same<typename trait_3::src_char_t, char>::value));
|
||||
BOOST_TEST((std::is_same<typename trait_3::target_char_t, wchar_t>::value));
|
||||
BOOST_TEST((std::is_same<typename trait_3::char_type, wchar_t>::value));
|
||||
assert_optimized_stream<T, std::wstring>();
|
||||
assert_optimized_stream<T, boost::container::wstring>();
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
static void test_optimized_types_to_string()
|
||||
{
|
||||
test_optimized_types_to_string_const<T>();
|
||||
|
||||
namespace de = boost::detail;
|
||||
typedef de::lexical_cast_stream_traits<std::string, T> trait_4;
|
||||
BOOST_TEST((std::is_same<typename trait_4::src_char_t, char>::value));
|
||||
BOOST_TEST((std::is_same<typename trait_4::target_char_t, char>::value));
|
||||
BOOST_TEST((std::is_same<typename trait_4::char_type, char>::value));
|
||||
assert_optimized_stream<std::string, T>();
|
||||
|
||||
typedef de::lexical_cast_stream_traits<const std::string, T> trait_5;
|
||||
BOOST_TEST((std::is_same<typename trait_5::src_char_t, char>::value));
|
||||
BOOST_TEST((std::is_same<typename trait_5::target_char_t, char>::value));
|
||||
BOOST_TEST((std::is_same<typename trait_5::char_type, char>::value));
|
||||
|
||||
typedef de::lexical_cast_stream_traits<const std::wstring, T> trait_6;
|
||||
BOOST_TEST((std::is_same<typename trait_6::src_char_t, wchar_t>::value));
|
||||
BOOST_TEST((std::is_same<typename trait_6::target_char_t, char>::value));
|
||||
BOOST_TEST((std::is_same<typename trait_6::char_type, wchar_t>::value));
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
static void test_optimized_types_to_x_string()
|
||||
{
|
||||
test_optimized_types_to_string<T>();
|
||||
assert_optimized_stream<std::wstring, T>();
|
||||
assert_optimized_stream<boost::container::wstring, T>();
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
static void test_optimized_types_to_wstring()
|
||||
{
|
||||
assert_optimized_stream<std::wstring, T>();
|
||||
assert_optimized_stream<T, std::wstring>();
|
||||
assert_optimized_stream<boost::container::wstring, T>();
|
||||
assert_optimized_stream<T, boost::container::wstring>();
|
||||
}
|
||||
|
||||
void test_metafunctions()
|
||||
{
|
||||
test_optimized_types_to_x_string<bool>();
|
||||
test_optimized_types_to_x_string<char>();
|
||||
test_optimized_types_to_x_string<unsigned char>();
|
||||
test_optimized_types_to_x_string<signed char>();
|
||||
test_optimized_types_to_x_string<short>();
|
||||
test_optimized_types_to_x_string<unsigned short>();
|
||||
test_optimized_types_to_x_string<int>();
|
||||
test_optimized_types_to_x_string<unsigned int>();
|
||||
test_optimized_types_to_x_string<long>();
|
||||
test_optimized_types_to_x_string<unsigned long>();
|
||||
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
test_optimized_types_to_x_string<boost::ulong_long_type>();
|
||||
test_optimized_types_to_x_string<boost::long_long_type>();
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
test_optimized_types_to_x_string<unsigned __int64>();
|
||||
test_optimized_types_to_x_string<__int64>();
|
||||
#endif
|
||||
|
||||
test_optimized_types_to_string<float>();
|
||||
test_optimized_types_to_string<double>();
|
||||
test_optimized_types_to_string<long double>();
|
||||
test_optimized_types_to_string<std::string>();
|
||||
test_optimized_types_to_string<char*>();
|
||||
//test_optimized_types_to_string<char[5]>();
|
||||
//test_optimized_types_to_string<char[1]>();
|
||||
test_optimized_types_to_string<unsigned char*>();
|
||||
//test_optimized_types_to_string<unsigned char[5]>();
|
||||
//test_optimized_types_to_string<unsigned char[1]>();
|
||||
test_optimized_types_to_string<signed char*>();
|
||||
//test_optimized_types_to_string<signed char[5]>();
|
||||
//test_optimized_types_to_string<signed char[1]>();
|
||||
test_optimized_types_to_string<boost::array<char, 1> >();
|
||||
test_optimized_types_to_string<boost::array<char, 5> >();
|
||||
test_optimized_types_to_string<boost::array<unsigned char, 1> >();
|
||||
test_optimized_types_to_string<boost::array<unsigned char, 5> >();
|
||||
test_optimized_types_to_string<boost::array<signed char, 1> >();
|
||||
test_optimized_types_to_string<boost::array<signed char, 5> >();
|
||||
test_optimized_types_to_string<boost::iterator_range<char*> >();
|
||||
test_optimized_types_to_string<boost::iterator_range<unsigned char*> >();
|
||||
test_optimized_types_to_string<boost::iterator_range<signed char*> >();
|
||||
|
||||
test_optimized_types_to_string_const<boost::array<const char, 1> >();
|
||||
test_optimized_types_to_string_const<boost::array<const char, 5> >();
|
||||
test_optimized_types_to_string_const<boost::array<const unsigned char, 1> >();
|
||||
test_optimized_types_to_string_const<boost::array<const unsigned char, 5> >();
|
||||
test_optimized_types_to_string_const<boost::array<const signed char, 1> >();
|
||||
test_optimized_types_to_string_const<boost::array<const signed char, 5> >();
|
||||
test_optimized_types_to_string_const<boost::iterator_range<const char*> >();
|
||||
test_optimized_types_to_string_const<boost::iterator_range<const unsigned char*> >();
|
||||
test_optimized_types_to_string_const<boost::iterator_range<const signed char*> >();
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
test_optimized_types_to_string<std::array<char, 1> >();
|
||||
test_optimized_types_to_string<std::array<char, 5> >();
|
||||
test_optimized_types_to_string<std::array<unsigned char, 1> >();
|
||||
test_optimized_types_to_string<std::array<unsigned char, 5> >();
|
||||
test_optimized_types_to_string<std::array<signed char, 1> >();
|
||||
test_optimized_types_to_string<std::array<signed char, 5> >();
|
||||
|
||||
test_optimized_types_to_string_const<std::array<const char, 1> >();
|
||||
test_optimized_types_to_string_const<std::array<const char, 5> >();
|
||||
test_optimized_types_to_string_const<std::array<const unsigned char, 1> >();
|
||||
test_optimized_types_to_string_const<std::array<const unsigned char, 5> >();
|
||||
test_optimized_types_to_string_const<std::array<const signed char, 1> >();
|
||||
test_optimized_types_to_string_const<std::array<const signed char, 5> >();
|
||||
|
||||
test_optimized_types_to_wstring<std::array<wchar_t, 42>>();
|
||||
test_optimized_types_to_wstring<std::array<const wchar_t, 42>>();
|
||||
#endif
|
||||
|
||||
test_optimized_types_to_wstring<wchar_t*>();
|
||||
test_optimized_types_to_wstring<const wchar_t*>();
|
||||
test_optimized_types_to_wstring<boost::iterator_range<const wchar_t*>>();
|
||||
test_optimized_types_to_wstring<boost::iterator_range<wchar_t*>>();
|
||||
|
||||
test_optimized_types_to_string<boost::string_view>();
|
||||
test_optimized_types_to_wstring<boost::basic_string_view<wchar_t>>();
|
||||
|
||||
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
|
||||
test_optimized_types_to_string<std::string_view>();
|
||||
test_optimized_types_to_wstring<std::basic_string_view<wchar_t>>();
|
||||
#endif
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_metafunctions();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@@ -1,49 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2012-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
|
||||
#include <boost/utility/string_view.hpp>
|
||||
|
||||
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
|
||||
#include <string_view>
|
||||
#endif
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
|
||||
template <class StringView>
|
||||
void test_string_view_conversion() {
|
||||
using boost::lexical_cast;
|
||||
|
||||
StringView sw = "1";
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(sw), "1");
|
||||
BOOST_TEST_EQ(lexical_cast<int>(sw), 1);
|
||||
|
||||
sw = StringView("a\0b", 3);
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(sw), std::string("a\0b", 3));
|
||||
|
||||
sw = StringView("a\0b", 4);
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(sw), std::string("a\0b", 4));
|
||||
|
||||
sw = StringView("\0a\0", 3);
|
||||
BOOST_TEST_EQ(lexical_cast<std::string>(sw), std::string("\0a\0", 3));
|
||||
}
|
||||
|
||||
int main() {
|
||||
test_string_view_conversion<boost::string_view>();
|
||||
|
||||
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
|
||||
test_string_view_conversion<std::string_view>();
|
||||
#endif
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
// // Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2013-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::lexical_cast<char*>("Hello");
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -1,75 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2014-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/lexical_cast/try_lexical_convert.hpp>
|
||||
|
||||
using namespace boost::conversion;
|
||||
|
||||
void try_uncommon_cases()
|
||||
{
|
||||
std::string sres;
|
||||
const bool res1 = try_lexical_convert(std::string("Test string"), sres);
|
||||
BOOST_TEST(res1);
|
||||
BOOST_TEST_EQ(sres, "Test string");
|
||||
|
||||
volatile int vires;
|
||||
const bool res2 = try_lexical_convert(100, vires);
|
||||
BOOST_TEST(res2);
|
||||
BOOST_TEST_EQ(vires, 100);
|
||||
|
||||
const bool res3 = try_lexical_convert("Test string", sres);
|
||||
BOOST_TEST(res3);
|
||||
BOOST_TEST_EQ(sres, "Test string");
|
||||
|
||||
const bool res4 = try_lexical_convert("Test string", sizeof("Test string") - 1, sres);
|
||||
BOOST_TEST(res4);
|
||||
BOOST_TEST_EQ(sres, "Test string");
|
||||
|
||||
int ires;
|
||||
BOOST_TEST(!try_lexical_convert("Test string", ires));
|
||||
BOOST_TEST(!try_lexical_convert(1.1, ires));
|
||||
BOOST_TEST(!try_lexical_convert(-1.9, ires));
|
||||
BOOST_TEST(!try_lexical_convert("1.1", ires));
|
||||
BOOST_TEST(!try_lexical_convert("1000000000000000000000000000000000000000", ires));
|
||||
}
|
||||
|
||||
|
||||
void try_common_cases()
|
||||
{
|
||||
int ires = 0;
|
||||
const bool res1 = try_lexical_convert(std::string("100"), ires);
|
||||
BOOST_TEST(res1);
|
||||
BOOST_TEST_EQ(ires, 100);
|
||||
|
||||
ires = 0;
|
||||
const bool res2 = try_lexical_convert("-100", ires);
|
||||
BOOST_TEST(res2);
|
||||
BOOST_TEST_EQ(ires, -100);
|
||||
|
||||
float fres = 1.0f;
|
||||
const bool res3 = try_lexical_convert("0.0", fres);
|
||||
BOOST_TEST(res3);
|
||||
BOOST_TEST_EQ(fres, 0.0f);
|
||||
|
||||
fres = 1.0f;
|
||||
const bool res4 = try_lexical_convert("0.0", sizeof("0.0") - 1, fres);
|
||||
BOOST_TEST(res4);
|
||||
BOOST_TEST_EQ(fres, 0.0f);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
try_uncommon_cases();
|
||||
try_common_cases();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/date_time/gregorian/gregorian.hpp>
|
||||
#include <boost/date_time/posix_time/posix_time.hpp>
|
||||
|
||||
void parseDate()
|
||||
{
|
||||
std::locale locale;
|
||||
boost::date_time::format_date_parser<boost::gregorian::date, wchar_t> parser(L"", locale);
|
||||
boost::date_time::special_values_parser<boost::gregorian::date, wchar_t> svp;
|
||||
|
||||
boost::gregorian::date date = parser.parse_date(L"", L"", svp);
|
||||
(void)date;
|
||||
}
|
||||
|
||||
|
||||
int main()
|
||||
{
|
||||
parseDate();
|
||||
return ::boost::lexical_cast<int>(L"1000") == 1000;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,53 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
void test_typedefed_wchar_t(unsigned short) // wchar_t is a typedef for unsigned short
|
||||
{
|
||||
BOOST_TEST(boost::lexical_cast<int>(L'A') == 65);
|
||||
BOOST_TEST(boost::lexical_cast<int>(L'B') == 66);
|
||||
|
||||
BOOST_TEST(boost::lexical_cast<wchar_t>(L"65") == 65);
|
||||
BOOST_TEST(boost::lexical_cast<wchar_t>(L"66") == 66);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_typedefed_wchar_t(T)
|
||||
{
|
||||
BOOST_TEST(1);
|
||||
}
|
||||
|
||||
void test_typedefed_wchar_t_runtime()
|
||||
{
|
||||
test_typedefed_wchar_t(L'0');
|
||||
}
|
||||
|
||||
void test_unsigned_short_to_wstring()
|
||||
{
|
||||
// Test case from https://github.com/boostorg/lexical_cast/issues/89
|
||||
unsigned short number = 4550;
|
||||
|
||||
auto res1 = boost::lexical_cast<std::wstring>(number);
|
||||
BOOST_TEST(res1 == L"4550");
|
||||
|
||||
auto res2 = boost::lexical_cast<std::string>(number);
|
||||
BOOST_TEST_EQ(res2, "4550");
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_typedefed_wchar_t_runtime();
|
||||
test_unsigned_short_to_wstring();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Alexander Nasonov, 2007.
|
||||
//
|
||||
// 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).
|
||||
//
|
||||
// This tests now must pass on vc8, because lexical_cast
|
||||
// implementation has changed and it does not use stringstream for casts
|
||||
// to integral types
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(disable: 4127) // conditional expression is constant
|
||||
#endif
|
||||
|
||||
using namespace boost;
|
||||
|
||||
// See also test_conversion_from_string_to_integral(CharT)
|
||||
// in libs/conversion/lexical_cast_test.cpp
|
||||
template<class T, class CharT>
|
||||
void test_too_long_number(CharT zero)
|
||||
{
|
||||
typedef std::numeric_limits<T> limits;
|
||||
|
||||
std::basic_string<CharT> s;
|
||||
|
||||
std::basic_ostringstream<CharT> o;
|
||||
o << (limits::max)() << zero;
|
||||
s = o.str();
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(s), bad_lexical_cast);
|
||||
s[s.size()-1] += static_cast<CharT>(9); // '0' -> '9'
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(s), bad_lexical_cast);
|
||||
|
||||
if (limits::is_signed)
|
||||
{
|
||||
std::basic_ostringstream<CharT> o2;
|
||||
o2 << (limits::min)() << zero;
|
||||
s = o2.str();
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(s), bad_lexical_cast);
|
||||
s[s.size()-1] += static_cast<CharT>(9); // '0' -> '9'
|
||||
BOOST_TEST_THROWS(lexical_cast<T>(s), bad_lexical_cast);
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_too_long_number<boost::intmax_t>('0');
|
||||
test_too_long_number<boost::uintmax_t>('0');
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T)
|
||||
test_too_long_number<boost::intmax_t>(L'0');
|
||||
test_too_long_number<boost::uintmax_t>(L'0');
|
||||
#endif
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,131 +0,0 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2011-2026.
|
||||
//
|
||||
// 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).
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#if defined(BOOST_USE_MODULES)
|
||||
#undef BOOST_USE_MODULES
|
||||
#endif
|
||||
#include <boost/lexical_cast/detail/lcast_char_constants.hpp>
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
|
||||
#define BOOST_LCAST_NO_WCHAR_T
|
||||
#endif
|
||||
|
||||
template <class CharT>
|
||||
void test_impl(const CharT* wc_arr)
|
||||
{
|
||||
typedef CharT wide_char;
|
||||
typedef std::basic_string<CharT> wide_string;
|
||||
const char c_arr[] = "Test array of chars";
|
||||
const unsigned char uc_arr[] = "Test array of chars";
|
||||
const signed char sc_arr[] = "Test array of chars";
|
||||
|
||||
// Following tests depend on realization of std::locale
|
||||
// and pass for popular compilers and STL realizations
|
||||
BOOST_TEST(boost::lexical_cast<wide_char>(c_arr[0]) == wc_arr[0]);
|
||||
BOOST_TEST(boost::lexical_cast<wide_string>(c_arr) == wide_string(wc_arr));
|
||||
|
||||
BOOST_TEST(boost::lexical_cast<wide_string>(sc_arr) == wide_string(wc_arr) );
|
||||
BOOST_TEST(boost::lexical_cast<wide_string>(uc_arr) == wide_string(wc_arr) );
|
||||
|
||||
BOOST_TEST(boost::lexical_cast<wide_char>(uc_arr[0]) == wc_arr[0]);
|
||||
BOOST_TEST(boost::lexical_cast<wide_char>(sc_arr[0]) == wc_arr[0]);
|
||||
}
|
||||
|
||||
|
||||
void test_char_types_conversions_wchar_t()
|
||||
{
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
test_impl(L"Test array of chars");
|
||||
wchar_t c = boost::detail::lcast_char_constants<wchar_t>::zero;
|
||||
BOOST_TEST(L'0' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<wchar_t>::minus;
|
||||
BOOST_TEST(L'-' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<wchar_t>::plus;
|
||||
BOOST_TEST(L'+' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<wchar_t>::lowercase_e;
|
||||
BOOST_TEST(L'e' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<wchar_t>::capital_e;
|
||||
BOOST_TEST(L'E' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<wchar_t>::c_decimal_separator;
|
||||
BOOST_TEST(L'.' == c);
|
||||
#endif
|
||||
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
void test_char_types_conversions_char16_t()
|
||||
{
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
test_impl(u"Test array of chars");
|
||||
char16_t c = boost::detail::lcast_char_constants<char16_t>::zero;
|
||||
BOOST_TEST(u'0' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<char16_t>::minus;
|
||||
BOOST_TEST(u'-' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<char16_t>::plus;
|
||||
BOOST_TEST(u'+' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<char16_t>::lowercase_e;
|
||||
BOOST_TEST(u'e' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<char16_t>::capital_e;
|
||||
BOOST_TEST(u'E' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<char16_t>::c_decimal_separator;
|
||||
BOOST_TEST(u'.' == c);
|
||||
#endif
|
||||
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
void test_char_types_conversions_char32_t()
|
||||
{
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
test_impl(U"Test array of chars");
|
||||
char32_t c = boost::detail::lcast_char_constants<char32_t>::zero;
|
||||
BOOST_TEST(U'0' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<char32_t>::minus;
|
||||
BOOST_TEST(U'-' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<char32_t>::plus;
|
||||
BOOST_TEST(U'+' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<char32_t>::lowercase_e;
|
||||
BOOST_TEST(U'e' == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<char32_t>::capital_e;
|
||||
BOOST_TEST(U'E', == c);
|
||||
|
||||
c = boost::detail::lcast_char_constants<char32_t>::c_decimal_separator;
|
||||
BOOST_TEST(U'.' == c);
|
||||
#endif
|
||||
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_char_types_conversions_wchar_t();
|
||||
test_char_types_conversions_char16_t();
|
||||
test_char_types_conversions_char32_t();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
Reference in New Issue
Block a user