[DEV] add v1.66.0

This commit is contained in:
2018-01-12 21:47:58 +01:00
parent 87059bb1af
commit a97e9ae7d4
49032 changed files with 7668950 additions and 0 deletions

View File

@@ -0,0 +1,174 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Boost.Assignment Documentation </title>
<link rel="stylesheet" href="style.css" type="text/css">
</head>
<body>
<pre>
<span class=comment>// 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/
//
</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>detail</span><span class=special>/</span><span class=identifier>workaround</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;
</span>
<span class=preprocessor>#if </span><span class=identifier>BOOST_WORKAROUND</span><span class=special>(</span><span class=identifier>__BORLANDC__</span><span class=special>, </span><span class=identifier>BOOST_TESTED_AT</span><span class=special>(</span><span class=number>0</span><span class=identifier>x564</span><span class=special>))</span>
###<span class=identifier>pragma </span><span class=identifier>warn </span><span class=special>-</span><span class=number>8091 </span><span class=comment>// suppress warning in Boost.Test</span>
###<span class=identifier>pragma </span><span class=identifier>warn </span><span class=special>-</span><span class=number>8057 </span><span class=comment>// unused argument argc/argv in Boost.Test</span>
<span class=preprocessor>#endif
</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>list_inserter</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>test</span><span class=special>/</span><span class=identifier>unit_test</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>test</span><span class=special>/</span><span class=identifier>test_tools</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>function</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>bind</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>vector</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>map</span><span class=special>&gt;
</span>
<span class=keyword>namespace </span><span class=identifier>ba </span><span class=special>= </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;
</span>
<span class=keyword>class </span><span class=identifier>email</span>
<span class=special>{</span>
<span class=keyword>public</span><span class=special>:
</span><span class=keyword>enum </span><span class=identifier>address_option
</span><span class=special>{
</span><span class=identifier>check_addr_book</span><span class=special>,
</span><span class=identifier>dont_check_addr_book
</span><span class=special>};
</span><span class=keyword>typedef </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>,</span><span class=identifier>address_option</span><span class=special>&gt; </span><span class=identifier>bcc_type</span><span class=special>;
</span><span class=keyword>typedef </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt; </span><span class=identifier>bcc_type </span><span class=special>&gt; </span><span class=identifier>bcc_map</span><span class=special>;
</span><span class=keyword>typedef </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>map</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>,</span><span class=identifier>address_option</span><span class=special>&gt; </span><span class=identifier>address_map</span><span class=special>;
</span>
<span class=keyword>private</span><span class=special>:
</span><span class=keyword>mutable </span><span class=identifier>address_map </span><span class=identifier>cc_list</span><span class=special>;
</span><span class=keyword>mutable </span><span class=identifier>address_map </span><span class=identifier>to_list</span><span class=special>;
</span><span class=identifier>bcc_map </span><span class=identifier>bcc_list</span><span class=special>;
</span><span class=keyword>struct </span><span class=identifier>add_to_map
</span><span class=special>{
</span><span class=identifier>address_map</span><span class=special>&amp; </span><span class=identifier>m</span><span class=special>;
</span><span class=identifier>add_to_map</span><span class=special>( </span><span class=identifier>address_map</span><span class=special>&amp; </span><span class=identifier>m </span><span class=special>) </span><span class=special>: </span><span class=identifier>m</span><span class=special>(</span><span class=identifier>m</span><span class=special>)
</span><span class=special>{}
</span><span class=keyword>void </span><span class=keyword>operator</span><span class=special>()( </span><span class=keyword>const </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&amp; </span><span class=identifier>name</span><span class=special>, </span><span class=identifier>address_option </span><span class=identifier>ao </span><span class=special>)
</span><span class=special>{
</span><span class=identifier>m</span><span class=special>[ </span><span class=identifier>name </span><span class=special>] </span><span class=special>= </span><span class=identifier>ao</span><span class=special>;
</span><span class=special>}
</span><span class=keyword>void </span><span class=keyword>operator</span><span class=special>()( </span><span class=keyword>const </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&amp; </span><span class=identifier>name </span><span class=special>)
</span><span class=special>{
</span><span class=identifier>m</span><span class=special>[ </span><span class=identifier>name </span><span class=special>] </span><span class=special>= </span><span class=identifier>check_addr_book</span><span class=special>;
</span><span class=special>}
</span><span class=special>};
</span><span class=keyword>struct </span><span class=identifier>add_to_vector
</span><span class=special>{
</span><span class=identifier>bcc_map</span><span class=special>&amp; </span><span class=identifier>m</span><span class=special>;
</span><span class=identifier>add_to_vector</span><span class=special>( </span><span class=identifier>bcc_map</span><span class=special>&amp; </span><span class=identifier>m </span><span class=special>) </span><span class=special>: </span><span class=identifier>m</span><span class=special>(</span><span class=identifier>m</span><span class=special>)
</span><span class=special>{}
</span><span class=keyword>void </span><span class=keyword>operator</span><span class=special>()( </span><span class=keyword>const </span><span class=identifier>bcc_type</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>)
</span><span class=special>{
</span><span class=identifier>m</span><span class=special>.</span><span class=identifier>push_back</span><span class=special>( </span><span class=identifier>r </span><span class=special>);
</span><span class=special>}
</span><span class=special>};
</span>
<span class=keyword>public</span><span class=special>:
</span><span class=identifier>ba</span><span class=special>::</span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=identifier>add_to_map </span><span class=special>&gt;
</span><span class=identifier>add_cc</span><span class=special>( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>name</span><span class=special>, </span><span class=identifier>address_option </span><span class=identifier>ao </span><span class=special>)
</span><span class=special>{
</span><span class=keyword>return </span><span class=identifier>ba</span><span class=special>::</span><span class=identifier>make_list_inserter</span><span class=special>( </span><span class=identifier>add_to_map</span><span class=special>( </span><span class=identifier>cc_list </span><span class=special>) </span><span class=special>)( </span><span class=identifier>name</span><span class=special>, </span><span class=identifier>ao </span><span class=special>);
</span><span class=special>}
</span><span class=identifier>ba</span><span class=special>::</span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=identifier>add_to_map </span><span class=special>&gt;
</span><span class=identifier>add_to</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&amp; </span><span class=identifier>name </span><span class=special>)
</span><span class=special>{
</span><span class=keyword>return </span><span class=identifier>ba</span><span class=special>::</span><span class=identifier>make_list_inserter</span><span class=special>( </span><span class=identifier>add_to_map</span><span class=special>( </span><span class=identifier>to_list </span><span class=special>) </span><span class=special>)( </span><span class=identifier>name </span><span class=special>);
</span><span class=special>}
</span><span class=identifier>ba</span><span class=special>::</span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=identifier>add_to_vector</span><span class=special>, </span><span class=identifier>bcc_type </span><span class=special>&gt;
</span><span class=identifier>add_bcc</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>bcc_type</span><span class=special>&amp; </span><span class=identifier>bcc </span><span class=special>)
</span><span class=special>{
</span><span class=keyword>return </span><span class=identifier>ba</span><span class=special>::</span><span class=identifier>make_list_inserter</span><span class=special>( </span><span class=identifier>add_to_vector</span><span class=special>( </span><span class=identifier>bcc_list </span><span class=special>) </span><span class=special>)( </span><span class=identifier>bcc </span><span class=special>);
</span><span class=special>}
</span><span class=identifier>address_option
</span><span class=identifier>cc_at</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&amp; </span><span class=identifier>name </span><span class=special>) </span><span class=keyword>const
</span><span class=special>{
</span><span class=keyword>return </span><span class=identifier>cc_list</span><span class=special>[ </span><span class=identifier>name </span><span class=special>];
</span><span class=special>}
</span><span class=identifier>address_option
</span><span class=identifier>to_at</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&amp; </span><span class=identifier>name </span><span class=special>) </span><span class=keyword>const
</span><span class=special>{
</span><span class=keyword>return </span><span class=identifier>to_list</span><span class=special>[ </span><span class=identifier>name </span><span class=special>];
</span><span class=special>}
</span><span class=identifier>address_option
</span><span class=identifier>bcc_at</span><span class=special>( </span><span class=keyword>unsigned </span><span class=identifier>index </span><span class=special>) </span><span class=keyword>const
</span><span class=special>{
</span><span class=keyword>return </span><span class=identifier>bcc_list</span><span class=special>.</span><span class=identifier>at</span><span class=special>( </span><span class=identifier>index </span><span class=special>).</span><span class=identifier>second</span><span class=special>;
</span><span class=special>}</span>
<span class=special>};
</span>
<span class=keyword>void </span><span class=identifier>check_list_inserter</span><span class=special>()</span>
<span class=special>{
</span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;
</span><span class=identifier>email </span><span class=identifier>e</span><span class=special>;
</span><span class=identifier>e</span><span class=special>.</span><span class=identifier>add_cc</span><span class=special>( </span><span class=string>&quot;franz&quot;</span><span class=special>, </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>dont_check_addr_book </span><span class=special>)
</span><span class=special>( </span><span class=string>&quot;hanz&quot;</span><span class=special>, </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>check_addr_book </span><span class=special>)
</span><span class=special>( </span><span class=string>&quot;betty&quot;</span><span class=special>, </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>dont_check_addr_book </span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>e</span><span class=special>.</span><span class=identifier>cc_at</span><span class=special>( </span><span class=string>&quot;franz&quot; </span><span class=special>), </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>dont_check_addr_book </span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>e</span><span class=special>.</span><span class=identifier>cc_at</span><span class=special>( </span><span class=string>&quot;hanz&quot; </span><span class=special>), </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>check_addr_book </span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>e</span><span class=special>.</span><span class=identifier>cc_at</span><span class=special>( </span><span class=string>&quot;betty&quot; </span><span class=special>), </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>dont_check_addr_book </span><span class=special>);
</span><span class=identifier>e</span><span class=special>.</span><span class=identifier>add_to</span><span class=special>( </span><span class=string>&quot;betsy&quot; </span><span class=special>)( </span><span class=string>&quot;peter&quot; </span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>e</span><span class=special>.</span><span class=identifier>cc_at</span><span class=special>( </span><span class=string>&quot;betsy&quot; </span><span class=special>), </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>check_addr_book </span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>e</span><span class=special>.</span><span class=identifier>cc_at</span><span class=special>( </span><span class=string>&quot;peter&quot; </span><span class=special>), </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>check_addr_book </span><span class=special>);
</span><span class=identifier>e</span><span class=special>.</span><span class=identifier>add_bcc</span><span class=special>( </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>bcc_type</span><span class=special>( </span><span class=string>&quot;Mr. Foo&quot;</span><span class=special>, </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>check_addr_book </span><span class=special>) </span><span class=special>)
</span><span class=special>( </span><span class=string>&quot;Mr. Bar&quot;</span><span class=special>, </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>dont_check_addr_book </span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>e</span><span class=special>.</span><span class=identifier>bcc_at</span><span class=special>( </span><span class=number>0 </span><span class=special>), </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>check_addr_book </span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>e</span><span class=special>.</span><span class=identifier>bcc_at</span><span class=special>( </span><span class=number>1 </span><span class=special>), </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>dont_check_addr_book </span><span class=special>);
</span>
<span class=special>}
</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>test</span><span class=special>/</span><span class=identifier>included</span><span class=special>/</span><span class=identifier>unit_test_framework</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;
</span>
<span class=keyword>using </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>unit_test_framework</span><span class=special>::</span><span class=identifier>test_suite</span><span class=special>;
</span>
<span class=identifier>test_suite</span><span class=special>* </span><span class=identifier>init_unit_test_suite</span><span class=special>( </span><span class=keyword>int </span><span class=identifier>argc</span><span class=special>, </span><span class=keyword>char</span><span class=special>* </span><span class=identifier>argv</span><span class=special>[] </span><span class=special>)</span>
<span class=special>{
</span><span class=identifier>test_suite</span><span class=special>* </span><span class=identifier>test </span><span class=special>= </span><span class=identifier>BOOST_TEST_SUITE</span><span class=special>( </span><span class=string>&quot;List Test Suite&quot; </span><span class=special>);
</span><span class=identifier>test</span><span class=special>-&gt;</span><span class=identifier>add</span><span class=special>( </span><span class=identifier>BOOST_TEST_CASE</span><span class=special>( </span><span class=special>&amp;</span><span class=identifier>check_list_inserter </span><span class=special>) </span><span class=special>);
</span><span class=keyword>return </span><span class=identifier>test</span><span class=special>;</span>
<span class=special>}
</span>
</pre>
</body>
</html>

1432
libs/assign/doc/index.html Normal file

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,185 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Boost.Assignment Documentation </title>
<link rel="stylesheet" href="style.css" type="text/css">
</head>
<body>
<pre>
<span class=comment>// 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/
//
</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>detail</span><span class=special>/</span><span class=identifier>workaround</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;
</span>
<span class=preprocessor>#if </span><span class=identifier>BOOST_WORKAROUND</span><span class=special>(</span><span class=identifier>__BORLANDC__</span><span class=special>, </span><span class=identifier>BOOST_TESTED_AT</span><span class=special>(</span><span class=number>0</span><span class=identifier>x564</span><span class=special>))</span>
###<span class=identifier>pragma </span><span class=identifier>warn </span><span class=special>-</span><span class=number>8091 </span><span class=comment>// suppress warning in Boost.Test</span>
###<span class=identifier>pragma </span><span class=identifier>warn </span><span class=special>-</span><span class=number>8057 </span><span class=comment>// unused argument argc/argv in Boost.Test</span>
<span class=preprocessor>#endif
</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>list_of</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>list_inserter</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index_container</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>identity</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>member</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>ordered_index</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>sequenced_index</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>test</span><span class=special>/</span><span class=identifier>unit_test</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>test</span><span class=special>/</span><span class=identifier>test_tools</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>cstddef</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>ostream</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>&gt;
</span>
<span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>;</span>
<span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>;</span>
<span class=keyword>namespace </span><span class=identifier>ba </span><span class=special>= </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;
</span>
<span class=comment>//
// Define a classical multi_index_container for employees
//</span>
<span class=keyword>struct </span><span class=identifier>employee</span>
<span class=special>{
</span><span class=keyword>int </span><span class=identifier>id</span><span class=special>;
</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>name</span><span class=special>;
</span><span class=keyword>int </span><span class=identifier>age</span><span class=special>;
</span><span class=identifier>employee</span><span class=special>(</span><span class=keyword>int </span><span class=identifier>id_</span><span class=special>,</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>name_</span><span class=special>,</span><span class=keyword>int </span><span class=identifier>age_</span><span class=special>):</span><span class=identifier>id</span><span class=special>(</span><span class=identifier>id_</span><span class=special>),</span><span class=identifier>name</span><span class=special>(</span><span class=identifier>name_</span><span class=special>),</span><span class=identifier>age</span><span class=special>(</span><span class=identifier>age_</span><span class=special>){}
</span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>==(</span><span class=keyword>const </span><span class=identifier>employee</span><span class=special>&amp; </span><span class=identifier>x</span><span class=special>)</span><span class=keyword>const
</span><span class=special>{
</span><span class=keyword>return </span><span class=identifier>id</span><span class=special>==</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>id</span><span class=special>&amp;&amp;</span><span class=identifier>name</span><span class=special>==</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>name</span><span class=special>&amp;&amp;</span><span class=identifier>age</span><span class=special>==</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>age</span><span class=special>;
</span><span class=special>}
</span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>&lt;(</span><span class=keyword>const </span><span class=identifier>employee</span><span class=special>&amp; </span><span class=identifier>x</span><span class=special>)</span><span class=keyword>const
</span><span class=special>{
</span><span class=keyword>return </span><span class=identifier>id</span><span class=special>&lt;</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>id</span><span class=special>;
</span><span class=special>}
</span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>!=(</span><span class=keyword>const </span><span class=identifier>employee</span><span class=special>&amp; </span><span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>{</span><span class=keyword>return </span><span class=special>!(*</span><span class=keyword>this</span><span class=special>==</span><span class=identifier>x</span><span class=special>);}
</span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>&gt; </span><span class=special>(</span><span class=keyword>const </span><span class=identifier>employee</span><span class=special>&amp; </span><span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>{</span><span class=keyword>return </span><span class=identifier>x</span><span class=special>&lt;*</span><span class=keyword>this</span><span class=special>;}
</span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>&gt;=(</span><span class=keyword>const </span><span class=identifier>employee</span><span class=special>&amp; </span><span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>{</span><span class=keyword>return </span><span class=special>!(*</span><span class=keyword>this</span><span class=special>&lt;</span><span class=identifier>x</span><span class=special>);}
</span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>&lt;=(</span><span class=keyword>const </span><span class=identifier>employee</span><span class=special>&amp; </span><span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>{</span><span class=keyword>return </span><span class=special>!(</span><span class=identifier>x</span><span class=special>&lt;*</span><span class=keyword>this</span><span class=special>);}
</span><span class=keyword>struct </span><span class=identifier>comp_id
</span><span class=special>{
</span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>()(</span><span class=keyword>int </span><span class=identifier>x</span><span class=special>,</span><span class=keyword>const </span><span class=identifier>employee</span><span class=special>&amp; </span><span class=identifier>e2</span><span class=special>)</span><span class=keyword>const</span><span class=special>{</span><span class=keyword>return </span><span class=identifier>x</span><span class=special>&lt;</span><span class=identifier>e2</span><span class=special>.</span><span class=identifier>id</span><span class=special>;}
</span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const </span><span class=identifier>employee</span><span class=special>&amp; </span><span class=identifier>e1</span><span class=special>,</span><span class=keyword>int </span><span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>{</span><span class=keyword>return </span><span class=identifier>e1</span><span class=special>.</span><span class=identifier>id</span><span class=special>&lt;</span><span class=identifier>x</span><span class=special>;}
</span><span class=special>};
</span><span class=keyword>friend </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>ostream</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>&lt;&lt;(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>ostream</span><span class=special>&amp; </span><span class=identifier>os</span><span class=special>,</span><span class=keyword>const </span><span class=identifier>employee</span><span class=special>&amp; </span><span class=identifier>e</span><span class=special>)
</span><span class=special>{
</span><span class=identifier>os</span><span class=special>&lt;&lt;</span><span class=identifier>e</span><span class=special>.</span><span class=identifier>id</span><span class=special>&lt;&lt;</span><span class=string>&quot; &quot;</span><span class=special>&lt;&lt;</span><span class=identifier>e</span><span class=special>.</span><span class=identifier>name</span><span class=special>&lt;&lt;</span><span class=string>&quot; &quot;</span><span class=special>&lt;&lt;</span><span class=identifier>e</span><span class=special>.</span><span class=identifier>age</span><span class=special>&lt;&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>endl</span><span class=special>;
</span><span class=keyword>return </span><span class=identifier>os</span><span class=special>;
</span><span class=special>}</span>
<span class=special>};
</span>
<span class=keyword>struct </span><span class=identifier>name</span><span class=special>{};</span>
<span class=keyword>struct </span><span class=identifier>by_name</span><span class=special>{};</span>
<span class=keyword>struct </span><span class=identifier>age</span><span class=special>{};</span>
<span class=keyword>struct </span><span class=identifier>as_inserted</span><span class=special>{};
</span>
<span class=keyword>typedef
</span><span class=identifier>multi_index_container</span><span class=special>&lt;
</span><span class=identifier>employee</span><span class=special>,
</span><span class=identifier>indexed_by</span><span class=special>&lt;
</span><span class=identifier>ordered_unique</span><span class=special>&lt;
</span><span class=identifier>identity</span><span class=special>&lt;</span><span class=identifier>employee</span><span class=special>&gt; </span><span class=special>&gt;,
</span><span class=identifier>ordered_non_unique</span><span class=special>&lt;
</span><span class=identifier>tag</span><span class=special>&lt;</span><span class=identifier>name</span><span class=special>,</span><span class=identifier>by_name</span><span class=special>&gt;,
</span><span class=identifier>BOOST_MULTI_INDEX_MEMBER</span><span class=special>(</span><span class=identifier>employee</span><span class=special>,</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>,</span><span class=identifier>name</span><span class=special>)&gt;,
</span><span class=identifier>ordered_non_unique</span><span class=special>&lt;
</span><span class=identifier>tag</span><span class=special>&lt;</span><span class=identifier>age</span><span class=special>&gt;,
</span><span class=identifier>BOOST_MULTI_INDEX_MEMBER</span><span class=special>(</span><span class=identifier>employee</span><span class=special>,</span><span class=keyword>int</span><span class=special>,</span><span class=identifier>age</span><span class=special>)&gt;,
</span><span class=identifier>sequenced</span><span class=special>&lt;
</span><span class=identifier>tag</span><span class=special>&lt;</span><span class=identifier>as_inserted</span><span class=special>&gt; </span><span class=special>&gt; </span><span class=special>&gt; </span><span class=special>&gt;
</span><span class=identifier>employee_set</span><span class=special>;
</span>
<span class=preprocessor>#if </span><span class=identifier>defined</span><span class=special>(</span><span class=identifier>BOOST_NO_MEMBER_TEMPLATES</span><span class=special>)</span>
<span class=keyword>typedef </span><span class=identifier>nth_index</span><span class=special>&lt;
</span><span class=identifier>employee_set</span><span class=special>,</span><span class=number>1</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>employee_set_by_name</span><span class=special>;</span>
<span class=preprocessor>#else</span>
<span class=keyword>typedef </span><span class=identifier>employee_set</span><span class=special>::</span><span class=identifier>nth_index</span><span class=special>&lt;</span><span class=number>1</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>employee_set_by_name</span><span class=special>;</span>
<span class=preprocessor>#endif
</span>
<span class=keyword>typedef </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>index</span><span class=special>&lt;
</span><span class=identifier>employee_set</span><span class=special>,</span><span class=identifier>age</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>employee_set_by_age</span><span class=special>;</span>
<span class=keyword>typedef </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>index</span><span class=special>&lt;
</span><span class=identifier>employee_set</span><span class=special>,</span><span class=identifier>as_inserted</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>employee_set_as_inserted</span><span class=special>;
</span>
<span class=comment>//
// Define a multi_index_container with a list-like index and an ordered index
//</span>
<span class=keyword>typedef </span><span class=identifier>multi_index_container</span><span class=special>&lt;
</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>,
</span><span class=identifier>indexed_by</span><span class=special>&lt;
</span><span class=identifier>sequenced</span><span class=special>&lt;&gt;, </span><span class=comment>// list-like index
</span><span class=identifier>ordered_non_unique</span><span class=special>&lt;</span><span class=identifier>identity</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&gt; </span><span class=special>&gt; </span><span class=comment>// words by alphabetical order
</span><span class=special>&gt;</span>
<span class=special>&gt; </span><span class=identifier>text_container</span><span class=special>;
</span>
<span class=keyword>void </span><span class=identifier>test_multi_index_container</span><span class=special>()</span>
<span class=special>{
</span><span class=identifier>employee_set </span><span class=identifier>eset </span><span class=special>= </span><span class=identifier>ba</span><span class=special>::</span><span class=identifier>list_of</span><span class=special>&lt; </span><span class=identifier>employee </span><span class=special>&gt;(</span><span class=number>1</span><span class=special>,</span><span class=string>&quot;Franz&quot;</span><span class=special>,</span><span class=number>30</span><span class=special>)(</span><span class=number>2</span><span class=special>,</span><span class=string>&quot;Hanz&quot;</span><span class=special>,</span><span class=number>40</span><span class=special>)(</span><span class=number>3</span><span class=special>,</span><span class=string>&quot;Ilse&quot;</span><span class=special>,</span><span class=number>50</span><span class=special>);
</span><span class=identifier>BOOST_CHECK</span><span class=special>( </span><span class=identifier>eset</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>3u </span><span class=special>);
</span><span class=comment>//
// This container is associative, hence we can use 'insert()'
//
</span><span class=identifier>ba</span><span class=special>::</span><span class=identifier>insert</span><span class=special>( </span><span class=identifier>eset </span><span class=special>)(</span><span class=number>4</span><span class=special>,</span><span class=string>&quot;Kurt&quot;</span><span class=special>,</span><span class=number>55</span><span class=special>)(</span><span class=number>5</span><span class=special>,</span><span class=string>&quot;Bjarne&quot;</span><span class=special>,</span><span class=number>77</span><span class=special>)(</span><span class=number>7</span><span class=special>,</span><span class=string>&quot;Thorsten&quot;</span><span class=special>,</span><span class=number>24</span><span class=special>);
</span><span class=identifier>BOOST_CHECK</span><span class=special>( </span><span class=identifier>eset</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>6u </span><span class=special>);
</span><span class=identifier>employee_set_by_name</span><span class=special>&amp; </span><span class=identifier>name_index </span><span class=special>= </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>get</span><span class=special>&lt;</span><span class=identifier>name</span><span class=special>&gt;(</span><span class=identifier>eset</span><span class=special>);
</span><span class=identifier>employee_set_by_name</span><span class=special>::</span><span class=identifier>iterator </span><span class=identifier>i </span><span class=special>= </span><span class=identifier>name_index</span><span class=special>.</span><span class=identifier>find</span><span class=special>(</span><span class=string>&quot;Ilse&quot;</span><span class=special>);
</span><span class=identifier>BOOST_CHECK</span><span class=special>( </span><span class=identifier>i</span><span class=special>-&gt;</span><span class=identifier>id </span><span class=special>== </span><span class=number>3 </span><span class=special>);
</span><span class=identifier>BOOST_CHECK</span><span class=special>( </span><span class=identifier>i</span><span class=special>-&gt;</span><span class=identifier>age </span><span class=special>== </span><span class=number>50 </span><span class=special>);
</span><span class=identifier>text_container </span><span class=identifier>text </span><span class=special>= </span><span class=identifier>ba</span><span class=special>::</span><span class=identifier>list_of</span><span class=special>&lt; </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=special>&gt;(</span><span class=string>&quot;Have&quot;</span><span class=special>)(</span><span class=string>&quot;you&quot;</span><span class=special>)(</span><span class=string>&quot;ever&quot;</span><span class=special>)(</span><span class=string>&quot;wondered&quot;</span><span class=special>)(</span><span class=string>&quot;how&quot;</span><span class=special>)(</span><span class=string>&quot;much&quot;</span><span class=special>)(</span><span class=string>&quot;Boost&quot;</span><span class=special>)(</span><span class=string>&quot;rocks?!&quot;</span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>text</span><span class=special>.</span><span class=identifier>size</span><span class=special>(), </span><span class=number>8u </span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=special>*</span><span class=identifier>text</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(), </span><span class=string>&quot;Have&quot; </span><span class=special>);
</span><span class=comment>//
// This container is a sequence, hence we can use 'push_back()' and 'push_font()'
//
</span><span class=identifier>ba</span><span class=special>::</span><span class=identifier>push_back</span><span class=special>( </span><span class=identifier>text </span><span class=special>)(</span><span class=string>&quot;Well&quot;</span><span class=special>)(</span><span class=string>&quot;,&quot;</span><span class=special>)(</span><span class=string>&quot;A&quot;</span><span class=special>)(</span><span class=string>&quot;LOT&quot;</span><span class=special>)(</span><span class=string>&quot;,&quot;</span><span class=special>)(</span><span class=string>&quot;obviously!&quot;</span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>text</span><span class=special>.</span><span class=identifier>size</span><span class=special>(), </span><span class=number>14u </span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=special>*--</span><span class=identifier>text</span><span class=special>.</span><span class=identifier>end</span><span class=special>(), </span><span class=string>&quot;obviously!&quot; </span><span class=special>);
</span><span class=identifier>ba</span><span class=special>::</span><span class=identifier>push_front</span><span class=special>( </span><span class=identifier>text </span><span class=special>) </span><span class=special>= </span><span class=string>&quot;question:&quot;</span><span class=special>, </span><span class=string>&quot;simple&quot;</span><span class=special>, </span><span class=string>&quot;A&quot;</span><span class=special>;
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>text</span><span class=special>.</span><span class=identifier>size</span><span class=special>(), </span><span class=number>17u </span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>text</span><span class=special>.</span><span class=identifier>front</span><span class=special>(), </span><span class=string>&quot;A&quot; </span><span class=special>);</span>
<span class=special>}
</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>test</span><span class=special>/</span><span class=identifier>included</span><span class=special>/</span><span class=identifier>unit_test_framework</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;
</span>
<span class=keyword>using </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>unit_test_framework</span><span class=special>::</span><span class=identifier>test_suite</span><span class=special>;
</span>
<span class=identifier>test_suite</span><span class=special>* </span><span class=identifier>init_unit_test_suite</span><span class=special>( </span><span class=keyword>int </span><span class=identifier>argc</span><span class=special>, </span><span class=keyword>char</span><span class=special>* </span><span class=identifier>argv</span><span class=special>[] </span><span class=special>)</span>
<span class=special>{
</span><span class=identifier>test_suite</span><span class=special>* </span><span class=identifier>test </span><span class=special>= </span><span class=identifier>BOOST_TEST_SUITE</span><span class=special>( </span><span class=string>&quot;List Test Suite&quot; </span><span class=special>);
</span><span class=identifier>test</span><span class=special>-&gt;</span><span class=identifier>add</span><span class=special>( </span><span class=identifier>BOOST_TEST_CASE</span><span class=special>( </span><span class=special>&amp;</span><span class=identifier>test_multi_index_container </span><span class=special>) </span><span class=special>);
</span><span class=keyword>return </span><span class=identifier>test</span><span class=special>;</span>
<span class=special>}
</span>
</pre>
</body>
</html>

View File

@@ -0,0 +1,131 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Boost.Assignment Documentation </title>
<link rel="stylesheet" href="style.css" type="text/css">
</head>
<body>
<pre>
<span class=comment>// 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/
//
</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>detail</span><span class=special>/</span><span class=identifier>workaround</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;
</span>
<span class=preprocessor>#if </span><span class=identifier>BOOST_WORKAROUND</span><span class=special>(</span><span class=identifier>__BORLANDC__</span><span class=special>, </span><span class=identifier>BOOST_TESTED_AT</span><span class=special>(</span><span class=number>0</span><span class=identifier>x564</span><span class=special>))</span>
###<span class=identifier>pragma </span><span class=identifier>warn </span><span class=special>-</span><span class=number>8091 </span><span class=comment>// suppress warning in Boost.Test</span>
###<span class=identifier>pragma </span><span class=identifier>warn </span><span class=special>-</span><span class=number>8057 </span><span class=comment>// unused argument argc/argv in Boost.Test</span>
<span class=preprocessor>#endif
</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>list_inserter</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>test</span><span class=special>/</span><span class=identifier>unit_test</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>test</span><span class=special>/</span><span class=identifier>test_tools</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>function</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>bind</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>vector</span><span class=special>&gt;</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>stdexcept</span><span class=special>&gt;
</span>
<span class=keyword>namespace </span><span class=identifier>ba </span><span class=special>= </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;
</span>
<span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>C </span><span class=special>&gt;</span>
<span class=keyword>class </span><span class=identifier>range_inserter</span>
<span class=special>{
</span><span class=keyword>typedef </span><span class=keyword>typename </span><span class=identifier>C</span><span class=special>::</span><span class=identifier>iterator </span><span class=identifier>iterator</span><span class=special>;
</span><span class=identifier>iterator </span><span class=identifier>begin</span><span class=special>, </span><span class=identifier>end</span><span class=special>;</span>
<span class=keyword>public</span><span class=special>:
</span><span class=identifier>range_inserter</span><span class=special>( </span><span class=identifier>C</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>)
</span><span class=special>: </span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>c</span><span class=special>.</span><span class=identifier>begin</span><span class=special>() </span><span class=special>), </span><span class=identifier>end</span><span class=special>( </span><span class=identifier>c</span><span class=special>.</span><span class=identifier>end</span><span class=special>() </span><span class=special>)
</span><span class=special>{ </span><span class=special>}
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword>void </span><span class=keyword>operator</span><span class=special>()( </span><span class=identifier>T </span><span class=identifier>r </span><span class=special>)
</span><span class=special>{
</span><span class=keyword>if</span><span class=special>( </span><span class=identifier>begin </span><span class=special>== </span><span class=identifier>end </span><span class=special>)
</span><span class=keyword>throw </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>range_error</span><span class=special>( </span><span class=string>&quot;range error: &lt;range_inserter&gt;&quot; </span><span class=special>);
</span><span class=special>*</span><span class=identifier>begin </span><span class=special>= </span><span class=identifier>r</span><span class=special>;
</span><span class=special>++</span><span class=identifier>begin</span><span class=special>;
</span><span class=special>}</span>
<span class=special>};
</span>
<span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>C </span><span class=special>&gt;</span>
<span class=keyword>inline </span><span class=identifier>range_inserter</span><span class=special>&lt;</span><span class=identifier>C</span><span class=special>&gt; </span><span class=identifier>make_range_inserter</span><span class=special>( </span><span class=identifier>C</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>)</span>
<span class=special>{
</span><span class=keyword>return </span><span class=identifier>range_inserter</span><span class=special>&lt;</span><span class=identifier>C</span><span class=special>&gt;( </span><span class=identifier>c </span><span class=special>);</span>
<span class=special>}
</span>
<span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;</span>
<span class=keyword>class </span><span class=identifier>my_vector</span>
<span class=special>{
</span><span class=keyword>typedef </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt; </span><span class=identifier>vector_t</span><span class=special>;
</span><span class=keyword>typedef </span><span class=keyword>typename </span><span class=identifier>vector_t</span><span class=special>::</span><span class=identifier>size_type </span><span class=identifier>size_type</span><span class=special>;
</span><span class=identifier>vector_t </span><span class=identifier>data_</span><span class=special>;
</span>
<span class=keyword>public</span><span class=special>:
</span><span class=identifier>my_vector</span><span class=special>() </span><span class=special>: </span><span class=identifier>data_</span><span class=special>( </span><span class=number>10</span><span class=special>, </span><span class=number>0 </span><span class=special>)
</span><span class=special>{ </span><span class=special>}
</span><span class=identifier>ba</span><span class=special>::</span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=identifier>range_inserter</span><span class=special>&lt; </span><span class=identifier>vector_t </span><span class=special>&gt;, </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword>operator</span><span class=special>=( </span><span class=identifier>T </span><span class=identifier>r </span><span class=special>)
</span><span class=special>{
</span><span class=keyword>return </span><span class=identifier>ba</span><span class=special>::</span><span class=identifier>make_list_inserter</span><span class=special>( </span><span class=identifier>make_range_inserter</span><span class=special>( </span><span class=identifier>data_ </span><span class=special>) </span><span class=special>)( </span><span class=identifier>r </span><span class=special>);
</span><span class=special>}
</span><span class=identifier>size_type </span><span class=identifier>size</span><span class=special>() </span><span class=keyword>const
</span><span class=special>{
</span><span class=keyword>return </span><span class=identifier>data_</span><span class=special>.</span><span class=identifier>size</span><span class=special>();
</span><span class=special>}
</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>[]( </span><span class=identifier>size_type </span><span class=identifier>index </span><span class=special>)
</span><span class=special>{
</span><span class=keyword>return </span><span class=identifier>data_</span><span class=special>.</span><span class=identifier>at</span><span class=special>( </span><span class=identifier>index </span><span class=special>);
</span><span class=special>}</span>
<span class=special>};
</span>
<span class=keyword>void </span><span class=identifier>check_list_inserter</span><span class=special>()</span>
<span class=special>{
</span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;
</span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;
</span><span class=identifier>my_vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>vec</span><span class=special>;
</span><span class=identifier>vec </span><span class=special>= </span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>,</span><span class=number>3</span><span class=special>,</span><span class=number>4</span><span class=special>,</span><span class=number>5</span><span class=special>,</span><span class=number>6</span><span class=special>,</span><span class=number>7</span><span class=special>,</span><span class=number>8</span><span class=special>,</span><span class=number>9</span><span class=special>,</span><span class=number>10</span><span class=special>;
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>vec</span><span class=special>.</span><span class=identifier>size</span><span class=special>(), </span><span class=number>10u </span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>vec</span><span class=special>[</span><span class=number>0</span><span class=special>], </span><span class=number>1 </span><span class=special>);
</span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>vec</span><span class=special>[</span><span class=number>9</span><span class=special>], </span><span class=number>10 </span><span class=special>);</span>
<span class=special>}
</span>
<span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>test</span><span class=special>/</span><span class=identifier>included</span><span class=special>/</span><span class=identifier>unit_test_framework</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;
</span>
<span class=keyword>using </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>unit_test_framework</span><span class=special>::</span><span class=identifier>test_suite</span><span class=special>;
</span>
<span class=identifier>test_suite</span><span class=special>* </span><span class=identifier>init_unit_test_suite</span><span class=special>( </span><span class=keyword>int </span><span class=identifier>argc</span><span class=special>, </span><span class=keyword>char</span><span class=special>* </span><span class=identifier>argv</span><span class=special>[] </span><span class=special>)</span>
<span class=special>{
</span><span class=identifier>test_suite</span><span class=special>* </span><span class=identifier>test </span><span class=special>= </span><span class=identifier>BOOST_TEST_SUITE</span><span class=special>( </span><span class=string>&quot;List Test Suite&quot; </span><span class=special>);
</span><span class=identifier>test</span><span class=special>-&gt;</span><span class=identifier>add</span><span class=special>( </span><span class=identifier>BOOST_TEST_CASE</span><span class=special>( </span><span class=special>&amp;</span><span class=identifier>check_list_inserter </span><span class=special>) </span><span class=special>);
</span><span class=keyword>return </span><span class=identifier>test</span><span class=special>;</span>
<span class=special>}
</span>
</pre>
</body>
</html>

30
libs/assign/doc/style.css Normal file
View File

@@ -0,0 +1,30 @@
/*
#// 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)
*/
pre{
BORDER-RIGHT: gray 1pt solid;
PADDING-RIGHT: 2pt;
BORDER-TOP: gray 1pt solid;
DISPLAY: block;
PADDING-LEFT: 2pt;
PADDING-BOTTOM: 2pt;
BORDER-LEFT: gray 1pt solid;
MARGIN-RIGHT: 32pt;
PADDING-TOP: 2pt;
BORDER-BOTTOM: gray 1pt solid;
FONT-FAMILY: "Courier New", Courier, mono;
background-color: #EEEEEE;
}
.keyword{color: #0000FF;}
.identifier{}
.comment{font-style: italic; color: #008000;}
.special{color: #800040;}
.preprocessor{color: #3F007F;}
.string{font-style: italic; color: #666666;}
.literal{font-style: italic; color: #666666;}

24
libs/assign/index.html Normal file
View File

@@ -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 <20> 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>

View File

@@ -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>"
]
}

View File

@@ -0,0 +1,34 @@
# 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/
#
rule assign-test ( name )
{
return [
run $(name).cpp /boost/test//boost_unit_test_framework/<link>static ]
;
}
test-suite assign :
[ assign-test basic ]
[ assign-test std ]
[ 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 ]
;

View File

@@ -0,0 +1,84 @@
// 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>
void check_array()
{
using namespace std;
using namespace boost;
using namespace boost::assign;
typedef 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 ) );
return test;
}

View File

@@ -0,0 +1,49 @@
// 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 std;
using namespace boost;
using namespace boost::assign;
void check_basic_usage()
{
vector<int> v;
v += 1,2,3,4,5,6,7,8,9;
push_back( v )(10)(11);
map<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;
}

View File

@@ -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;
}

View File

@@ -0,0 +1,156 @@
// 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)
#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;
}

View File

@@ -0,0 +1,301 @@
// 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 );
#else
c3 = ba::list_of(1).repeat_fun( 10, &rand )(2)(3);
BOOST_CHECK_EQUAL( c3.size(), 13u );
#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 usefull 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 wierd 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;
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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;
}

219
libs/assign/test/std.cpp Normal file
View File

@@ -0,0 +1,219 @@
// 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 namespace std;
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;
}

View File

@@ -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;
}