diff options
Diffstat (limited to 'src/boost/libs/assign')
21 files changed, 1984 insertions, 0 deletions
diff --git a/src/boost/libs/assign/Jamfile b/src/boost/libs/assign/Jamfile new file mode 100644 index 000000000..0914294b5 --- /dev/null +++ b/src/boost/libs/assign/Jamfile @@ -0,0 +1,10 @@ +# Boost.Assign Library Jamfile +# +# Copyright (c) 2018 James E. King III +# +# 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) + +# please order by name to ease maintenance +build-project test ; diff --git a/src/boost/libs/assign/LICENSE b/src/boost/libs/assign/LICENSE new file mode 100644 index 000000000..36b7cd93c --- /dev/null +++ b/src/boost/libs/assign/LICENSE @@ -0,0 +1,23 @@ +Boost Software License - Version 1.0 - August 17th, 2003 + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/src/boost/libs/assign/README.md b/src/boost/libs/assign/README.md new file mode 100644 index 000000000..2356845b8 --- /dev/null +++ b/src/boost/libs/assign/README.md @@ -0,0 +1,33 @@ +Assign, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), makes it easy to fill containers with data by overloading operator() and operator()(). + +### License + +Distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt). + +### Properties + +* C++03 +* Header Only + +### Build Status + +Branch | Travis | Appveyor | Coverity Scan | codecov.io | Deps | Docs | Tests | +:-------------: | ------ | -------- | ------------- | ---------- | ---- | ---- | ----- | +[`master`](https://github.com/boostorg/assign/tree/master) | [](https://travis-ci.org/boostorg/assign) | [](https://ci.appveyor.com/project/jeking3/assign-4i3tt/branch/master) | [](https://scan.coverity.com/projects/boostorg-assign) | [](https://codecov.io/gh/boostorg/assign/branch/master)| [](https://pdimov.github.io/boostdep-report/master/assign.html) | [](http://www.boost.org/doc/libs/master/doc/html/assign.html) | [](http://www.boost.org/development/tests/master/developer/assign.html) +[`develop`](https://github.com/boostorg/assign/tree/develop) | [](https://travis-ci.org/boostorg/assign) | [](https://ci.appveyor.com/project/jeking3/assign-4i3tt/branch/develop) | [](https://scan.coverity.com/projects/boostorg-assign) | [](https://codecov.io/gh/boostorg/assign/branch/develop) | [](https://pdimov.github.io/boostdep-report/develop/assign.html) | [](http://www.boost.org/doc/libs/develop/doc/html/assign.html) | [](http://www.boost.org/development/tests/develop/developer/assign.html) + +### Directories + +| Name | Purpose | +| ----------- | ------------------------------ | +| `doc` | documentation | +| `include` | headers | +| `test` | unit tests | + +### More information + +* [Ask questions](http://stackoverflow.com/questions/ask?tags=c%2B%2B,boost,boost-assign) +* [Report bugs](https://github.com/boostorg/assign/issues): Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well. +* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt). +* Discussions about the library are held on the [Boost developers mailing list](http://www.boost.org/community/groups.html#main). Be sure to read the [discussion policy](http://www.boost.org/community/policy.html) before posting and add the `[assign]` tag at the beginning of the subject line. + diff --git a/src/boost/libs/assign/index.html b/src/boost/libs/assign/index.html new file mode 100644 index 000000000..001f41083 --- /dev/null +++ b/src/boost/libs/assign/index.html @@ -0,0 +1,24 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN"> + +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> +<meta http-equiv="refresh" content="0; URL=doc/index.html"> +<title>Boost.Assign Documentation</title> +<link rel="stylesheet" href="doc/style.css" type="text/css"> +</head> + +<body> +Automatic redirection failed, please go to +<a href="doc/index.html">doc/index.html</a> + <p> + Copyright © 2003-2007 Thorsten Ottosen. Use, modification and distribution is + subject to the Boost Software License, Version 1.0 (see LICENSE_1_0.txt) + (See accompanying +file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy +at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>) + </p> +</body> +</html></body> + +</html> diff --git a/src/boost/libs/assign/meta/libraries.json b/src/boost/libs/assign/meta/libraries.json new file mode 100644 index 000000000..a78e091bb --- /dev/null +++ b/src/boost/libs/assign/meta/libraries.json @@ -0,0 +1,14 @@ +{ + "key": "assign", + "name": "Assign", + "authors": [ + "Thorsten Ottosen" + ], + "description": "Filling containers with constant or generated data has never been easier.", + "category": [ + "IO" + ], + "maintainers": [ + "Thorsten Ottosen <nesotto -at- cs.auc.dk>" + ] +} diff --git a/src/boost/libs/assign/test/Jamfile.v2 b/src/boost/libs/assign/test/Jamfile.v2 new file mode 100644 index 000000000..7172745ed --- /dev/null +++ b/src/boost/libs/assign/test/Jamfile.v2 @@ -0,0 +1,75 @@ +# Boost.Assign library +# +# Copyright Thorsten Ottosen 2003-2005. Use, modification and +# distribution is 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) +# +# For more information, see http://www.boost.org/libs/assign/ +# + +import path ; +import regex ; + +rule assign-test ( name ) +{ + return [ + run $(name).cpp /boost/test//boost_unit_test_framework/<link>static ] + ; +} + +# this rule enumerates through all the headers and ensures +# that inclusion of the header by itself is sufficient to +# compile successfully, proving the header does not depend +# on any other headers to be included first - adapted from +# logic in the winapi test bjam script +rule test_headers +{ + local all_rules = ; + local file ; + local headers_path = [ path.make $(BOOST_ROOT)/libs/assign/include/boost/assign ] ; + for file in [ path.glob-tree $(headers_path) : *.hpp : assign ] + { + local rel_file = [ path.relative-to $(headers_path) $(file) ] ; + # Note: The test name starts with '~' in order to group these tests in the test report table, preferably at the end. + # All '/' are replaced with '-' because apparently test scripts have a problem with test names containing slashes. + local test_name = [ regex.replace $(rel_file) "/" "-" ] ; + local decl_test_name = ~hdr-decl-$(test_name) ; + # ECHO $(rel_file) ; + all_rules += [ compile compile/decl_header.cpp : <define>"BOOST_ASSIGN_TEST_HEADER=$(rel_file)" <dependency>$(file) : $(decl_test_name) ] ; + } + + local tests_path = [ path.make $(BOOST_ROOT)/libs/assign/test/compile-fail ] ; + for file in [ path.glob-tree $(tests_path) : *.cpp ] + { + local rel_file = [ path.relative-to $(tests_path) $(file) ] ; + local test_name = [ regex.replace [ regex.replace $(rel_file) "/" "-" ] ".cpp" "" ] ; + local decl_test_name = cf-$(test_name) ; + # ECHO $(rel_file) ; + all_rules += [ compile-fail $(file) : : $(decl_test_name) ] ; + } + + # ECHO All rules: $(all_rules) ; + return $(all_rules) ; +} + + +test-suite assign : + [ test_headers ] + [ assign-test basic ] + [ assign-test std ] + [ assign-test array ] + [ assign-test list_of ] + [ assign-test ptr_list_of ] + [ assign-test static_list_of ] + [ assign-test tuple_list_of ] + [ assign-test list_inserter ] + [ assign-test ptr_list_inserter ] + [ assign-test ptr_map_inserter ] + [ assign-test list_of_workaround ] + [ assign-test email_example ] + [ assign-test my_vector_example ] + [ assign-test multi_index_container ] + ; + + diff --git a/src/boost/libs/assign/test/array.cpp b/src/boost/libs/assign/test/array.cpp new file mode 100644 index 000000000..1723f612a --- /dev/null +++ b/src/boost/libs/assign/test/array.cpp @@ -0,0 +1,107 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x564) ) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + +#include <boost/assign/list_of.hpp> +#include <boost/array.hpp> +#include <boost/test/test_tools.hpp> +#include <iostream> +#include <algorithm> +#include <iterator> + +#ifndef BOOST_NO_CXX11_HDR_ARRAY +#include <array> + +void check_std_array() +{ + using namespace boost::assign; + + typedef std::array<float,6> Array; + + Array a = list_of(1)(2)(3)(4)(5)(6); + + BOOST_CHECK_EQUAL( a[0], 1 ); + BOOST_CHECK_EQUAL( a[5], 6 ); + // last element is implicitly 0 + Array a2 = list_of(1)(2)(3)(4)(5); + BOOST_CHECK_EQUAL( a2[5], 0 ); + // two last elements are implicitly + a2 = list_of(1)(2)(3)(4); + BOOST_CHECK_EQUAL( a2[4], 0 ); + BOOST_CHECK_EQUAL( a2[5], 0 ); + // too many arguments + BOOST_CHECK_THROW( a2 = list_of(1)(2)(3)(4)(5)(6)(7), assignment_exception ); +} + +#endif + +void check_array() +{ + using namespace boost::assign; + + typedef boost::array<float,6> Array; + + +#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + Array a = list_of(1)(2)(3)(4)(5)(6).to_array(a); +#else + Array a = list_of(1)(2)(3)(4)(5)(6); +#endif + + BOOST_CHECK_EQUAL( a[0], 1 ); + BOOST_CHECK_EQUAL( a[5], 6 ); + // last element is implicitly 0 +#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + Array a2 = list_of(1)(2)(3)(4)(5).to_array(a2); +#else + Array a2 = list_of(1)(2)(3)(4)(5); +#endif + BOOST_CHECK_EQUAL( a2[5], 0 ); + // two last elements are implicitly +#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + a2 = list_of(1))(2)(3)(4).to_array(a2); +#else + a2 = list_of(1)(2)(3)(4); +#endif + BOOST_CHECK_EQUAL( a2[4], 0 ); + BOOST_CHECK_EQUAL( a2[5], 0 ); + // too many arguments +#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + + BOOST_CHECK_THROW( a2 = list_of(1)(2)(3)(4)(5)(6)(6).to_array(a2), + assignment_exception ); +#else + BOOST_CHECK_THROW( a2 = list_of(1)(2)(3)(4)(5)(6)(7), assignment_exception ); +#endif +} + + +#include <boost/test/unit_test.hpp> +using boost::unit_test::test_suite; + + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); + + test->add( BOOST_TEST_CASE( &check_array ) ); +#ifndef BOOST_NO_CXX11_HDR_ARRAY + test->add( BOOST_TEST_CASE( &check_std_array ) ); +#endif + + return test; +} + diff --git a/src/boost/libs/assign/test/basic.cpp b/src/boost/libs/assign/test/basic.cpp new file mode 100644 index 000000000..077823d64 --- /dev/null +++ b/src/boost/libs/assign/test/basic.cpp @@ -0,0 +1,47 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + +#include <boost/assign/std/vector.hpp> +#include <boost/assign/std/map.hpp> +#include <string> + + +using namespace boost::assign; + +void check_basic_usage() +{ + std::vector<int> v; + v += 1,2,3,4,5,6,7,8,9; + push_back( v )(10)(11); + std::map<std::string,int> m; + insert( m )( "foo", 1 )( "bar", 2 ); +} + + + +#include <boost/test/unit_test.hpp> +using boost::unit_test::test_suite; + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "Assign Test Suite" ); + + test->add( BOOST_TEST_CASE( &check_basic_usage ) ); + + return test; +} + diff --git a/src/boost/libs/assign/test/compile/decl_header.cpp b/src/boost/libs/assign/test/compile/decl_header.cpp new file mode 100644 index 000000000..9f75774b5 --- /dev/null +++ b/src/boost/libs/assign/test/compile/decl_header.cpp @@ -0,0 +1,24 @@ +/* + * Copyright Andrey Semashev 2015. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ +/*! + * \file decl_header.cpp + * \author Andrey Semashev + * \date 21.06.2015 + * + * \brief This file contains a test boilerplate for checking that every + * public header is self-contained and does not have any missing + * #includes. + */ + +#define BOOST_ASSIGN_TEST_INCLUDE_HEADER() <boost/assign/BOOST_ASSIGN_TEST_HEADER> + +#include BOOST_ASSIGN_TEST_INCLUDE_HEADER() + +int main(int, char*[]) +{ + return 0; +} diff --git a/src/boost/libs/assign/test/email_example.cpp b/src/boost/libs/assign/test/email_example.cpp new file mode 100644 index 000000000..3e8b98ba0 --- /dev/null +++ b/src/boost/libs/assign/test/email_example.cpp @@ -0,0 +1,155 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + +#include <boost/assign/list_inserter.hpp> +#include <boost/test/test_tools.hpp> +#include <boost/function.hpp> +#include <boost/bind.hpp> +#include <vector> +#include <map> + +namespace ba = boost::assign; + +class email +{ +public: + enum address_option + { + check_addr_book, + dont_check_addr_book + }; + + typedef std::pair<std::string,address_option> bcc_type; + typedef std::vector< bcc_type > bcc_map; + typedef std::map<std::string,address_option> address_map; + + +private: + + mutable address_map cc_list; + mutable address_map to_list; + bcc_map bcc_list; + + struct add_to_map + { + address_map& m; + + add_to_map( address_map& m ) : m(m) + {} + + void operator()( const std::string& name, address_option ao ) + { + m[ name ] = ao; + } + + void operator()( const std::string& name ) + { + m[ name ] = check_addr_book; + } + }; + + struct add_to_vector + { + bcc_map& m; + + add_to_vector( bcc_map& m ) : m(m) + {} + + void operator()( const bcc_type& r ) + { + m.push_back( r ); + } + }; + +public: + + ba::list_inserter< add_to_map > + add_cc( std::string name, address_option ao ) + { + return ba::make_list_inserter( add_to_map( cc_list ) )( name, ao ); + } + + ba::list_inserter< add_to_map > + add_to( const std::string& name ) + { + return ba::make_list_inserter( add_to_map( to_list ) )( name ); + } + + ba::list_inserter< add_to_vector, bcc_type > + add_bcc( const bcc_type& bcc ) + { + return ba::make_list_inserter( add_to_vector( bcc_list ) )( bcc ); + } + + address_option + cc_at( const std::string& name ) const + { + return cc_list[ name ]; + } + + address_option + to_at( const std::string& name ) const + { + return to_list[ name ]; + } + + address_option + bcc_at( unsigned index ) const + { + return bcc_list.at( index ).second; + } +}; + + + +void check_list_inserter() +{ + using namespace boost::assign; + + email e; + e.add_cc( "franz", email::dont_check_addr_book ) + ( "hanz", email::check_addr_book ) + ( "betty", email::dont_check_addr_book ); + BOOST_CHECK_EQUAL( e.cc_at( "franz" ), email::dont_check_addr_book ); + BOOST_CHECK_EQUAL( e.cc_at( "hanz" ), email::check_addr_book ); + BOOST_CHECK_EQUAL( e.cc_at( "betty" ), email::dont_check_addr_book ); + + e.add_to( "betsy" )( "peter" ); + BOOST_CHECK_EQUAL( e.cc_at( "betsy" ), email::check_addr_book ); + BOOST_CHECK_EQUAL( e.cc_at( "peter" ), email::check_addr_book ); + + e.add_bcc( email::bcc_type( "Mr. Foo", email::check_addr_book ) ) + ( "Mr. Bar", email::dont_check_addr_book ); + BOOST_CHECK_EQUAL( e.bcc_at( 0 ), email::check_addr_book ); + BOOST_CHECK_EQUAL( e.bcc_at( 1 ), email::dont_check_addr_book ); + +} + + +#include <boost/test/unit_test.hpp> +using boost::unit_test::test_suite; + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); + + test->add( BOOST_TEST_CASE( &check_list_inserter ) ); + + return test; +} + diff --git a/src/boost/libs/assign/test/list_inserter.cpp b/src/boost/libs/assign/test/list_inserter.cpp new file mode 100644 index 000000000..8d904764b --- /dev/null +++ b/src/boost/libs/assign/test/list_inserter.cpp @@ -0,0 +1,158 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + + +#include <boost/assign/list_inserter.hpp> +#include <boost/assign/list_of.hpp> +#include <boost/test/test_tools.hpp> +#include <boost/array.hpp> +#include <boost/function.hpp> +#include <boost/bind.hpp> +#include <boost/functional.hpp> +#include <iostream> +#include <vector> +#include <map> +#include <string> +#include <utility> +#include <stdexcept> +#include <cstdlib> + + +namespace ba = boost::assign; + +void function_ptr( int ) +{ + // do nothing +} + +struct functor +{ + template< class T > + void operator()( T ) const + { + // do nothing + } +}; + + + +void check_list_inserter() +{ + using namespace std; + using namespace boost; + using namespace boost::assign; + vector<int> v; + + // + // @note: cast only necessary on CodeWarrior + // + make_list_inserter( (void (*)(int))&function_ptr )( 5 ),3; + make_list_inserter( functor() )( 4 ),2; + + typedef void (vector<int>::* push_back_t)(const int&); + push_back_t push_back_func = &vector<int>::push_back; + make_list_inserter( boost::bind( push_back_func, &v, _1 ) )( 6 ),4; + + BOOST_CHECK_EQUAL( v.size(), 2u ); + BOOST_CHECK_EQUAL( v[0], 6 ); + BOOST_CHECK_EQUAL( v[1], 4 ); + + push_back( v ) = 1,2,3,4,5; + BOOST_CHECK_EQUAL( v.size(), 7u ); + BOOST_CHECK_EQUAL( v[6], 5 ); + + push_back( v )(6).repeat( 10, 7 )(8); + BOOST_CHECK_EQUAL( v.size(), 19u ); + BOOST_CHECK_EQUAL( v[18], 8 ); + BOOST_CHECK_EQUAL( v[8], 7 ); + BOOST_CHECK_EQUAL( v[16], 7 ); + +#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1200) + push_back( v ) = repeat_fun( 10, &rand ); +#else + push_back( v ).repeat_fun( 10, &rand ); +#endif + + BOOST_CHECK_EQUAL( v.size(), 29u ); + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580 ) + push_back( v )(1).repeat( 10, 2 )(3); +#else + push_back( v ) = 1,repeat( 10, 2 ),3; +#endif + BOOST_CHECK_EQUAL( v.size(), 41u ); + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580 ) + push_back( v )(1).repeat_fun( 10, &rand )(2); +#else + push_back( v ) = 1,repeat_fun( 10, &rand ),2; +#endif + + BOOST_CHECK_EQUAL( v.size(), 53u ); + + typedef map<string,int> map_t; + typedef map_t::value_type V; + map_t m; + + make_list_inserter( assign_detail::call_insert< map_t >( m ) ) + ( V("bar",3) )( V("foo", 2) ); + BOOST_CHECK_EQUAL( m.size(), 2u ); + BOOST_CHECK_EQUAL( m["foo"], 2 ); + + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \ + || BOOST_WORKAROUND(BOOST_MSVC, <=1300) \ + || BOOST_WORKAROUND(BOOST_MSVC, ==1700) \ + || !defined( BOOST_NO_CXX11_HDR_INITIALIZER_LIST ) +#else + + typedef vector<int> score_type; + typedef map<string,score_type> team_score_map; + typedef std::pair<string,score_type> score_pair; + team_score_map team_score; + insert( team_score )( "Team Foo", list_of(1)(1)(0) ) + ( "Team Bar", list_of(0)(0)(0) ) + ( "Team FooBar", list_of(0)(0)(1) ); + BOOST_CHECK_EQUAL( team_score.size(), 3u ); + BOOST_CHECK_EQUAL( team_score[ "Team Foo" ][1], 1 ); + BOOST_CHECK_EQUAL( team_score[ "Team Bar" ][0], 0 ); + + team_score = list_of< score_pair > + ( "Team Foo", list_of(1)(1)(0) ) + ( "Team Bar", list_of(0)(0)(0) ) + ( "Team FooBar", list_of(0)(0)(1) ); + BOOST_CHECK_EQUAL( team_score.size(), 3u ); + BOOST_CHECK_EQUAL( team_score[ "Team Foo" ][1], 1 ); + BOOST_CHECK_EQUAL( team_score[ "Team Bar" ][0], 0 ); +#endif + +} + + + +#include <boost/test/unit_test.hpp> +using boost::unit_test::test_suite; + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); + + test->add( BOOST_TEST_CASE( &check_list_inserter ) ); + + return test; +} + diff --git a/src/boost/libs/assign/test/list_of.cpp b/src/boost/libs/assign/test/list_of.cpp new file mode 100644 index 000000000..b5bc0ed09 --- /dev/null +++ b/src/boost/libs/assign/test/list_of.cpp @@ -0,0 +1,309 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + +#include <boost/assign/list_of.hpp> +#include <boost/test/test_tools.hpp> +#include <boost/array.hpp> +#include <algorithm> +#include <vector> +#include <list> +#include <deque> +#include <set> +#include <map> +#include <stack> +#include <string> +#include <cstdlib> +#include <complex> + +struct nothing +{ + template< class T > + void operator()( T ) + { } + +}; + +template< class Range > +void for_each( const Range& r ) +{ + std::for_each( r.begin(), r.end(), nothing() ); +} + +namespace ba = boost::assign; + +template< class C > +void test_sequence_list_of_string() +{ +#if BOOST_WORKAROUND(BOOST_MSVC, <=1300) + const C c = ba::list_of( "foo" )( "bar" ).to_container( c ); +#else + const C c = ba::list_of( "foo" )( "bar" ); +#endif + BOOST_CHECK_EQUAL( c.size(), 2u ); +} + +struct parameter_list +{ + int val; + + template< class T > + parameter_list( T ) + : val(0) + { } + + template< class T > + parameter_list( const T&, int ) + : val(1) + { } +}; + +template< class C > +void test_sequence_list_of_int() +{ + using namespace std; +#if BOOST_WORKAROUND(BOOST_MSVC, <=1300) + + const C c = ba::list_of<int>(1)(2)(3)(4).to_container( c ); + const C c2 = ba::list_of(1)(2)(3)(4).to_container( c2 ); + BOOST_CHECK_EQUAL( c.size(), 4u ); + BOOST_CHECK_EQUAL( c2.size(), 4u ); + C c3 = ba::list_of(1).repeat( 1, 2 )(3).to_container( c3 ); + BOOST_CHECK_EQUAL( c3.size(), 3u ); + + c3 = ba::list_of(1).repeat_fun( 10, &rand )(2)(3).to_container( c3 ); + BOOST_CHECK_EQUAL( c3.size(), 13u ); + +#else + + const C c = ba::list_of<int>(1)(2)(3)(4); + const C c2 = ba::list_of(1)(2)(3)(4); + BOOST_CHECK_EQUAL( c.size(), 4u ); + BOOST_CHECK_EQUAL( c2.size(), 4u ); + C c3 = ba::list_of(1).repeat( 1, 2 )(3); + BOOST_CHECK_EQUAL( c3.size(), 3u ); + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + // BCB fails to use operator=() directly, + // it must be worked around using e.g. auxiliary variable + C aux = ba::list_of(1).repeat_fun( 10, &rand )(2)(3); + BOOST_CHECK_EQUAL( aux.size(), 13u ); + c3 = aux; + BOOST_CHECK_EQUAL( c3.size(), 13u ); +#elif defined( BOOST_NO_CXX11_HDR_INITIALIZER_LIST ) + c3 = ba::list_of(1).repeat_fun( 10, &rand )(2)(3); + BOOST_CHECK_EQUAL( c3.size(), 13u ); +#endif + +#if !defined( BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS ) + C c4; + c4 = ba::list_of(1)(2)(3)(4); + BOOST_CHECK_EQUAL( c4.size(), 4u ); + C c5(ba::list_of(1)(2)(3)(4)(5)); + BOOST_CHECK_EQUAL( c5.size(), 5u ); +#endif + +#endif + + parameter_list p( ba::list_of(1)(2), 3u ); + BOOST_CHECK_EQUAL( p.val, 1 ); + +} + +template< class C > +void test_map_list_of() +{ + const C c = ba::list_of< std::pair<std::string,int> >( "foo", 1 )( "bar", 2 )( "buh", 3 )( "bah", 4 ); + BOOST_CHECK_EQUAL( c.size(), 4u ); + const C c2 = ba::map_list_of( "foo", 1 )( "bar", 2 )( "buh", 3 )( "bah", 4 ); + BOOST_CHECK_EQUAL( c2.size(), 4u ); +} + +void test_vector_matrix() +{ + using namespace boost; + using namespace boost::assign; + using namespace std; + using boost::array; + +#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) || BOOST_WORKAROUND(BOOST_MSVC, <=1300) +#else + + const int sz = 3; + typedef array<int,sz> row3; + typedef array<row3,sz> matrix3x3; + + + matrix3x3 m = list_of( list_of(1)(2)(3) ) + ( list_of(4)(5)(6) ) + ( list_of(7)(8)(9) ); + + for( int i = 0; i != sz; ++i ) + for( int j = 0; j != sz; ++j ) + BOOST_CHECK_EQUAL( m[i][j], i*sz + j + 1 ); + + typedef vector<int> row; + typedef vector<row> matrix; + + // + // note: some libraries need a little help + // with the conversion, hence the 'row' template parameter. + // + matrix m2 = list_of< row >( list_of(1)(2)(3) ) + ( list_of(4)(5) ) + ( list_of(6) ); + + for( int i = 0; i != sz; ++i ) + for( int j = 0; j != sz - i; ++j ) + BOOST_CHECK_EQUAL( m[i][j], i*sz + j + 1 ); + +#endif + +} + +void test_map_list_of() +{ +/* + maybe in the future... + + using namespace std; + using namespace boost::assign; + + typedef vector<int> score_type; + typedef map<string,score_type> team_score_map; + + team_score_map team_score = map_list_of + ( "Team Foo", list_of(1)(1)(0) ) + ( "Team Bar", list_of(0)(0)(0) ) + ( "Team FooBar", list_of(0)(0)(1) ); + BOOST_CHECK_EQUAL( team_score.size(), 3 ); + BOOST_CHECK_EQUAL( team_score[ "Team Foo" ][1], 1 ); + BOOST_CHECK_EQUAL( team_score[ "Team Bar" ][0], 0 ); +*/ + +} + +/* +void test_complex_list_of() +{ + typedef std::complex<float> complex_t; + std::vector<complex_t> v; + v = ba::list_of<complex_t>(1,2)(2,3)(4,5)(0). + repeat_from_to( complex_t(0,0), complex_t(10,10), complex_t(1,1) ); +} +*/ + +struct five +{ + five( int, int, int, int, int ) + { + } +}; + +void test_list_of() +{ + ba::list_of< five >(1,2,3,4,5)(6,7,8,9,10); + +/* Maybe this could be useful in a later version? + + // an anonymous lists, fulfills Range concept + for_each( ba::list_of( T() )( T() )( T() ) ); + + // non-anonymous lists + ba::generic_list<T> list_1 = ba::list_of( T() ); + BOOST_CHECK_EQUAL( list_1.size(), 1 ); + ba::generic_list<T> list_2 = list_1 + ba::list_of( T() )( T() ) + list_1; + BOOST_CHECK_EQUAL( list_2.size(), 4 ); + list_1 += list_2; + BOOST_CHECK_EQUAL( list_1.size(), 5 ); +*/ +} + +// +// @remark: ADL is required here, but it is a bit weird to +// open up namespace std. Perhaps Boost.Test needs a +// better configuration option. +// +namespace std +{ + template< class T, class Elem, class Traits > + inline std::basic_ostream<Elem,Traits>& + operator<<( std::basic_ostream<Elem, Traits>& Os, + const std::vector<T>& r ) + { + return Os << ::boost::make_iterator_range( r.begin(), r.end() ); + } +} + +template <class Seq> +inline std::vector<int> as_seq( const Seq& s ) +{ + std::vector<int> c; + return s.to_container( c ); +} + +void test_comparison_operations() +{ + BOOST_CHECK_EQUAL( ba::list_of(0)(1)(2), as_seq(ba::list_of(0)(1)(2)) ); + BOOST_CHECK_NE( ba::list_of(0)(1)(2), as_seq(ba::list_of(-1)(1)(2)) ); + BOOST_CHECK_LT( ba::list_of(0)(1)(2), as_seq(ba::list_of(0)(1)(3)) ); + BOOST_CHECK_LE( ba::list_of(0)(1)(2), as_seq(ba::list_of(0)(1)(2)) ); + BOOST_CHECK_GT( ba::list_of(0)(1)(3), as_seq(ba::list_of(0)(1)(2)) ); + BOOST_CHECK_GE( ba::list_of(0)(1)(2), as_seq(ba::list_of(0)(1)(2)) ); + BOOST_CHECK_EQUAL( as_seq(ba::list_of(0)(1)(2)), ba::list_of(0)(1)(2) ); + BOOST_CHECK_NE( as_seq(ba::list_of(0)(1)(2)), ba::list_of(-1)(1)(2) ); + BOOST_CHECK_LT( as_seq(ba::list_of(0)(1)(2)), ba::list_of(0)(1)(3) ); + BOOST_CHECK_LE( as_seq(ba::list_of(0)(1)(2)), ba::list_of(0)(1)(2) ); + BOOST_CHECK_GT( as_seq(ba::list_of(0)(1)(3)), ba::list_of(0)(1)(2) ); + BOOST_CHECK_GE( as_seq(ba::list_of(0)(1)(2)), ba::list_of(0)(1)(2) ); +} + +void check_list_of() +{ + test_sequence_list_of_int< std::vector<int> >(); + test_sequence_list_of_int< std::list<int> >(); + test_sequence_list_of_int< std::deque<int> >(); + test_sequence_list_of_int< std::set<int> >(); + test_sequence_list_of_int< std::multiset<int> >(); + test_sequence_list_of_int< std::vector<float> >(); + + test_sequence_list_of_string< std::vector<std::string> >(); + + test_map_list_of< std::map<std::string,int> >(); + test_map_list_of< std::multimap<std::string,int> >(); + + std::stack<std::string> s = ba::list_of( "Foo" )( "Bar" )( "FooBar" ).to_adapter( s ); + test_list_of(); + test_vector_matrix(); + test_comparison_operations(); +} + + + +#include <boost/test/unit_test.hpp> +using boost::unit_test::test_suite; + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); + + test->add( BOOST_TEST_CASE( &check_list_of ) ); + + return test; +} + + diff --git a/src/boost/libs/assign/test/list_of_workaround.cpp b/src/boost/libs/assign/test/list_of_workaround.cpp new file mode 100644 index 000000000..2e72e9304 --- /dev/null +++ b/src/boost/libs/assign/test/list_of_workaround.cpp @@ -0,0 +1,59 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + +#include <boost/assign/list_of.hpp> +#include <boost/test/test_tools.hpp> +#include <vector> +#include <set> +#include <map> +#include <stack> +#include <queue> +#include <boost/array.hpp> + +void check_list_of() +{ + using namespace std; + using namespace boost; + using namespace boost::assign; + using boost::array; + + vector<int> v = list_of(1)(2)(3)(4).to_container( v ); + set<int> s = list_of(1)(2)(3)(4).to_container( s ); + map<int,int> m = map_list_of(1,2)(2,3).to_container( m ); + stack<int> st = list_of(1)(2)(3)(4).to_adapter( st ); + queue<int> q = list_of(1)(2)(3)(4).to_adapter( q ); + array<int,4> a = list_of(1)(2)(3)(4).to_array( a ); + const vector<int> v2 = list_of(1).to_container( v2 ); + const array<int,1> a2 = list_of(1).to_array( a2 ); +} + + + +#include <boost/test/unit_test.hpp> +using boost::unit_test::test_suite; + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); + + test->add( BOOST_TEST_CASE( &check_list_of ) ); + + return test; +} + + diff --git a/src/boost/libs/assign/test/multi_index_container.cpp b/src/boost/libs/assign/test/multi_index_container.cpp new file mode 100644 index 000000000..711ba5d4d --- /dev/null +++ b/src/boost/libs/assign/test/multi_index_container.cpp @@ -0,0 +1,168 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + +#include <boost/assign/list_of.hpp> +#include <boost/assign/list_inserter.hpp> +#include <boost/multi_index_container.hpp> +#include <boost/multi_index/identity.hpp> +#include <boost/multi_index/member.hpp> +#include <boost/multi_index/ordered_index.hpp> +#include <boost/multi_index/sequenced_index.hpp> +#include <boost/test/test_tools.hpp> +#include <boost/test/unit_test.hpp> +#include <cstddef> +#include <ostream> +#include <string> + +using namespace boost; +using namespace boost::multi_index; +namespace ba = boost::assign; + +// +// Define a classical multi_index_container for employees +// +struct employee +{ + int id; + std::string name; + int age; + + employee(int id_,std::string name_,int age_):id(id_),name(name_),age(age_){} + + bool operator==(const employee& x)const + { + return id==x.id&&name==x.name&&age==x.age; + } + + bool operator<(const employee& x)const + { + return id<x.id; + } + + bool operator!=(const employee& x)const{return !(*this==x);} + bool operator> (const employee& x)const{return x<*this;} + bool operator>=(const employee& x)const{return !(*this<x);} + bool operator<=(const employee& x)const{return !(x<*this);} + + struct comp_id + { + bool operator()(int x,const employee& e2)const{return x<e2.id;} + bool operator()(const employee& e1,int x)const{return e1.id<x;} + }; + + friend std::ostream& operator<<(std::ostream& os,const employee& e) + { + os<<e.id<<" "<<e.name<<" "<<e.age<<std::endl; + return os; + } +}; + +struct name{}; +struct by_name{}; +struct age{}; +struct as_inserted{}; + +typedef + multi_index_container< + employee, + indexed_by< + ordered_unique< + identity<employee> >, + ordered_non_unique< + tag<name,by_name>, + BOOST_MULTI_INDEX_MEMBER(employee,std::string,name)>, + ordered_non_unique< + tag<age>, + BOOST_MULTI_INDEX_MEMBER(employee,int,age)>, + sequenced< + tag<as_inserted> > > > + employee_set; + +#if defined(BOOST_NO_MEMBER_TEMPLATES) +typedef nth_index< + employee_set,1>::type employee_set_by_name; +#else +typedef employee_set::nth_index<1>::type employee_set_by_name; +#endif + +typedef boost::multi_index::index< + employee_set,age>::type employee_set_by_age; +typedef boost::multi_index::index< + employee_set,as_inserted>::type employee_set_as_inserted; + +// +// Define a multi_index_container with a list-like index and an ordered index +// +typedef multi_index_container< + std::string, + indexed_by< + sequenced<>, // list-like index + ordered_non_unique<identity<std::string> > // words by alphabetical order + > +> text_container; + + + +void test_multi_index_container() +{ + employee_set eset = ba::list_of< employee >(1,"Franz",30)(2,"Hanz",40)(3,"Ilse",50); + BOOST_CHECK( eset.size() == 3u ); + + // + // This container is associative, hence we can use 'insert()' + // + + ba::insert( eset )(4,"Kurt",55)(5,"Bjarne",77)(7,"Thorsten",24); + BOOST_CHECK( eset.size() == 6u ); + + employee_set_by_name& name_index = boost::multi_index::get<name>(eset); + employee_set_by_name::iterator i = name_index.find("Ilse"); + BOOST_CHECK( i->id == 3 ); + BOOST_CHECK( i->age == 50 ); + + text_container text = ba::list_of< std::string >("Have")("you")("ever")("wondered")("how")("much")("Boost")("rocks?!"); + BOOST_CHECK_EQUAL( text.size(), 8u ); + BOOST_CHECK_EQUAL( *text.begin(), "Have" ); + + // + // This container is a sequence, hence we can use 'push_back()' and 'push_font()' + // + + ba::push_back( text )("Well")(",")("A")("LOT")(",")("obviously!"); + BOOST_CHECK_EQUAL( text.size(), 14u ); + BOOST_CHECK_EQUAL( *--text.end(), "obviously!" ); + + ba::push_front( text ) = "question:", "simple", "A"; + BOOST_CHECK_EQUAL( text.size(), 17u ); + BOOST_CHECK_EQUAL( text.front(), "A" ); +} + + + +using boost::unit_test::test_suite; + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); + + test->add( BOOST_TEST_CASE( &test_multi_index_container ) ); + + return test; +} + + diff --git a/src/boost/libs/assign/test/my_vector_example.cpp b/src/boost/libs/assign/test/my_vector_example.cpp new file mode 100644 index 000000000..f1a1849ce --- /dev/null +++ b/src/boost/libs/assign/test/my_vector_example.cpp @@ -0,0 +1,115 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + +#include <boost/assign/list_inserter.hpp> +#include <boost/test/test_tools.hpp> +#include <boost/function.hpp> +#include <boost/bind.hpp> +#include <vector> +#include <stdexcept> + +namespace ba = boost::assign; + + + +template< class C > +class range_inserter +{ + typedef typename C::iterator iterator; + iterator begin, end; +public: + range_inserter( C& c ) + : begin( c.begin() ), end( c.end() ) + { } + + template< class T > + void operator()( T r ) + { + if( begin == end ) + throw std::range_error( "range error: <range_inserter>" ); + *begin = r; + ++begin; + } +}; + + + +template< class C > +inline range_inserter<C> make_range_inserter( C& c ) +{ + return range_inserter<C>( c ); +} + + + +template< class T > +class my_vector +{ + typedef std::vector<T> vector_t; + typedef typename vector_t::size_type size_type; + vector_t data_; + +public: + my_vector() : data_( 10, 0 ) + { } + + ba::list_inserter< range_inserter< vector_t >, T > + operator=( T r ) + { + return ba::make_list_inserter( make_range_inserter( data_ ) )( r ); + } + + size_type size() const + { + return data_.size(); + } + + const T& operator[]( size_type index ) + { + return data_.at( index ); + } +}; + + + +void check_list_inserter() +{ + using namespace std; + using namespace boost::assign; + + my_vector<int> vec; + vec = 1,2,3,4,5,6,7,8,9,10; + BOOST_CHECK_EQUAL( vec.size(), 10u ); + BOOST_CHECK_EQUAL( vec[0], 1 ); + BOOST_CHECK_EQUAL( vec[9], 10 ); +} + + + +#include <boost/test/unit_test.hpp> +using boost::unit_test::test_suite; + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); + + test->add( BOOST_TEST_CASE( &check_list_inserter ) ); + + return test; +} + diff --git a/src/boost/libs/assign/test/ptr_list_inserter.cpp b/src/boost/libs/assign/test/ptr_list_inserter.cpp new file mode 100644 index 000000000..ddfd57cda --- /dev/null +++ b/src/boost/libs/assign/test/ptr_list_inserter.cpp @@ -0,0 +1,106 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2006. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + + +#include <boost/assign/ptr_list_inserter.hpp> +#include <boost/test/test_tools.hpp> +#include <boost/ptr_container/ptr_deque.hpp> +#include <boost/ptr_container/ptr_set.hpp> +#include <typeinfo> + +struct Foo +{ + int i; + + Foo() : i(0) + { } + Foo( int i ) : i(i) + { } + Foo( int i, int ) : i(i) + { } + Foo( const char*, int i, int ) : i(i) + { } + + virtual ~Foo() + { } +}; + +struct FooBar : Foo +{ + FooBar( int i ) : Foo(i) + { } + + FooBar( int i, const char* ) + { } +}; + +inline bool operator<( const Foo& l, const Foo& r ) +{ + return l.i < r.i; +} + +void check_ptr_list_inserter() +{ + using namespace std; + using namespace boost; + using namespace boost::assign; + + ptr_deque<Foo> deq; + ptr_push_back( deq )()(); + BOOST_CHECK( deq.size() == 2u ); + + ptr_push_front( deq )( 3 )( 42, 42 )( "foo", 42, 42 ); + BOOST_CHECK( deq.size() == 5u ); + + ptr_set<Foo> a_set; + ptr_insert( a_set )()( 1 )( 2, 2 )( "foo", 3, 3 ); + BOOST_CHECK( a_set.size() == 4u ); + ptr_insert( a_set )()()()(); + BOOST_CHECK( a_set.size() == 4u ); // duplicates not inserted + +#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING + + ptr_push_back<FooBar>( deq )( 42, "42" ); + BOOST_CHECK_EQUAL( deq.size(), 6u ); + BOOST_CHECK( typeid(deq[5u]) == typeid(FooBar) ); + + ptr_push_front<FooBar>( deq )( 42, "42" ); + BOOST_CHECK_EQUAL( deq.size(), 7u ); + BOOST_CHECK( typeid(deq[0]) == typeid(FooBar) ); + + ptr_insert<FooBar>( a_set )( 4 ); + BOOST_CHECK( a_set.size() == 5u ); + BOOST_CHECK( typeid(*--a_set.end()) == typeid(FooBar) ); + +#endif + +} + + + +#include <boost/test/unit_test.hpp> +using boost::unit_test::test_suite; + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); + + test->add( BOOST_TEST_CASE( &check_ptr_list_inserter ) ); + + return test; +} + diff --git a/src/boost/libs/assign/test/ptr_list_of.cpp b/src/boost/libs/assign/test/ptr_list_of.cpp new file mode 100644 index 000000000..9f59f03ec --- /dev/null +++ b/src/boost/libs/assign/test/ptr_list_of.cpp @@ -0,0 +1,75 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + +#include <boost/assign/ptr_list_of.hpp> +#include <boost/test/test_tools.hpp> +#include <boost/ptr_container/ptr_container.hpp> + +struct Foo +{ + int i; + + Foo() : i(0) + { } + Foo( int i ) : i(i) + { } + Foo( int i, int ) : i(i) + { } + Foo( const char*, int i, int ) : i(i) + { } +}; + +inline bool operator<( Foo l, Foo r ) +{ + return l.i < r.i; +} + +template< class PtrCont > +void check_ptr_list_of_impl() +{ + using namespace std; + using namespace boost; + using namespace boost::assign; + + PtrCont deq; + deq = ptr_list_of<Foo>( 42 )()()( 3, 3 )( "foo", 2, 1 ); + BOOST_CHECK( deq.size() == 5 ); + +} + +void check_ptr_list_of() +{ + check_ptr_list_of_impl< boost::ptr_deque<Foo> >(); + check_ptr_list_of_impl< boost::ptr_list<Foo> >(); + check_ptr_list_of_impl< boost::ptr_vector<Foo> >(); +} + + +#include <boost/test/unit_test.hpp> +using boost::unit_test::test_suite; + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); + + test->add( BOOST_TEST_CASE( &check_ptr_list_of ) ); + + return test; +} + + diff --git a/src/boost/libs/assign/test/ptr_map_inserter.cpp b/src/boost/libs/assign/test/ptr_map_inserter.cpp new file mode 100644 index 000000000..4248ebd30 --- /dev/null +++ b/src/boost/libs/assign/test/ptr_map_inserter.cpp @@ -0,0 +1,99 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + + +#include <boost/assign/ptr_map_inserter.hpp> +#include <boost/test/test_tools.hpp> +#include <boost/ptr_container/ptr_map.hpp> +#include <typeinfo> +#include <string> + +// +// abstract base class definition +// +struct abstract_base +{ + virtual ~abstract_base() {} + virtual void foo() = 0; + virtual abstract_base* clone() const = 0; +}; + +struct implementation : abstract_base +{ + implementation() + { } + + implementation( const implementation& ) + { } + + implementation( int ) + { } + + implementation( int, int ) + { } + + implementation( int, std::string, int, std::string ) + { } + + virtual void foo() {} + virtual abstract_base* clone() const + { + return new implementation( *this ); + } +}; + + +void check_ptr_map_inserter() +{ + +#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING + + boost::ptr_map<std::string, abstract_base> m; + boost::assign::ptr_map_insert<implementation>( m ) + ( "foo", 1, "two", 3, "four" ) + ( "bar", 41, "42", 43, "44" ); + BOOST_CHECK_EQUAL( m.size(), 2u ); + BOOST_CHECK( typeid(m.at("foo")) == typeid(implementation) ); + +#endif + + boost::ptr_map<std::string,implementation> m2; + boost::assign::ptr_map_insert( m2 ) + ( "foobar", 1, "two", 3, "four" ) + ( "key1" )( "key2" )( "key3" )( "key4" ) + ( "key5", 42 )( "key6", 42, 42 ); + + BOOST_CHECK_EQUAL( m2.size(), 7u ); + boost::assign::ptr_map_insert( m2 )( "key1" ); + BOOST_CHECK_EQUAL( m2.size(), 7u ); // duplicates not inserted + +} + + + +#include <boost/test/unit_test.hpp> +using boost::unit_test::test_suite; + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); + + test->add( BOOST_TEST_CASE( &check_ptr_map_inserter ) ); + + return test; +} + diff --git a/src/boost/libs/assign/test/static_list_of.cpp b/src/boost/libs/assign/test/static_list_of.cpp new file mode 100644 index 000000000..b28cc24f6 --- /dev/null +++ b/src/boost/libs/assign/test/static_list_of.cpp @@ -0,0 +1,98 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + +#include <boost/assign/list_of.hpp> +#include <boost/array.hpp> +#include <boost/test/test_tools.hpp> +#include <algorithm> +#include <iostream> + +template< class Range > +void print( const Range& r ) +{ + std::cout << "\n printing " << typeid(r).name() << " \n"; + std::cout << "\n"; + for( typename Range::iterator i = r.begin(), e = r.end(); + i !=e; ++i ) + std::cout << " " << *i; +} + +template< class Range > +void sort( const Range& r ) +{ + std::cout << "\n sorting " << typeid(r).name() << " \n"; + std::sort( r.begin(), r.end() ); + print( r ); +} + +template< class Range, class Pred > +void sort( const Range& r, Pred pred ) +{ + std::cout << "\n sorting " << typeid(r).name() << " \n"; + std::sort( r.begin(), r.end(), pred ); + print( r ); +} + +template< class Range > +typename Range::const_iterator max_element( const Range& r ) +{ + return std::max_element( r.begin(), r.end() ); +} + + + +void check_static_list_of() +{ + using namespace boost::assign; + + BOOST_CHECK( cref_list_of<5>( 1 )( 2 )( 3 )( 4 ).size() == 4 ); + + int a=1,b=5,c=3,d=4,e=2,f=9,g=0,h=7; + + int& max = *max_element( ref_list_of<8>(a)(b)(c)(d)(e)(f)(g)(h) ); + BOOST_CHECK_EQUAL( max, f ); + max = 8; + BOOST_CHECK_EQUAL( f, 8 ); + const int& const_max = *max_element( cref_list_of<8>(a)(b)(c)(d)(e)(f)(g)(h) ); + BOOST_CHECK_EQUAL( max, const_max ); + + print( ref_list_of<8>(a)(b)(c)(d)(e)(f)(g)(h) ); + print( cref_list_of<8>(a)(b)(c)(d)(e)(f)(g)(h) ); + + boost::array<int,4> array = cref_list_of<4>(1)(2)(3)(4); + + BOOST_CHECK_EQUAL( array[0], 1 ); + BOOST_CHECK_EQUAL( array[3], 4 ); + // + //print( cref_list_of<5>( "foo" )( "bar" )( "foobar" ) ); + // +} + +#include <boost/test/unit_test.hpp> +using boost::unit_test::test_suite; + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); + + test->add( BOOST_TEST_CASE( &check_static_list_of ) ); + + return test; +} + + diff --git a/src/boost/libs/assign/test/std.cpp b/src/boost/libs/assign/test/std.cpp new file mode 100644 index 000000000..bb2d8fbe5 --- /dev/null +++ b/src/boost/libs/assign/test/std.cpp @@ -0,0 +1,231 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + +#include <boost/assign/std.hpp> +#include <boost/test/test_tools.hpp> +#include <utility> +#include <string> + +using std::deque; +using std::list; +using std::vector; +using std::set; +using std::multiset; +using std::map; +using std::multimap; +using std::stack; +using std::queue; +using std::priority_queue; +using std::string; +using std::pair; +using std::make_pair; +using namespace boost::assign; + +template< typename K, typename V > +inline pair<K,V> P( K k, V v ) +{ + return make_pair( k, v ); +} + +struct three +{ + three( int, int, int ) { } + three( const string&, const string&, const string& ) { } +}; + +struct four +{ + four( int, int, int, int ) { } + four( const string&, const string&, const string&, const string& ) { } +}; + +struct five +{ + five( int, int, int, int, int ) { } + five( const string&, const string&, const string&, + const string&, const string& ) { } +}; + + + +template< class C > +void test_int_sequence() +{ + C c; + + BOOST_CHECK_EQUAL( c.size(), 0u ); + c +=1,2,3,4,5,6,7,8,9,10; + BOOST_CHECK_EQUAL( c.size(), 10u ); +} + + + +template< class C > +void test_string_sequence() +{ + C c; + + BOOST_CHECK_EQUAL( c.size(), 0u ); + c += "1","2","3","4","5","6","7","8","9","10"; + BOOST_CHECK_EQUAL( c.size(), 10u ); +} + + + +typedef pair<string,int> two_tuple; + +template< class C > +void test_tuple_sequence() +{ + C c; + + BOOST_CHECK_EQUAL( c.size(), 0u ); + c += P("1",1), P("2",2), P("3",3), P("4",4), P("5",5), P("6",6), + P("7",7), P("8",8), P("9",9), P("10",10); + BOOST_CHECK_EQUAL( c.size(), 10u ); +} + + + +template< class M > +void test_map() +{ + M m; + m += P( "january", 31 ), P( "february", 28 ), + P( "march", 31 ), P( "april", 30 ), + P( "may", 31 ), P( "june", 30 ), + P( "july", 31 ), P( "august", 31 ), + P( "september", 30 ), P( "october", 31 ), + P( "november", 30 ), P( "december", 31 ); + BOOST_CHECK_EQUAL( m.size(), 12u ); + m.clear(); + insert( m ) + ( "january", 31 )( "february", 28 ) + ( "march", 31 )( "april", 30 ) + ( "may", 31 )( "june", 30 ) + ( "july", 31 )( "august", 31 ) + ( "september", 30 )( "october", 31 ) + ( "november", 30 )( "december", 31 ); + BOOST_CHECK_EQUAL( m.size(), 12u ); +} + + + +void test_tuple() +{ + vector<three> v_three; + vector<four> v_four; + vector<five> v_five; + + push_back( v_three ) (1,2,3) ("1","2","3"); + push_back( v_four ) (1,2,3,4) ("1","2","3","4"); + push_back( v_five ) (1,2,3,4,5) ("1","2","3","4","5"); + BOOST_CHECK_EQUAL( v_three.size(), 2u ); + BOOST_CHECK_EQUAL( v_four.size(), 2u ); + BOOST_CHECK_EQUAL( v_five.size(), 2u ); + +} + + + +void check_std() +{ + test_int_sequence< deque<int> >(); + test_int_sequence< list<int> >(); + test_int_sequence< vector<int> >(); + test_int_sequence< set<int> >(); + test_int_sequence< multiset<int> >(); + test_int_sequence< stack<int> >(); + test_int_sequence< queue<int> >(); + test_int_sequence< priority_queue<int> >(); + + test_string_sequence< deque<string> >(); + test_string_sequence< list<string> >(); + test_string_sequence< vector<string> >(); + test_string_sequence< set<string> >(); + test_string_sequence< multiset<string> >(); + test_string_sequence< stack<string> >(); + test_string_sequence< queue<string> >(); + test_string_sequence< priority_queue<string> >(); + + test_tuple_sequence< deque<two_tuple> >(); + test_tuple_sequence< list<two_tuple> >(); + test_tuple_sequence< vector<two_tuple> >(); + test_tuple_sequence< set<two_tuple> >(); + test_tuple_sequence< multiset<two_tuple> >(); + test_tuple_sequence< stack<two_tuple> >(); + test_tuple_sequence< queue<two_tuple> >(); + test_tuple_sequence< priority_queue<two_tuple> >(); + test_tuple(); + + deque<int> di; + push_back( di )( 1 ); + push_front( di )( 2 ); + BOOST_CHECK_EQUAL( di[0], 2 ); + BOOST_CHECK_EQUAL( di[1], 1 ); + + list<int> li; + push_back( li )( 2 ); + push_front( li )( 1 ); + BOOST_CHECK_EQUAL( li.front(), 1 ); + BOOST_CHECK_EQUAL( li.back(), 2 ); + + vector<int> vi; + push_back( vi ) = 2,3; + BOOST_CHECK_EQUAL( vi[0], 2 ); + BOOST_CHECK_EQUAL( vi[1], 3 ); + + set<int> si; + insert( si )( 4 ); + BOOST_CHECK_EQUAL( *si.find( 4 ), 4 ); + + multiset<int> msi; + insert( msi )( 5 ); + BOOST_CHECK_EQUAL( *msi.find( 5 ), 5 ); + + stack<int> sti; + push( sti )( 6 ); + BOOST_CHECK_EQUAL( sti.top(), 6 ); + + queue<int> qi; + push( qi )( 7 ); + BOOST_CHECK_EQUAL( qi.back(), 7 ); + + priority_queue<int> pqi; + push( pqi )( 8 ); + BOOST_CHECK_EQUAL( pqi.top(), 8 ); + + test_map< map<string,int> >(); + test_map< multimap<string,int> >(); + +} + + + +#include <boost/test/unit_test.hpp> +using boost::unit_test::test_suite; + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); + + test->add( BOOST_TEST_CASE( &check_std ) ); + + return test; +} + diff --git a/src/boost/libs/assign/test/tuple_list_of.cpp b/src/boost/libs/assign/test/tuple_list_of.cpp new file mode 100644 index 000000000..807dd60ed --- /dev/null +++ b/src/boost/libs/assign/test/tuple_list_of.cpp @@ -0,0 +1,54 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is 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) +// +// For more information, see http://www.boost.org/libs/assign/ +// + + +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# pragma warn -8091 // suppress warning in Boost.Test +# pragma warn -8057 // unused argument argc/argv in Boost.Test +#endif + +#include <boost/assign/list_of.hpp> +#include <boost/test/test_tools.hpp> +#include <algorithm> +#include <iostream> +#include <string> +#include <vector> +#include <map> + +void check_tuple_list_of() +{ + using namespace boost::assign; + + typedef boost::tuple<int,std::string,int> tuple; + + std::vector<tuple> v = tuple_list_of( 1, "foo", 2 )( 3, "bar", 4 ); + BOOST_CHECK( v.size() == 2 ); + BOOST_CHECK( boost::get<0>( v[1] ) == 3 ); + + std::map<std::string,int> m = pair_list_of( "foo", 3 )( "bar", 5 ); + BOOST_CHECK( m.size() == 2 ); + BOOST_CHECK( m["foo"] == 3 ); +} + +#include <boost/test/unit_test.hpp> +using boost::unit_test::test_suite; + +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); + + test->add( BOOST_TEST_CASE( &check_tuple_list_of ) ); + + return test; +} + + |