chapter-5.cpp

Go to the documentation of this file.

// ===-- chapter-5/chapter-5.cpp -------------------------- -*- C++ -*- --=== //
#include "chapter-5-tiny.hpp"
#include "exercise-5-1.hpp"
#include "exercise-5-6.hpp"
#include "exercise-5-7.hpp"
#include "exercise-5-8.hpp"
#include "exercise-5-9.hpp"
#include "exercise-5-10.hpp"
 
#include <boost/mpl/vector.hpp>
using namespace boost::mpl::placeholders;
 
#include <stdio.h>
 
#define PARANOID_DEBUG_TEST
 
 
namespace test_5_1 {
using namespace exercise_5_1;
 
typedef boost::mpl::vector_c<int, 1, 2, 3, 4> testVec;
 
typedef double_first_half<testVec>::type testVec2;
BOOST_STATIC_ASSERT((boost::mpl::equal<
                     testVec2,
                     boost::mpl::vector_c<int, 2, 4, 3, 4> >::value));
 
} // namespace test_5_1
 
 
namespace test_5_8 {
using namespace exercise_5_8;
 
typedef boost::mpl::advance_c<
    boost::mpl::begin<exercise_5_8::fibonacci_series>::type,
    6>::type i;
BOOST_STATIC_ASSERT(boost::mpl::deref<i>::type::value == 8);
 
typedef boost::mpl::advance_c<i, 4>::type j;
BOOST_STATIC_ASSERT(boost::mpl::deref<j>::type::value == 55);
 
} // namespace test_5_8
 
 
namespace test_5_10 {
using namespace exercise_5_10;
 
typedef chapter5::tree<
    double,
    chapter5::tree<void*, int, long>,
    char
> tree_seq;
 
typedef chapter5::tree<
    double,
    chapter5::tree<
        short,
        long,
        chapter5::tree<float, void*>
        >,
    chapter5::tree<
        int,
        void_,
        char>
    > tree_seq_hard;
 
#ifdef PARANOID_DEBUG_TEST
typedef boost::mpl::begin< inorder_view<tree_seq_hard> >::type tmp1;
typedef boost::mpl::deref<tmp1>::type tmp1d;
BOOST_STATIC_ASSERT((boost::is_same<long, tmp1d>::value));
 
typedef boost::mpl::next<tmp1>::type tmp2;
typedef boost::mpl::deref<tmp2>::type tmp2d;
BOOST_STATIC_ASSERT((boost::is_same<short, tmp2d>::value));
 
typedef boost::mpl::next<tmp2>::type tmp3;
typedef boost::mpl::deref<tmp3>::type tmp3d;
BOOST_STATIC_ASSERT((boost::is_same<void*, tmp3d>::value));
 
typedef boost::mpl::next<tmp3>::type tmp4;
typedef boost::mpl::deref<tmp4>::type tmp4d;
BOOST_STATIC_ASSERT((boost::is_same<float, tmp4d>::value));
 
typedef boost::mpl::next<tmp4>::type tmp5;
typedef boost::mpl::deref<tmp5>::type tmp5d;
BOOST_STATIC_ASSERT((boost::is_same<double, tmp5d>::value));
 
typedef boost::mpl::next<tmp5>::type tmp6;
typedef boost::mpl::deref<tmp6>::type tmp6d;
BOOST_STATIC_ASSERT((boost::is_same<int, tmp6d>::value));
 
typedef boost::mpl::next<tmp6>::type tmp7;
typedef boost::mpl::deref<tmp7>::type tmp7d;
BOOST_STATIC_ASSERT((boost::is_same<char, tmp7d>::value));
 
typedef boost::mpl::next<tmp7>::type tmp8;
typedef boost::mpl::end< inorder_view<tree_seq_hard> >::type tmp_end;
BOOST_STATIC_ASSERT((boost::is_same<tmp_end, tmp8>::value));
#endif // PARANOID_DEBUG_TEST
 
BOOST_STATIC_ASSERT((
    boost::mpl::equal<
        exercise_5_10::inorder_view<tree_seq>,
        boost::mpl::vector<int, void*, long, double, char>,
        boost::is_same<_1, _2>
    >::value));
 
BOOST_STATIC_ASSERT((
    boost::mpl::equal<
        exercise_5_10::inorder_view<tree_seq_hard>,
        boost::mpl::vector<long, short, void*, float, double, int, char>,
        boost::is_same<_1, _2>
    >::value));
 
} // namespace test_5_10
 
 
namespace {
 
static void test_exercise_5_0()
{
#ifdef CHAPTER_5_TINY
    using namespace chapter5;
 
    typedef tiny<int, char, float> v1;
    boost::mpl::deref< boost::mpl::begin<v1>::type >::type const i1 = 5;
    boost::mpl::at< v1, boost::mpl::int_<1> >::type const c1 = 'a';
    boost::mpl::deref<
        boost::mpl::prior< boost::mpl::end<v1>::type >::type
        >::type const f1 = 2.5;
 
    printf("i1: (%lu,%i); c1: (%lu,%c); f1: (%lu,%f)\n",
           sizeof(i1), i1,
           sizeof(c1), c1,
           sizeof(f1), f1);
 
    typedef boost::mpl::clear<v1>::type v2;
    BOOST_STATIC_ASSERT((boost::is_same<v2::t0, none>::value));
    BOOST_STATIC_ASSERT((boost::is_same<v2::t1, none>::value));
    BOOST_STATIC_ASSERT((boost::is_same<v2::t2, none>::value));
 
    typedef boost::mpl::push_front<v2, double>::type v3;
    typedef boost::mpl::push_back<v3, int>::type v4;
 
    BOOST_STATIC_ASSERT((boost::mpl::equal< v4, tiny<double,int> >::value));
#endif
}
 
static void test_exercise_5_3()
{
#ifdef CHAPTER_5_TINY
    using namespace chapter5;
 
    typedef tiny<int> v1;
    BOOST_STATIC_ASSERT((boost::is_same<v1::t0, int>::value));
    BOOST_STATIC_ASSERT((boost::is_same<v1::t1, none>::value));
    BOOST_STATIC_ASSERT((boost::is_same<v1::t2, none>::value));
    BOOST_STATIC_ASSERT((boost::is_same<tiny<int>, v1>::value));
 
    typedef boost::mpl::insert<v1, boost::mpl::begin<v1>::type, float>::type v2;
    BOOST_STATIC_ASSERT((boost::is_same<tiny<float, int>, v2>::value));
 
    typedef boost::mpl::insert<v2, boost::mpl::end<v2>::type, char>::type v3;
    BOOST_STATIC_ASSERT((boost::is_same<tiny<float, int, char>, v3>::value));
 
    // Should be an error:
    // typedef boost::mpl::insert<v2, boost::mpl::end<v3>::type, char>::type v4;
#endif
}
 
static void test_exercise_5_5()
{
#ifdef CHAPTER_5_TINY
    using namespace boost;
    using namespace boost::mpl;
    using namespace chapter5;
 
    typedef tiny<int, float, char> v1;
    typedef begin<v1>::type  pos0;
    typedef next<pos0>::type pos1;
    typedef next<pos1>::type pos2;
    typedef end<v1>::type    posEnd;
 
    BOOST_STATIC_ASSERT((
        is_same< erase<v1, pos0>::type, tiny<float, char> >::value));
    BOOST_STATIC_ASSERT((
        is_same< erase<v1, pos1>::type, tiny<int, char> >::value));
    BOOST_STATIC_ASSERT((
        is_same< erase<v1, pos2>::type, tiny<int, float> >::value));
 
    BOOST_STATIC_ASSERT((
        is_same< erase<v1, pos0, pos1>::type, tiny<float, char> >::value));
    BOOST_STATIC_ASSERT((
        is_same< erase<v1, pos0, pos2>::type, tiny<char> >::value));
    BOOST_STATIC_ASSERT((
        is_same< erase<v1, pos0, posEnd>::type, tiny<> >::value));
    BOOST_STATIC_ASSERT((
        is_same< erase<v1, pos1, posEnd>::type, tiny<int> >::value));
    BOOST_STATIC_ASSERT((
        is_same< erase<v1, pos2, posEnd>::type, tiny<int, float> >::value));
 
    BOOST_STATIC_ASSERT((
        is_same< pop_front<v1>::type, tiny<float, char> >::value));
    BOOST_STATIC_ASSERT((
        is_same< pop_back<v1>::type, tiny<int, float> >::value));
#endif
}
 
static void test_exercise_5_6()
{
#ifdef EXERCISE_5_6
    namespace mpl = boost::mpl;
 
    typedef exercise_5_6::dimensions<char[10][5][2]> seq;
    printf("%lu entries: (%lu, %lu, %lu)\n",
           mpl::size<seq>::value,
           mpl::at_c<seq,0>::type::value,
           mpl::at_c<seq,1>::type::value,
           mpl::at_c<seq,2>::type::value);
 
 
    // Note: I think the book's asserts are backwards.  I've changed the
    //       requirement.  See 5-7 for the list implemented as asked...
    BOOST_STATIC_ASSERT((mpl::size<seq>::value == 3));
    BOOST_STATIC_ASSERT((mpl::at_c<seq,0>::type::value == 10));
    BOOST_STATIC_ASSERT((mpl::at_c<seq,1>::type::value == 5));
    BOOST_STATIC_ASSERT((mpl::at_c<seq,2>::type::value == 2));
#endif
}
 
static void test_exercise_5_7()
{
#ifdef EXERCISE_5_7
    namespace mpl = boost::mpl;
 
    typedef exercise_5_7::dimensions_b<int[10][5][2]> dim1;
    typedef mpl::begin<dim1>::type dim_it1;
 
    BOOST_STATIC_ASSERT((mpl::deref<dim_it1>::value == 2));
 
    printf("%lu entries: (%i, %i, %i)\n",
           mpl::size<dim1>::value,
           mpl::at_c<dim1,0>::type::value,
           mpl::at_c<dim1,1>::type::value,
           mpl::at_c<dim1,2>::type::value);
 
    BOOST_STATIC_ASSERT((mpl::size<dim1>::value == 3));
    BOOST_STATIC_ASSERT((mpl::at_c<dim1,0>::type::value == 2));
    BOOST_STATIC_ASSERT((mpl::at_c<dim1,1>::type::value == 5));
    BOOST_STATIC_ASSERT((mpl::at_c<dim1,2>::type::value == 10));
 
    typedef mpl::push_back< dim1, mpl::int_<3> >::type dim2;
    BOOST_STATIC_ASSERT((mpl::size<dim2>::value == 4));
    BOOST_STATIC_ASSERT((mpl::at_c<dim2,3>::type::value == 3));
 
    typedef mpl::pop_back<dim1>::type dim3;
    BOOST_STATIC_ASSERT((mpl::size<dim3>::value == 2));
#endif
}
 
 
#ifdef EXERCISE_5_9
template <typename CurFibIt, size_t Count>
struct print_fibonacci
{
    typedef print_fibonacci<
        typename boost::mpl::next<CurFibIt>::type,
        Count+1> next;
 
    void print() const
    {
        printf("%i ", boost::mpl::deref<CurFibIt>::type::value);
        next const i;
        i.print();
    }
};
 
template <typename CurFibIt>
struct print_fibonacci<CurFibIt, sMaxFibForInt32>
{
    void print() const
    {
        printf("%i ", boost::mpl::deref<CurFibIt>::type::value);
    }
};
#endif
 
static void print_fibonacci_series()
{
#ifdef EXERCISE_5_9
    using exercise_5_8::fibonacci_series;
 
    typedef print_fibonacci<
        boost::mpl::begin<fibonacci_series>::type,
        0
    > printer;
 
    printf("\nFibonacci: { ");
    {
        printer const p;
        p.print();
    }
    printf("}\n");
#endif
}
 
 
} // namespace <anon>
 
int main()
{
    test_exercise_5_0();
    test_exercise_5_3();
    test_exercise_5_5();
    test_exercise_5_6();
    test_exercise_5_7();
 
    print_fibonacci_series();
    return 0;
}