Subject: [Boost-commit] svn:boost r58009 - in sandbox/variadic_templates: boost libs/composite_tagged libs/composite_tagged/sandbox
From: cppljevans_at_[hidden]
Date: 2009-11-28 12:15:56
Author: cppljevans
Date: 2009-11-28 12:15:55 EST (Sat, 28 Nov 2009)
New Revision: 58009
URL: http://svn.boost.org/trac/boost/changeset/58009
Log:
Added composite_tagged files.
These files supersede those in the boost vault
which were mentioned in the spirit general post:
http://sourceforge.net/mailarchive/message.php?msg_name=he6hdk%24f9t%241%40ger.gmane.org
which had headers:
Re: [Spirit-general] another case for tagged variants (was Re: Look mom! No semantic actions.
From: Larry Evans <cppljevans_at_su...> - 2009-11-20 16:51
Added:
sandbox/variadic_templates/boost/composite_tagged.hpp (contents, props changed)
sandbox/variadic_templates/libs/composite_tagged/
sandbox/variadic_templates/libs/composite_tagged/sandbox/
sandbox/variadic_templates/libs/composite_tagged/sandbox/composite_tagged.leaf.test.cpp (contents, props changed)
Added: sandbox/variadic_templates/boost/composite_tagged.hpp
==============================================================================
--- (empty file)
+++ sandbox/variadic_templates/boost/composite_tagged.hpp 2009-11-28 12:15:55 EST (Sat, 28 Nov 2009)
@@ -0,0 +1,931 @@
+#ifndef BOOST_COMPOSITE_TAGGED_INCLUDED//if#BOOST_COMPOSITE_TAGGED_INCLUDED
+#define BOOST_COMPOSITE_TAGGED_INCLUDED
+// (C) Copyright Larry Evans 2009.
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+
+#include <cstddef>
+#include <boost/math/common_factor_ct.hpp>
+#include <boost/aligned_storage.hpp>
+#include <boost/mpl/for_each.hpp>
+
+#include <boost/mpl/fold_assoc_pack.hpp>
+#include <boost/mpl/package_range_c.hpp>
+#include <boost/mpl/mk_indexed_pairs.hpp>
+
+#include <iostream>
+
+namespace boost
+{
+namespace composite_tags
+{
+ struct one_of
+ //composite contains an instance of 'one of' template arguments.
+ ;
+ struct all_of_aligned
+ //composite contains instances of 'all of' template arguments, properly 'aligned'.
+ ;
+ struct all_of_packed
+ //composite contains instances of 'all of' template arguments, 'packed' together.
+ ;
+
+};
+
+ template
+ < class CompositeTag//possibly something from namespace composite_tags.
+ , class IndexType
+ , typename... Components
+ >
+ struct
+composite_tagged
+;
+
+namespace detail_composite_tagged//general
+{
+
+ typedef
+ int
+index_type
+;
+ static
+ index_type const
+index_undefined
+=-1
+;
+ template
+ < index_type Index=index_undefined
+ >
+ struct
+index_wrap
+/**@brief
+ * Used as argument to overloaded functions.
+ * Instances of this type are used to select
+ * which function to call.
+ */
+{
+};
+
+ template
+ < std::size_t Left
+ , std::size_t Right
+ >
+ struct
+compatible_alignment
+/**@brief
+ * "Metafunction" returning alignment which is compatible with the
+ * metafunction argument alignments, Left and Right.
+ *
+ * The real reason why this template was created instead of directly using
+ * static_lcm was to provide the documentation shown below which justifies
+ * static_lcm use.
+ */
+{
+ static
+ std::size_t const
+ value
+ = ::boost::math::static_lcm
+ < (unsigned long)Left
+ , (unsigned long)Right
+ >::value
+ //The use of static_lcm is based on the statement:
+ //
+ // N is the least common multiple of all Alignments
+ //
+ //in paragraph 1 on page 10 of:
+ //
+ // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2165.pdf
+ //
+ //AFAICT, the reason lcm is used instead of just taking the
+ //maximum:
+ //
+ // Left>Right?Left:Right
+ //
+ //is to account for "Extended alignments" mentioned in paragraph 3
+ //on page 3 of the n2165 reference mentioned above. OTOH, if only
+ //"Fundamental alignments" are used (which, I assume, are the
+ //"static alignments;powers of 2" in paragraph 4 on page 5 of:
+ //
+ // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2006/n2140.pdf
+ //
+ //) then simply using max instead of lcm would work.
+ ;
+};
+
+ template
+ < std::size_t Size
+ , std::size_t Align
+ >
+ struct
+aligned_char_storage
+: private ::boost::aligned_storage<Size,Align>
+{
+ typedef
+ ::boost::aligned_storage<Size,Align>
+ super_type
+ ;
+ char const*
+ address(void)const
+ {
+ void const*p=this->super_type::address();
+ return static_cast<char const*>(p);
+ }
+ char*
+ address(void)
+ {
+ void*p=this->super_type::address();
+ return static_cast<char*>(p);
+ }
+
+};
+
+ template
+ < class CompositeTag
+ >
+ struct
+layout_make
+/**@brief
+ * Member template:
+ * push_back
+ * is used to calculate various "layout" traits of a composite.
+ * These traits include at least the size
+ * and possibly the offsets and alignments
+ * of the composite's components.
+ * Also a layout contains injection and projection
+ * functions for creating components of the composite
+ * in a memory buffer and retrieving the components
+ * from that memory buffer.
+ */
+{
+ template
+ < typename HeadLayout //layout of some Composite
+ , typename TailComponent//Type to be appended to some Composite
+ >
+ struct
+ push_back
+ /**@brief
+ * Calculate the layout of composite with component, TailComponent,
+ * appended to a Composite with layout, HeadLayout, and return
+ * layout result in push_back<HeadLayout,TailComponent>::type.
+ */
+ ;
+ struct
+ layout0
+ /**@brief
+ * layout of a composite with 0 components.
+ */
+ ;
+};
+
+}//exit detail_composite_tagged//general
+
+namespace detail_composite_tagged//composite_tags::one_of
+{
+ template
+ <
+ >
+ struct
+layout_make
+ < composite_tags::one_of
+ >
+{
+ struct
+ layout0
+ {
+ static
+ index_type const
+ index_part
+ =index_undefined
+ ;
+ static
+ std::size_t const
+ size_part
+ =0
+ ;
+ static
+ std::size_t const
+ align_part
+ =1
+ ;
+ static
+ void
+ result(index_wrap<index_part>)
+ ;
+ static
+ void
+ inject(index_wrap<index_part> index_arg, char*buffer_composite,...)
+ {
+ }
+ static
+ void const*
+ project(index_wrap<index_part> index_arg, char const*buffer_composite)
+ {
+ return 0;
+ }
+ static
+ void*
+ project(index_wrap<index_part> index_arg, char*buffer_composite)
+ {
+ return 0;
+ }
+ };
+ template
+ < typename HeadLayout
+ , typename TailComponent
+ >
+ struct
+ push_back
+ {
+ struct
+ type
+ : private HeadLayout
+ {
+ static
+ index_type const
+ index_part
+ =HeadLayout::index_part+1
+ ;
+ static
+ std::size_t const
+ size_part
+ =HeadLayout::size_part+sizeof(TailComponent)
+ ;
+ static
+ std::size_t const
+ align_part
+ =compatible_alignment
+ < HeadLayout::align_part
+ , ::boost::alignment_of<TailComponent>::value
+ >::value
+ ;
+ using HeadLayout::
+ result
+ ;
+ static
+ TailComponent
+ result(index_wrap<index_part>)
+ ;
+ using HeadLayout::
+ inject
+ ;
+ static
+ void
+ inject
+ ( index_wrap<index_part> index_arg
+ , char*buffer_composite
+ , TailComponent const& tail_component
+ )
+ {
+ char*buffer_tail=buffer_composite;
+ new(buffer_tail) TailComponent(tail_component);
+ }
+ using HeadLayout::
+ project
+ ;
+ static
+ TailComponent const*
+ project(index_wrap<index_part> index_arg, char const*buffer_composite)
+ {
+ void const*buffer_tail=buffer_composite;
+ TailComponent const*p=static_cast<TailComponent const*>(buffer_tail);
+ return p;
+ }
+ static
+ TailComponent*
+ project(index_wrap<index_part> index_arg, char*buffer_composite)
+ {
+ void*buffer_tail=buffer_composite;
+ TailComponent*p=static_cast<TailComponent*>(buffer_tail);
+ return p;
+ }
+ };
+ };
+
+};
+
+}//exit detail_composite_tagged//composite_tags::one_of
+
+ template
+ < class IndexType
+ , typename... Components
+ >
+ struct
+composite_tagged
+ < composite_tags::one_of
+ , IndexType
+ , Components...
+ >
+{
+ typedef
+ detail_composite_tagged::layout_make<composite_tags::one_of>
+ appender_type
+ ;
+ typedef
+ detail_composite_tagged::index_type
+ index_type
+ ;
+ typedef
+ typename mpl::fold_assoc_pack
+ < mpl::assoc_left
+ , appender_type::template push_back
+ , typename appender_type::layout0
+ , Components...
+ >::type
+ layout_type
+ ;
+ private:
+ detail_composite_tagged::aligned_char_storage
+ < layout_type::size_part
+ , layout_type::align_part
+ >
+ buffer
+ ;
+ index_type
+ my_index
+ ;
+ public:
+ index_type
+ which(void)const
+ {
+ return my_index;
+ }
+ composite_tagged(void)
+ : my_index(detail_composite_tagged::index_undefined)
+ {}
+ template
+ < index_type Index
+ >
+ struct
+ result_type
+ {
+ typedef
+ decltype
+ ( layout_type::result
+ ( detail_composite_tagged::index_wrap<Index>()
+ )
+ )
+ type
+ ;
+ };
+
+ template
+ < IndexType indexValu
+ >
+ void
+ inject
+ ( typename result_type<indexValu>::type const& tail_component
+ )
+ {
+ detail_composite_tagged::index_wrap<indexValu> index;
+ layout_type::inject(index,buffer.address(),tail_component);
+ my_index=indexValu;
+ }
+ template
+ < IndexType indexValu
+ >
+ typename result_type<indexValu>::type const*
+ project(void)const
+ {
+ if(indexValu == my_index)
+ {
+ detail_composite_tagged::index_wrap<indexValu> index;
+ return layout_type::project(index,buffer.address());
+ }
+ else
+ {
+ return 0;
+ }
+ }
+ template
+ < IndexType indexValu
+ >
+ typename result_type<indexValu>::type*
+ project(void)
+ {
+ if(indexValu == my_index)
+ {
+ detail_composite_tagged::index_wrap<indexValu> index;
+ return layout_type::project(index,buffer.address());
+ }
+ else
+ {
+ return 0;
+ }
+ }
+};
+
+#if 1 //if#composite_tags::all_of_packed
+namespace detail_composite_tagged//composite_tags::all_of_packed
+{
+ template
+ <// class CompositeTag
+ >
+ struct
+layout_make
+ < composite_tags::all_of_packed
+ >
+{
+ struct
+ layout0
+ {
+ static
+ index_type const
+ index_part
+ =index_undefined
+ ;
+ static
+ std::size_t const
+ size_part
+ =0
+ ;
+ static
+ std::size_t
+ offset(index_wrap<index_part+1>)
+ {
+ return size_part;
+ }
+ static
+ void
+ result(index_wrap<index_part>)
+ ;
+ static
+ void
+ inject(index_wrap<index_part> index_arg, char*buffer_composite,...)
+ {
+ }
+ static
+ void
+ project(index_wrap<index_part> index_arg, char const*buffer_composite)
+ {
+ }
+ static
+ void
+ project(index_wrap<index_part> index_arg, char*buffer_composite)
+ {
+ }
+ };
+ template
+ < typename HeadLayout
+ , typename TailComponent
+ >
+ struct
+ push_back
+ {
+ struct
+ type
+ : private HeadLayout
+ {
+ static
+ index_type const
+ index_part
+ =HeadLayout::index_part+1
+ ;
+ static
+ std::size_t const
+ size_part
+ =HeadLayout::size_part+sizeof(TailComponent)
+ ;
+ using HeadLayout::
+ offset
+ ;
+ static
+ std::size_t
+ offset(index_wrap<index_part+1>)
+ {
+ return size_part;
+ }
+ using HeadLayout::
+ result
+ ;
+ static
+ TailComponent
+ result(index_wrap<index_part>)
+ ;
+ using HeadLayout::
+ inject
+ ;
+ static
+ void
+ inject
+ ( index_wrap<index_part> index_arg
+ , char*buffer_composite
+ , TailComponent const& tail_component
+ )
+
+ {
+ void*buffer_tail=buffer_composite+HeadLayout::size_part;
+ new(buffer_tail) TailComponent(tail_component);
+ }
+ using HeadLayout::
+ project
+ ;
+ static
+ TailComponent const&
+ project(index_wrap<index_part> index_arg, char const*buffer_composite)
+ {
+ void const*buffer_tail=buffer_composite+HeadLayout::size_part;
+ TailComponent const*p=static_cast<TailComponent const*>(buffer_tail);
+ return *p;
+ }
+ static
+ TailComponent&
+ project(index_wrap<index_part> index_arg, char*buffer_composite)
+ {
+ void*buffer_tail=buffer_composite+HeadLayout::size_part;
+ TailComponent*p=static_cast<TailComponent*>(buffer_tail);
+ return *p;
+ }
+
+ };//end type struct
+ };//end push_back struct
+};//end layout_make struct
+
+ template
+ < typename Layout
+ , typename... Components
+ >
+ struct
+construct_all
+{
+ typedef typename
+ mpl::package_range_c
+ < int
+ , 0
+ , sizeof...(Components)
+ >::type
+ indices
+ ;
+ typedef typename
+ mpl::mk_indexed_pairs
+ < indices
+ , Components...
+ >::type
+ ndx_pairs
+ ;
+ struct
+ initialize_one
+ {
+
+ char*
+ my_buffer
+ ;
+ initialize_one(char* a_buffer)
+ : my_buffer(a_buffer)
+ {}
+ template
+ < class IndexPair
+ >
+ void
+ operator()(IndexPair)const
+ {
+ int const index_part=IndexPair::first::value;
+ index_wrap<index_part> index;
+ typedef typename IndexPair::second value_type;
+ value_type value_val;
+ Layout::inject(index,my_buffer,value_val);
+ }
+
+ };
+ static
+ void
+ initialize_all(char*buffer)
+ {
+ initialize_one initializer(buffer);
+ mpl::for_each<ndx_pairs>(initializer);
+ };
+};
+
+}//exit detail_composite_tagged//composite_tags::all_of_packed
+
+ template
+ < class IndexType
+ , typename... Components
+ >
+ struct
+composite_tagged
+ < composite_tags::all_of_packed
+ , IndexType
+ , Components...
+ >
+{
+ typedef
+ detail_composite_tagged::layout_make<composite_tags::all_of_packed>
+ appender_type
+ ;
+ typedef
+ detail_composite_tagged::index_type
+ index_type
+ ;
+ typedef
+ typename mpl::fold_assoc_pack
+ < mpl::assoc_left
+ , appender_type::template push_back
+ , typename appender_type::layout0
+ , Components...
+ >::type
+ layout_type
+ ;
+ private:
+ char
+ buffer[layout_type::size_part]
+ ;
+ public:
+ composite_tagged(void)
+ {
+ detail_composite_tagged::construct_all<layout_type,Components...>::initialize_all(buffer);
+ }
+
+ template
+ < index_type IndexValu
+ >
+ struct
+ result_type
+ {
+ typedef
+ decltype
+ ( layout_type::result
+ ( detail_composite_tagged::index_wrap<IndexValu>()
+ )
+ )
+ type
+ ;
+ };
+ template
+ < IndexType IndexValu
+ >
+ typename result_type<IndexValu>::type const&
+ project(void)const
+ {
+ detail_composite_tagged::index_wrap<IndexValu> index;
+ return layout_type::project(index,buffer);
+ }
+ template
+ < IndexType IndexValu
+ >
+ typename result_type<IndexValu>::type &
+ project(void)
+ {
+ detail_composite_tagged::index_wrap<IndexValu> index;
+ return layout_type::project(index,buffer);
+ }
+};
+#endif //endif#composite_tags::all_of_packed
+
+#if 1 //if#composite_tags::all_of_aligned
+namespace detail_composite_tagged//composite_tags::all_of_aligned
+{
+ template
+ <// class CompositeTag
+ >
+ struct
+layout_make
+ < composite_tags::all_of_aligned
+ >
+{
+ template
+ < std::size_t Offset
+ , std::size_t Alignment
+ >
+ struct
+ next_aligned_offset
+ {
+ static
+ std::size_t const
+ remainder
+ = Offset%Alignment
+ ;
+ static
+ std::size_t const
+ value
+ = remainder == 0
+ ? Offset
+ : Offset+(Alignment-remainder)
+ //value is minimum value > Offset such that
+ //value%Alignment == 0
+ ;
+
+ };
+
+ struct
+ layout0
+ {
+ static
+ index_type const
+ index_part
+ =index_undefined
+ ;
+ static
+ std::size_t const
+ size_part
+ =0
+ ;
+ static
+ std::size_t const
+ align_part
+ =1
+ ;
+ static
+ std::size_t
+ offset(index_wrap<index_part+1>)
+ {
+ return size_part;
+ }
+ static
+ void
+ result(index_wrap<index_part>)
+ ;
+ static
+ void
+ inject(index_wrap<index_part> index_arg, char*buffer_composite,...)
+ {
+ }
+ static
+ void
+ project(index_wrap<index_part> index_arg, char const*buffer_composite)
+ {
+ }
+ static
+ void
+ project(index_wrap<index_part> index_arg, char*buffer_composite)
+ {
+ }
+ };
+
+ template
+ < typename HeadLayout
+ , typename TailComponent
+ >
+ struct
+ push_back
+ {
+ struct
+ type
+ : private HeadLayout
+ {
+ static
+ index_type const
+ index_part
+ =HeadLayout::index_part+1
+ ;
+ static
+ std::size_t const
+ align_one
+ = ::boost::alignment_of<TailComponent>::value
+ ;
+ static
+ std::size_t const
+ align_part
+ = compatible_alignment
+ < HeadLayout::align_part
+ , align_one
+ >::value
+ ;
+ static
+ std::size_t const
+ size_part
+ = next_aligned_offset
+ < HeadLayout::size_part
+ + sizeof(TailComponent)
+ , align_one
+ >::value
+ ;
+
+ using HeadLayout::
+ offset
+ ;
+ static
+ std::size_t
+ offset(index_wrap<index_part+1>)
+ {
+ return size_part;
+ }
+ using HeadLayout::
+ result
+ ;
+ static
+ TailComponent
+ result(index_wrap<index_part>)
+ ;
+ using HeadLayout::
+ inject
+ ;
+ static
+ void
+ inject
+ ( index_wrap<index_part> index_arg
+ , char*buffer_composite
+ , TailComponent const& tail_component
+ )
+ {
+ void*buffer_tail=buffer_composite+HeadLayout::size_part;
+ new(buffer_tail) TailComponent(tail_component);
+ }
+ using HeadLayout::
+ project
+ ;
+ static
+ TailComponent const&
+ project(index_wrap<index_part> index_arg, char const*buffer_composite)
+ {
+ void const*buffer_tail=buffer_composite+HeadLayout::size_part;
+ TailComponent const*p=static_cast<TailComponent const*>(buffer_tail);
+ return *p;
+ }
+ static
+ TailComponent&
+ project(index_wrap<index_part> index_arg, char*buffer_composite)
+ {
+ void*buffer_tail=buffer_composite+HeadLayout::size_part;
+ TailComponent*p=static_cast<TailComponent*>(buffer_tail);
+ return *p;
+ }
+
+ };//end type struct
+ };//end push_back struct
+};//end layout_make struct
+
+}//exit detail_composite_tagged namespace//composite_tags::all_of_aligned
+
+ template
+ < class IndexType
+ , typename... Components
+ >
+ struct
+composite_tagged
+ < composite_tags::all_of_aligned
+ , IndexType
+ , Components...
+ >
+{
+ typedef
+ detail_composite_tagged::layout_make<composite_tags::all_of_aligned>
+ appender_type
+ ;
+ typedef
+ detail_composite_tagged::index_type
+ index_type
+ ;
+ typedef
+ typename mpl::fold_assoc_pack
+ < mpl::assoc_left
+ , appender_type::template push_back
+ , typename appender_type::layout0
+ , Components...
+ >::type
+ layout_type
+ ;
+ private:
+ detail_composite_tagged::aligned_char_storage
+ < layout_type::size_part
+ , layout_type::align_part
+ >
+ buffer
+ ;
+ public:
+ composite_tagged(void)
+ {
+ char*memory=buffer.address();
+ detail_composite_tagged::construct_all<layout_type,Components...>::initialize_all(memory);
+ }
+
+ template
+ < index_type Index
+ >
+ struct
+ result_type
+ {
+ typedef
+ decltype
+ ( layout_type::result
+ ( detail_composite_tagged::index_wrap<Index>()
+ )
+ )
+ type
+ ;
+ };
+ template
+ < IndexType IndexValu
+ >
+ typename result_type<IndexValu>::type const&
+ project(void)const
+ {
+ detail_composite_tagged::index_wrap<IndexValu> index;
+ return layout_type::project(index,buffer.address());
+ }
+ template
+ < IndexType IndexValu
+ >
+ typename result_type<IndexValu>::type &
+ project(void)
+ {
+ detail_composite_tagged::index_wrap<IndexValu> index;
+ return layout_type::project(index,buffer.address());
+ }
+};
+#endif //endif#composite_tags::all_of_aligned
+
+}//exit boost namespace
+#endif //endif#BOOST_COMPOSITE_TAGGED_INCLUDED
Added: sandbox/variadic_templates/libs/composite_tagged/sandbox/composite_tagged.leaf.test.cpp
==============================================================================
--- (empty file)
+++ sandbox/variadic_templates/libs/composite_tagged/sandbox/composite_tagged.leaf.test.cpp 2009-11-28 12:15:55 EST (Sat, 28 Nov 2009)
@@ -0,0 +1,261 @@
+
+#include <boost/composite_tagged.hpp>
+
+#include <iostream>
+namespace boost
+{
+namespace composite_tagged_leaf
+{
+ template
+ < unsigned I
+ >
+ struct
+charvec_u
+{
+ char v[2*(I+1)];
+ unsigned tag(void)const
+ {
+ return I;
+ }
+ charvec_u(void)
+ {
+ v[0]='a';
+ v[1]='\0';
+ }
+};
+
+ enum
+index_numerals
+{ index_0
+, index_1
+, index_2
+, index_3
+, index_4
+};
+
+void test(void)
+{
+#if 0
+ {
+ typedef
+ detail::layout_make
+ < composite_tags::one_of
+ >::push_back
+ < detail::size_alignment<>
+ , detail::size_alignment<2,9>
+ >::type
+ tp_type
+ ;
+ std::cout
+ <<"***layout_make<one_of>::push_back<<>,<2,9>>\n"
+ <<":size="<<tp_type::size_part<<"\n"
+ <<":alignment="<<tp_type::align_part<<"\n"
+ ;
+ }
+#endif
+#if 1
+ {
+ typedef
+ composite_tagged
+ < composite_tags::one_of
+ , index_numerals
+ , charvec_u<0>
+ , charvec_u<1>
+ >
+ tagged_type
+ ;
+ typedef
+ tagged_type::layout_type
+ layout_type
+ ;
+ std::cout
+ <<"***composite_tagged<one_of>:\n"
+ <<":size="<<layout_type::size_part<<"\n"
+ <<":alignment="<<layout_type::align_part<<"\n"
+ ;
+ tagged_type
+ tagged_values
+ ;
+ charvec_u<0>*
+ t0
+ ;
+ charvec_u<1>*
+ t1
+ ;
+ std::cout
+ <<"which="<<tagged_values.which()<<"\n";
+ t0=tagged_values.project<index_0>();
+ std::cout
+ <<"t0="<<t0<<"\n";
+ t1=tagged_values.project<index_1>();
+ std::cout
+ <<"t1="<<t1<<"\n";
+
+ tagged_values.inject<index_0>(charvec_u<0>());
+ std::cout
+ <<"which="<<tagged_values.which()<<"\n";
+ t0=tagged_values.project<index_0>();
+ std::cout
+ <<"t0="<<t0<<"\n";
+ t1=tagged_values.project<index_1>();
+ std::cout
+ <<"t1="<<t1<<"\n";
+
+ tagged_values.inject<index_1>(charvec_u<1>());
+ std::cout
+ <<"which="<<tagged_values.which()<<"\n";
+ t0=tagged_values.project<index_0>();
+ std::cout
+ <<"t0="<<t0<<"\n";
+ t1=tagged_values.project<index_1>();
+ std::cout
+ <<"t1="<<t1<<"\n";
+ }
+#endif
+#if 0
+ {
+ std::cout
+ <<"sizeof(charvec_u<0>)="<<sizeof(charvec_u<0>)<<"\n"
+ <<"sizeof(charvec_u<1>)="<<sizeof(charvec_u<1>)<<"\n"
+ <<"sizeof(charvec_u<2>)="<<sizeof(charvec_u<2>)<<"\n"
+ ;
+ typedef
+ detail::layout_make
+ < composite_tags::all_of_packed
+ >::layout0
+ tp0_type
+ ;
+ typedef
+ detail::layout_make
+ < composite_tags::all_of_packed
+ >::push_back
+ < tp0_type
+ , charvec_u<0>
+ >::type
+ tp1_type
+ ;
+ std::cout
+ <<"***layout_make<all_of_packed>::push_back<tp0_type,charvec_u<0> >\n"
+ <<":size="<<tp1_type::size_part<<"\n"
+ <<":index="<<tp1_type::index_part<<"\n"
+ <<":offset(0)="<<tp1_type::offset(index_wrap<0>())<<"\n"
+ ;
+ typedef
+ detail::layout_make
+ < composite_tags::all_of_packed
+ >::push_back
+ < tp1_type
+ , charvec_u<1>
+ >::type
+ tp2_type
+ ;
+ std::cout
+ <<"***layout_make<all_of_packed>::push_back<tp1_type,charvec_u<1> >\n"
+ <<":size="<<tp2_type::size_part<<"\n"
+ <<":index="<<tp2_type::index_part<<"\n"
+ <<":offset(1)="<<tp2_type::offset(index_wrap<1>())<<"\n"
+ ;
+ typedef
+ detail::layout_make
+ < composite_tags::all_of_packed
+ >::push_back
+ < tp2_type
+ , charvec_u<2>
+ >::type
+ tp3_type
+ ;
+ std::cout
+ <<"***layout_make<all_of_packed>::push_back<tp2_type,charvec_u<2> >\n"
+ <<":size="<<tp3_type::size_part<<"\n"
+ <<":index="<<tp3_type::index_part<<"\n"
+ <<":offset(2)="<<tp3_type::offset(index_wrap<2>())<<"\n"
+ ;
+ std::cout
+ <<":offset(3)="<<tp3_type::offset(index_wrap<3>())<<"\n"
+ ;
+ }
+#endif
+#if 1
+ {
+ typedef
+ composite_tagged
+ < composite_tags::all_of_packed
+ , index_numerals
+ , charvec_u<0>
+ , charvec_u<1>
+ , charvec_u<2>
+ >
+ tagged_type
+ ;
+ typedef
+ tagged_type::layout_type
+ layout_type
+ ;
+ tagged_type
+ tagged_valu
+ ;
+ std::cout
+ <<"***composite_tagged<all_of_packed>:\n"
+ <<":size="<<layout_type::size_part<<"\n"
+ <<":offset<0>="<<layout_type::offset(detail_composite_tagged::index_wrap<0>())<<"\n"
+ <<":offset<1>="<<layout_type::offset(detail_composite_tagged::index_wrap<1>())<<"\n"
+ <<":offset<2>="<<layout_type::offset(detail_composite_tagged::index_wrap<2>())<<"\n"
+ <<":offset<3>="<<layout_type::offset(detail_composite_tagged::index_wrap<3>())<<"\n"
+ <<":project<index_0>="<<tagged_valu.project<index_0>().v<<"\n"
+ <<":project<index_1>="<<tagged_valu.project<index_1>().v<<"\n"
+ ;
+ tagged_valu.project<index_1>().v[0]='b';
+ std::cout
+ <<"***composite_tagged<all_of_packed>:\n"
+ <<" (after project<index_1>='b')\n"
+ <<":project<index_1>="<<tagged_valu.project<index_1>().v<<"\n"
+ ;
+ }
+#endif
+#if 1
+ {
+ typedef
+ composite_tagged
+ < composite_tags::all_of_aligned
+ , index_numerals
+ , charvec_u<0>
+ , charvec_u<1>
+ , charvec_u<2>
+ >
+ tagged_type
+ ;
+ typedef
+ tagged_type::layout_type
+ layout_type
+ ;
+ tagged_type
+ tagged_valu
+ ;
+ std::cout
+ <<"***composite_tagged<all_of_aligned>:\n"
+ <<":size="<<layout_type::size_part<<"\n"
+ <<":offset<0>="<<layout_type::offset(detail_composite_tagged::index_wrap<0>())<<"\n"
+ <<":offset<1>="<<layout_type::offset(detail_composite_tagged::index_wrap<1>())<<"\n"
+ <<":offset<2>="<<layout_type::offset(detail_composite_tagged::index_wrap<2>())<<"\n"
+ <<":offset<3>="<<layout_type::offset(detail_composite_tagged::index_wrap<3>())<<"\n"
+ <<":project<index_0>="<<tagged_valu.project<index_0>().v<<"\n"
+ <<":project<index_1>="<<tagged_valu.project<index_1>().v<<"\n"
+ ;
+ tagged_valu.project<index_1>().v[0]='b';
+ std::cout
+ <<"***composite_tagged<all_of_packed>:\n"
+ <<" (after project<index_1>='b')\n"
+ <<":project<index_1>="<<tagged_valu.project<index_1>().v<<"\n"
+ ;
+ }
+#endif
+}
+
+}//exit composite_tagged_leaf namespace
+}//exit boost namespace
+
+int main(void)
+{
+ boost::composite_tagged_leaf::test();
+ return 0;
+}