[Boost-commit] svn:boost r63326 - in sandbox/variadic_templates/libs/composite_storage: . sandbox sandbox/pack

Subject: [Boost-commit] svn:boost r63326 - in sandbox/variadic_templates/libs/composite_storage: . sandbox sandbox/pack
From: cppljevans_at_[hidden]
Date: 2010-06-25 15:44:47

Author: cppljevans
Date: 2010-06-25 15:44:46 EDT (Fri, 25 Jun 2010)
New Revision: 63326
URL: http://svn.boost.org/trac/boost/changeset/63326

Log:
leaf tests and multiple_dispatch test
Added:
   sandbox/variadic_templates/libs/composite_storage/
   sandbox/variadic_templates/libs/composite_storage/sandbox/
   sandbox/variadic_templates/libs/composite_storage/sandbox/pack/
   sandbox/variadic_templates/libs/composite_storage/sandbox/pack/composite_storage.leaf.test.cpp   (contents, props changed)
   sandbox/variadic_templates/libs/composite_storage/sandbox/pack/one_of_multiple_dispatch.test.cpp   (contents, props changed)

Added: sandbox/variadic_templates/libs/composite_storage/sandbox/pack/composite_storage.leaf.test.cpp
==============================================================================
--- (empty file)
+++ sandbox/variadic_templates/libs/composite_storage/sandbox/pack/composite_storage.leaf.test.cpp	2010-06-25 15:44:46 EDT (Fri, 25 Jun 2010)
@@ -0,0 +1,577 @@
+//ChangeLog:
+//  2010-05-22.0902
+//    WHAT:
+//      cp'ed from /home/evansl/prog_dev/boost-svn/ro/trunk
+//        /sandbox-local/lje/libs/composite_tagged_seq/sandbox
+//        /composite_tagged_seq.leaf.test.cpp
+//    WHY:
+//      Modify for use with variadic template version of similar composite classes.
+//
+//#include <boost/composite_storage/pack/container_all_of_aligned.hpp>
+#include <boost/composite_storage/pack/container_one_of_maybe.hpp>
+
+#include <boost/iostreams/utility/indent_ostream.hpp>
+#include <string>
+#include <iostream>
+
+#include "../../utility/curried_offset.hpp"
+
+#include <boost/assert.hpp>
+
+    typedef
+  ::boost::iostreams::indent_ostream<>
+ind_ostream
+;
+    static
+  ind_ostream
+ind_out(std::cout)
+;
+struct trace_scope
+{
+    trace_scope(std::string const& a_where)
+    : my_where(a_where)
+    {
+        ind_out<<"[[[ENTERING:"<<my_where<<"\n";
+        ++ind_out;
+    }
+    ~trace_scope(void)
+    {
+        --ind_out;
+        ind_out<<"]]]EXITING:"<<my_where<<"\n";
+    }
+ private:
+      std::string
+    my_where
+    ;    
+};  
+
+namespace boost
+{
+namespace composite_storage
+{
+namespace leaf_test
+{
+
+    static
+  unsigned
+object_id
+=0
+;
+    static
+  int
+object_number
+=0
+;
+struct obj
+{
+      unsigned const
+    my_id
+    ;
+      unsigned
+    id_get(void)const
+    {
+        return my_id;
+    }
+    obj(void)
+    : my_id(++object_id)
+    {
+        ++object_number;
+    }
+    obj(obj const&)
+    : my_id(++object_id)
+    {
+        ++object_number;
+    }
+    ~obj(void)
+    {
+        --object_number;
+    }
+      void
+    operator=(obj const&)
+    {}
+};
+  template
+  < unsigned I
+  >
+  struct
+charvec_u
+: obj
+{
+    char v[2*(I+1)];
+    unsigned tag(void)const
+    {
+        return I;
+    }
+    charvec_u(void)
+    {
+        v[0]='a';
+        v[1]='\0';
+    }
+};
+
+  template
+  < unsigned I
+  >
+  std::ostream&
+operator<<
+  ( std::ostream& sout
+  , charvec_u<I>const& x
+  )
+{
+    sout
+      <<"charvec_u<"<<I<<">"
+      <<":id_get="<<x.id_get()
+      <<":v[0]="<<x.v[0]
+      ;
+    return sout;
+}  
+
+  enum
+index_numerals
+{ index_0
+, index_1
+, index_2
+, index_3
+, index_4
+};
+
+void test(void)
+{
+#if 1
+    ind_out<<"object_number="<<object_number<<"\n";
+    {    
+        trace_scope ts("one_of_maybe on non-class types TESTS");
+            typedef
+          pack::container
+          < tags::one_of_maybe
+          , mpl::integral_c<index_numerals,index_0>
+          , int
+          , float
+          >
+        tagged_type
+        ;
+            typedef
+          tagged_type::layout_comp::scanned
+        layout_scanned
+        ;
+        ind_out
+          <<"***composite_storage<one_of_maybe>:\n"
+          <<":size="<<layout_scanned::comp_part::size<<"\n"
+          <<":alignment="<<layout_scanned::comp_part::align<<"\n"
+        ;
+        {
+            trace_scope ts("default CTOR");
+              tagged_type 
+            tagged_values
+            ;
+              int*
+            t0
+            ;
+              float*
+            t1
+            ;
+            ind_out
+              <<"which="<<tagged_values.which()<<"\n";
+              
+            tagged_values.inject<index_0>(9);
+            ind_out
+              <<"which="<<tagged_values.which()<<"\n";
+            t0=&tagged_values.project<index_0>();
+            ind_out
+              <<"t0="<<*t0<<"\n";
+
+            tagged_values.inject<index_1>(8.5);
+            ind_out
+              <<"which="<<tagged_values.which()<<"\n";
+            t1=&tagged_values.project<index_1>();
+            ind_out
+              <<"t1="<<*t1<<"\n";
+
+        }
+    } 
+    {    
+        trace_scope ts("one_of_maybe on class types TESTS");
+            typedef
+          pack::container
+          < tags::one_of_maybe
+          , mpl::integral_c<index_numerals,index_0>
+          , charvec_u<0>
+          , charvec_u<1>
+          >
+        tagged_type
+        ;
+            typedef
+          tagged_type::layout_comp::scanned
+        layout_scanned
+        ;
+        ind_out
+          <<"***composite_storage<one_of_maybe>:\n"
+          <<":size="<<layout_scanned::comp_part::size<<"\n"
+          <<":alignment="<<layout_scanned::comp_part::align<<"\n"
+        ;
+        {
+            trace_scope ts("default CTOR");
+              tagged_type 
+            tagged_values
+            ;
+              charvec_u<0>*
+            t0
+            ;
+              charvec_u<1>*
+            t1
+            ;
+            ind_out
+              <<"which="<<tagged_values.which()<<"\n";
+              
+            tagged_values.inject<index_0>(charvec_u<0>());
+            ind_out
+              <<"which="<<tagged_values.which()<<"\n";
+            t0=&tagged_values.project<index_0>();
+            ind_out
+              <<"t0="<<*t0<<"\n";
+              
+            unsigned obj_id_saved=t0->id_get();
+              
+            tagged_values.inject<index_1>(charvec_u<1>());
+            ind_out
+              <<"which="<<tagged_values.which()<<"\n";
+            t1=&tagged_values.project<index_1>();
+            ind_out
+              <<"t1="<<*t1<<"\n";
+              
+            //Only 2 more objects should have been created since
+            //obj_id_saved was set:
+            //  1)  The charvec_u<1>() arg to inject<index_1>
+            //  2)  The charvec_u<1> actually injected into tagged_values
+            //Check that:
+            BOOST_ASSERT((obj_id_saved+2==t1->id_get()));
+              
+            ind_out
+              <<"assign_test:\n";
+              tagged_type
+            tagged_from
+            ;
+            tagged_values=tagged_from;
+                    ind_out
+              <<"which="<<tagged_values.which()<<"\n";
+        }
+        {
+            trace_scope ts("index_component CTOR");
+                typedef
+              tagged_type::index_component<index_1,charvec_u<1>const&>
+            index_component_1_type
+            ;
+              tagged_type 
+            tagged_values
+              ( index_component_1_type::_()
+              )
+            ;
+            ind_out
+              <<"which="<<tagged_values.which()<<"\n";
+        }
+      #if 0
+        {
+            //2010-03-19:
+            //  This feature:
+            //    CTOR arg pairs where 1st arg is index
+            //    and 2dn arg is value,
+            //  is not implemented yet.  Instead, please
+            //  use the index_component CTOR feature
+            //  (whose test is immediately above).
+            //
+            trace_scope ts("assign_at CTOR");
+              tagged_type 
+            tagged_values
+              ( index_1
+              , charvec_u<1>()
+              )
+            ;
+            ind_out
+              <<"which="<<tagged_values.which()<<"\n";
+        }
+      #endif
+
+    }
+#endif    
+#if 0
+    ind_out<<"object_number="<<object_number<<"\n";
+    {
+        trace_scope ts("all_of_packed layout_operators TESTS");
+        ind_out
+          <<"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
+          mpl::integral_c<int,-1>
+        index_undef
+        ;
+            typedef
+          detail_composite_tagged::layout_operators
+          < tags::all_of_packed
+          >::layout0<index_undef>
+        tp0_type
+        ;
+        ind_out
+          <<"***layout_operators<all_of_packed>::layout0<integral_c<int,-1>\n"
+          <<":size="<<tp0_type::comp_part::size<<"\n"
+          <<":index="<<tp0_type::index_part::value<<"\n"
+        ;
+            typedef
+          detail_composite_tagged::layout_operators
+          < tags::all_of_packed
+          >::push_back
+          < tp0_type
+          , charvec_u<0>
+          >::type
+        tp1_type
+        ;
+        ind_out
+          <<"***layout_operators<all_of_packed>::push_back<tp0_type,charvec_u<0> >\n"
+          <<":size="<<tp1_type::comp_part::size<<"\n"
+          <<":index="<<tp1_type::index_part::value<<"\n"
+          <<":offset(0)="<<tp1_type::comp_part::offset<<"\n"
+        ;
+            typedef
+          detail_composite_tagged::layout_operators
+          < tags::all_of_packed
+          >::push_back
+          < tp1_type
+          , charvec_u<1>
+          >::type
+        tp2_type
+        ;
+        ind_out
+          <<"***layout_operators<all_of_packed>::push_back<tp1_type,charvec_u<1> >\n"
+          <<":size="<<tp2_type::comp_part::size<<"\n"
+          <<":index="<<tp2_type::index_part::value<<"\n"
+          <<":offset(1)="<<tp2_type::comp_part::offset<<"\n"
+        ;
+            typedef
+          detail_composite_tagged::layout_operators
+          < tags::all_of_packed
+          >::push_back
+          < tp2_type
+          , charvec_u<2>
+          >::type
+        tp3_type
+        ;
+        ind_out
+          <<"***layout_operators<all_of_packed>::push_back<tp2_type,charvec_u<2> >\n"
+          <<":size="<<tp3_type::comp_part::size<<"\n"
+          <<":index="<<tp3_type::index_part::value<<"\n"
+          <<":offset(2)="<<tp3_type::comp_part::offset<<"\n"
+        ;
+    }
+#endif    
+#if 0
+    ind_out<<"object_number="<<object_number<<"\n";
+    {    
+        trace_scope ts("all_of_packed composite_storage TESTS");
+            typedef
+          pack::container
+          < tags::all_of_packed
+          , mpl::integral_c<index_numerals,index_0>
+          , charvec_u<0>
+          , charvec_u<1>
+          , charvec_u<2>
+          >
+        tagged_type
+        ;
+            typedef
+          libs::composite_storage::utility::curried_offset<tagged_type>
+        cur_off
+        ;
+            typedef
+          tagged_type::layout_comp::scanned
+        layout_scanned
+        ;
+            typedef
+          tagged_type::index_base
+        index_base
+        ;
+          tagged_type
+        tagged_valu
+        ;
+        ind_out
+          <<"***composite_storage<all_of_packed>:\n"
+          <<":size="<<layout_scanned::comp_part::size<<"\n"
+          <<":offset<0>="<<cur_off::offset_at<index_0>::value<<"\n"
+          <<":offset<1>="<<cur_off::offset_at<index_1>::value<<"\n"
+          <<":offset<2>="<<cur_off::offset_at<index_2>::value<<"\n"
+        #if 0
+          //This will cause compile error since only 3 elments in composite.
+          <<":offset<3>="<<cur_off::offset_at<index_3>::value<<"\n"
+        #endif
+        ;
+        
+        charvec_u<index_1> c_1;
+        c_1.v[0]='b';
+        ind_out
+          <<"  (before project<index_1>='b')\n"
+          <<":c_1.v="<<c_1.v<<"\n";
+        tagged_valu.project<index_1>(c_1);
+        ind_out
+          <<"  (after project<index_1>='b')\n"
+          <<":c_1.v="<<c_1.v<<"\n";
+        c_1.v[0]='c';
+        ind_out
+          <<"  (before inject<index_1>='c')\n"
+          <<":c_1.v="<<c_1.v<<"\n";
+        tagged_valu.inject<index_1>(c_1);
+        ind_out
+          <<"  (after inject<index_1>='c')\n"
+          <<":c_1.v="<<c_1.v<<"\n";
+        c_1.v[0]='d';
+        tagged_valu.project<index_1>(c_1);
+        ind_out
+          <<"  (after project<index_1>='d')\n"
+          <<":c_1.v="<<c_1.v<<"\n";
+          
+        charvec_u<index_2> c_2;
+        c_2.v[0]='b';
+        ind_out
+          <<"  (before project<index_2>='b')\n"
+          <<":c_2.v="<<c_2.v<<"\n";
+        tagged_valu.project<index_2>(c_2);
+        ind_out
+          <<"  (after project<index_2>='b')\n"
+          <<":c_2.v="<<c_2.v<<"\n";
+        c_2.v[0]='c';
+        ind_out
+          <<"  (before inject<index_2>='c')\n"
+          <<":c_2.v="<<c_2.v<<"\n";
+        tagged_valu.inject<index_2>(c_2);
+        ind_out
+          <<"  (after inject<index_2>='c')\n"
+          <<":c_2.v="<<c_2.v<<"\n";
+        c_2.v[0]='d';
+        tagged_valu.project<index_2>(c_2);
+        ind_out
+          <<"  (after project<index_2>='d')\n"
+          <<":c_2.v="<<c_2.v<<"\n";
+          
+    }
+#endif    
+#if 0
+    ind_out<<"object_number="<<object_number<<"\n";
+    {    
+        trace_scope ts("all_of_aligned composite_storage TESTS");
+            typedef
+          pack::container
+          < tags::all_of_aligned
+          , mpl::integral_c<index_numerals,index_0>
+          , charvec_u<0>
+          , charvec_u<1>
+          , charvec_u<2>
+          >
+        tagged_type
+        ;
+            typedef
+          libs::composite_storage::utility::curried_offset<tagged_type>
+        cur_off
+        ;
+            typedef
+          tagged_type::layout_comp::scanned
+        layout_scanned
+        ;
+            typedef
+          tagged_type::index_base
+        index_base
+        ;
+          tagged_type
+        tagged_valu
+        ;
+        ind_out
+          <<"***composite_storage<all_of_aligned>:\n"
+          <<":size="<<layout_scanned::comp_part::size<<"\n"
+          <<":offset<0>="<<cur_off::offset_at<index_0>::value<<"\n"
+          <<":offset<1>="<<cur_off::offset_at<index_1>::value<<"\n"
+          <<":offset<2>="<<cur_off::offset_at<index_2>::value<<"\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';
+        ind_out
+          <<"***composite_storage<all_of_aligned>:\n"
+          <<"  (after project<index_1>='b')\n"
+          <<":project<index_1>="<<tagged_valu.project<index_1>().v<<"\n"
+        ;
+    }
+#endif
+#if 0
+    ind_out<<"object_number="<<object_number<<"\n";
+    {    
+        trace_scope ts("all_of_aligned min end pad DEMO");
+            typedef
+          pack::container
+          < tags::all_of_aligned
+          , mpl::integral_c<index_numerals,index_0>
+          , char
+          , int
+          , double
+          >
+        tagged_type
+        ;
+            typedef
+          libs::composite_storage::utility::curried_offset<tagged_type>
+        cur_off
+        ;
+            typedef
+          tagged_type::layout_comp::scanned
+        layout_scanned
+        ;
+        ind_out
+          <<"***composite_storage<all_of_aligned> min end pad:\n"
+          <<":size scan="<<layout_scanned::comp_part::size<<"\n"
+          <<":offset<0>="<<cur_off::offset_at<index_0>::value<<"\n"
+          <<":offset<1>="<<cur_off::offset_at<index_1>::value<<"\n"
+          <<":offset<2>="<<cur_off::offset_at<index_2>::value<<"\n"
+          <<":size composite="<<sizeof(tagged_type)<<"\n"
+          <<":end pad="<<(sizeof(tagged_type)-layout_scanned::comp_part::size)<<"\n"
+          ;
+    }
+    ind_out<<"object_number="<<object_number<<"\n";
+    {    
+        trace_scope ts("all_of_aligned max end pad DEMO");
+            typedef
+          pack::container
+          < tags::all_of_aligned
+          , mpl::integral_c<index_numerals,index_0>
+          , double
+          , int
+          , char
+          >
+        tagged_type
+        ;
+            typedef
+          libs::composite_storage::utility::curried_offset<tagged_type>
+        cur_off
+        ;
+            typedef
+          tagged_type::layout_comp::scanned
+        layout_scanned
+        ;
+        ind_out
+          <<"***composite_storage<all_of_aligned> max end pad:\n"
+          <<":size scan="<<layout_scanned::comp_part::size<<"\n"
+          <<":offset<0>="<<cur_off::offset_at<index_0>::value<<"\n"
+          <<":offset<1>="<<cur_off::offset_at<index_1>::value<<"\n"
+          <<":offset<2>="<<cur_off::offset_at<index_2>::value<<"\n"
+          <<":size composite="<<sizeof(tagged_type)<<"\n"
+          <<":end pad="<<(sizeof(tagged_type)-layout_scanned::comp_part::size)<<"\n"
+          ;
+    }
+#endif    
+    ind_out<<"final:object_number="<<object_number<<"\n";
+}
+
+}//exit leaf_test
+}//exit composite_storage
+}//exit boost namespace
+
+int main(void)
+{
+    boost::composite_storage::leaf_test::test();
+    return 0;
+}    

Added: sandbox/variadic_templates/libs/composite_storage/sandbox/pack/one_of_multiple_dispatch.test.cpp
==============================================================================
--- (empty file)
+++ sandbox/variadic_templates/libs/composite_storage/sandbox/pack/one_of_multiple_dispatch.test.cpp	2010-06-25 15:44:46 EDT (Fri, 25 Jun 2010)
@@ -0,0 +1,395 @@
+#include <boost/iostreams/utility/indent_scoped_ostreambuf.hpp>
+#include <iostream>
+#include <string>
+#include <boost/mpl/assert.hpp>
+typedef std::ostream ind_ostream;
+static std::ostream& ind_out=std::cout;
+struct trace_scope
+{
+    trace_scope(std::string const& a_where)
+    : my_where(a_where)
+    {
+        ind_out<<"[[[ENTERING:"<<my_where<<"\n";
+        ind_out<<indent_buf_in;
+    }
+    ~trace_scope(void)
+    {
+        ind_out<<indent_buf_out;
+        ind_out<<"]]]EXITING:"<<my_where<<"\n";
+    }
+ private:
+      std::string
+    my_where
+    ;    
+};  
+  #if 1
+    #define FUNCTOR_CONSTANCY const
+  #else
+    #define FUNCTOR_CONSTANCY
+  #endif
+//#include <boost/composite_storage/pack/one_of_multiple_dispatch.hpp>
+#include <boost/composite_storage/pack/multiple_dispatch/reify_apply.hpp>
+#include <boost/composite_storage/pack/multiple_dispatch/reifier_switch.hpp>
+#include <boost/composite_storage/pack/multiple_dispatch/reifier_visitor.hpp>
+#include <boost/composite_storage/pack/container_one_of_maybe.hpp>
+
+namespace boost
+{
+namespace composite_storage
+{
+namespace pack
+{
+namespace multiple_dispatch
+{
+namespace testing
+{
+    static
+  unsigned
+object_id
+=0
+;
+    static
+  int
+object_number
+=0
+;
+  template
+  < unsigned I
+  , typename ResultType=int
+  >
+struct host_concrete
+;
+  template
+  < typename Indices
+  , typename ResultType
+  >
+struct hosts_indices_concrete
+;  
+  template
+  < unsigned... Indices
+  , typename ResultType
+  >
+struct hosts_indices_concrete
+  < mpl::package_c<unsigned, Indices...>
+  , ResultType
+  >
+{
+    typedef mpl::package<host_concrete<Indices,ResultType>...> type;
+};
+
+  template
+  < typename ResultType=int
+  >
+struct host_abstract
+;
+
+}//exit testing namespace
+  template
+  < typename ResultType
+  >
+struct hosts_concrete
+  < testing::host_abstract<ResultType>
+  >  
+: testing::hosts_indices_concrete
+  < mpl::package_range_c<unsigned, 0,3>::type
+  , ResultType
+  >
+{
+};
+
+namespace testing
+{
+  template
+  < typename ResultType
+  >
+struct host_abstract
+{
+      unsigned const
+    my_id
+    ;
+    host_abstract(void)
+    : my_id(++object_id)
+    {
+        ++object_number;
+    }
+    host_abstract(host_abstract const&)
+    : my_id(++object_id)
+    {
+        ++object_number;
+    }
+    ~host_abstract(void)
+    {
+        --object_number;
+    }
+      void
+    operator=(host_abstract const&)
+    {}
+    
+        typedef
+      reifier_visit_abstract_seq
+      < ResultType
+      , typename hosts_concrete<host_abstract>::type
+      >
+    visitor_abstract
+    ;
+        virtual
+      ResultType 
+    accept
+      ( visitor_abstract const&
+      )const
+    =0
+    ;
+};
+  template
+  < unsigned I
+  , typename ResultType
+  >
+struct host_concrete
+: host_abstract<ResultType>
+{
+    char v[2*(I+1)];
+    unsigned tag(void)const
+    {
+        return I;
+    }
+    host_concrete(void)
+    {
+        v[0]='a';
+        v[1]='\0';
+    }
+        typedef
+      typename host_abstract<ResultType>::visitor_abstract
+    visitor_abstract
+    ;
+      ResultType 
+    accept
+      ( visitor_abstract const& a_visitor
+      )const
+    {
+        return a_visitor.visit(*this);
+    }
+};
+
+  template
+  < unsigned I
+  , typename ResultType
+  >
+  ind_ostream&
+operator<<
+  ( ind_ostream& sout
+  , host_concrete<I,ResultType>const& x
+  )
+  {
+      sout<<":host_concrete<"<<I<<">(my_id="<<x.my_id<<")";
+      return sout;
+  }
+  
+  enum
+index_numerals
+{ index_0
+, index_1
+, index_2
+, index_3
+, index_4
+};
+
+struct functor_any
+{
+    functor_any(void)
+    {}
+
+    typedef int result_type;
+    
+    static void print(unsigned index)
+    {
+        ind_out<<":index(last)="<<index<<"\n";
+    }
+    template<typename Head, typename... Tail>
+    static void print(unsigned index, Head const& a_head, Tail const&... a_tail)
+    {
+        ind_out<<":index="<<index<<":a_head=";
+        ind_out<<a_head<<"\n";
+        print(index+1,a_tail...);
+    }
+    
+    template<typename... Args>
+    int operator()(Args const&... args)const
+    {
+        unsigned const arity=sizeof...(Args);
+        ind_out<<"functor_any:arity="<<arity<<"\n";
+        print(0,args...);
+        return arity;
+    }
+}; 
+
+struct functor3
+{
+    functor3(void)
+    {}
+    
+    typedef int result_type;
+    
+    int operator()
+      ( void
+      )FUNCTOR_CONSTANCY
+    {
+        ind_out<<"functor3:arity=0.\n";
+        return 0;
+    }
+    int operator()
+      ( host_concrete<0>const&a0
+      )FUNCTOR_CONSTANCY
+    {
+        ind_out<<"functor3:arity=1:\n";
+        ind_out<<":a0="<<a0<<"\n";
+        return 0;
+    }
+    int operator()
+      ( host_concrete<1>const&a0
+      )FUNCTOR_CONSTANCY
+    {
+        ind_out<<"functor3:arity=1:";
+        ind_out<<":a0="<<a0<<"\n";
+        return 0;
+    }
+    int operator()
+      ( host_concrete<2>const&a0
+      )FUNCTOR_CONSTANCY
+    {
+        ind_out<<"functor3:arity=1:";
+        ind_out<<":a0="<<a0<<"\n";
+        return 0;
+    }
+    int operator()
+      ( host_concrete<0>const&a0
+      , host_concrete<1>const&a1
+      )FUNCTOR_CONSTANCY
+    {
+        ind_out<<"functor3:arity=2:\n";
+        ind_out<<":a0="<<a0<<"\n";
+        ind_out<<":a1="<<a1<<"\n";
+        return 0;
+    }
+};
+
+void test(void)
+{
+#if 1
+    ind_out<<"object_number="<<object_number<<"\n";
+    {    
+        trace_scope ts("one_of_multiple_dispatch TESTS");
+            typedef
+          pack::container
+          < tags::one_of_maybe
+          , mpl::integral_c<index_numerals,index_0>
+          , host_concrete<0>
+          , host_concrete<1>
+          , host_concrete<2>
+          >
+        tagged_type
+        ;
+          unsigned const 
+        arity=3
+        ;
+          tagged_type 
+        tagged_v[arity]
+        ;
+        ind_out<<"v before inject:\n";
+        for(unsigned i=0; i<arity; ++i)
+        {
+            ind_out<<"v["<<i<<"].which="<<tagged_v[i].which()<<"\n";
+        }
+        tagged_v[0].inject<index_0>(host_concrete<0>());
+        tagged_v[1].inject<index_1>(host_concrete<1>());
+        tagged_v[2].inject<index_2>(host_concrete<2>());
+        ind_out<<"v after inject:\n";
+        for(unsigned i=0; i<arity; ++i)
+        {
+            ind_out<<"v["<<i<<"].which="<<tagged_v[i].which()<<"\n";
+        }
+            typedef
+        #if 0
+          functor_any
+        #else
+          functor3
+        #endif
+          FUNCTOR_CONSTANCY
+        functor_t;
+          functor_t
+        functor_v;
+          int 
+        result=0;
+        ind_out<<"functor_v().result="<<result<<"\n";
+        result =functor_v(tagged_v[0].project<index_0>());
+        ind_out<<"functor_v(c<0>).result="<<result<<"\n";
+            typedef
+          function_types::
+        #ifdef USE_IS_CALLABLE_WITH_ARGS
+          is_callable_with_args
+        #else
+          can_be_called
+        #endif
+          < functor_t
+            ( host_concrete<0>
+            , host_concrete<1>
+            )
+          >::type
+        is_functor_args_callable;
+        ind_out
+          <<"callable<functor_t(u<0>,u<1> >::type::value="
+          <<is_functor_args_callable::type::value
+          <<"\n";
+      #if 1
+          #define REIFIER_VISITOR
+        #ifdef REIFIER_ViSITOR
+        ind_out<<"***  defined(REIFIER_VISITOR)\n";
+        #else
+        ind_out<<"*** !defined(REIFIER_VISITOR)\n";
+        #endif
+        result
+          = pack::multiple_dispatch::reify_apply
+          #ifdef REIFIER_VISITOR
+            < pack::multiple_dispatch::reifier_visitor
+          #else
+            < pack::multiple_dispatch::reifier_switch
+          #endif
+            >
+            ( functor_v
+          #ifdef REIFIER_VISITOR
+            , static_cast<host_abstract<>const&>(host_concrete<0>())
+            , static_cast<host_abstract<>const&>(host_concrete<1>())
+          #else
+            , tagged_v[0]
+            , tagged_v[1]
+          #endif
+          #define FUNCTOR_INVALID_ARGS
+          #if defined(FUNCTOR_INVALID_ARGS) && !defined(REIFIER_VISITOR)
+            //This should fail compilation with error message
+            //something about invalid args.
+            , tagged_v[0]
+          #endif
+            );
+      #ifdef FUNCTOR_INVALID_ARGS
+        ind_out<<"functor_v(v0,V1,v0).result="<<result<<"\n";
+      #else
+        ind_out<<"functor_v(v0,V1).result="<<result<<"\n";
+      #endif
+      #endif
+    }
+#endif    
+    ind_out<<"final:object_number="<<object_number<<"\n";
+}
+
+}//exit testing
+}//exit multiple_dispatch
+}//exit pack
+}//exit composite_storage
+}//exit boost namespace
+
+int main(void)
+{
+    boost::iostreams::indent_scoped_ostreambuf<char> indent_outbuf(std::cout,4);
+    
+    boost::composite_storage::pack::multiple_dispatch::testing::test();
+    return 0;
+}