chapter-5-tiny.hpp

Go to the documentation of this file.

// ===-- chapter-5/chapter-5-tiny.hpp --------------------- -*- C++ -*- --=== //
 
 
#ifndef CHAPTER_5_TINY
#define CHAPTER_5_TINY
 
#include <boost/static_assert.hpp>
 
#include <boost/mpl/at.hpp>
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/clear.hpp>
#include <boost/mpl/insert.hpp>
#include <boost/mpl/iterator_tags.hpp>
#include <boost/mpl/minus.hpp>
#include <boost/mpl/next_prior.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/pop_back.hpp>
#include <boost/mpl/pop_front.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/push_front.hpp>
#include <boost/mpl/size.hpp>
 
#include <boost/type_traits/is_same.hpp>
 
 
namespace chapter5 {
 
struct none { };
 
struct tiny_tag {};
 
template <typename Tiny, typename Pos>
struct tiny_iterator
{
    typedef boost::mpl::random_access_iterator_tag category;
};
 
template <typename T0 = none, typename T1 = none, typename T2 = none>
struct tiny
{
    typedef tiny_tag tag;
    typedef tiny type;
    typedef T0 t0;
    typedef T1 t1;
    typedef T2 t2;
};
 
template <typename Tiny, int Pos> struct tiny_at { };
 
template <typename Tiny>
struct tiny_at<Tiny, 0>
{
    typedef typename Tiny::t0 type;
};
template <typename Tiny>
struct tiny_at<Tiny, 1>
{
    typedef typename Tiny::t1 type;
};
template <typename Tiny>
struct tiny_at<Tiny, 2>
{
    typedef typename Tiny::t2 type;
};
 
// Indirection to improve back insertion:
 
template <typename Tiny, typename T, int N>
struct tiny_push_back;
 
template <typename Tiny, typename T>
struct tiny_push_back<Tiny, T, 0> : tiny<T, none, none> { };
template <typename Tiny, typename T>
struct tiny_push_back<Tiny, T, 1> : tiny<typename Tiny::t0, T, none> { };
template <typename Tiny, typename T>
struct tiny_push_back<Tiny, T, 2>
    : tiny<typename Tiny::t0, typename Tiny::t1, T> { };
 
#ifndef PRE_EXERCISE_5_3
template <typename Tiny, typename T, int N>
struct tiny_insert;
 
template <typename Tiny, typename T>
struct tiny_insert<Tiny, T, 0>
    : tiny<T, typename Tiny::t0, typename Tiny::t1>
{ BOOST_STATIC_ASSERT((boost::is_same<typename Tiny::t2, none>::value)); };
template <typename Tiny, typename T>
struct tiny_insert<Tiny, T, 1>
    : tiny<typename Tiny::t0, T, typename Tiny::t1>
{ BOOST_STATIC_ASSERT((boost::is_same<typename Tiny::t2, none>::value)); };
template <typename Tiny, typename T>
struct tiny_insert<Tiny, T, 2>
    : tiny<typename Tiny::t0, typename Tiny::t1, T>
{ BOOST_STATIC_ASSERT((boost::is_same<typename Tiny::t2, none>::value)); };
#endif
 
template <typename T0, typename T1, typename T2>
struct tiny_size : boost::mpl::int_<3> { };
 
template <typename T0, typename T1>
struct tiny_size<T0, T1, none> : boost::mpl::int_<2> { };
template <typename T0>
struct tiny_size<T0, none, none> : boost::mpl::int_<1> { };
template <>
struct tiny_size<none, none, none> : boost::mpl::int_<0> { };
 
} // namespace chapter5
 
 
namespace boost {
namespace mpl {
 
 
// Implement the required operations
 
template <typename Tiny, typename Pos>
struct next< chapter5::tiny_iterator<Tiny,Pos> >
{
    typedef chapter5::tiny_iterator<
        Tiny,
        typename boost::mpl::next<Pos>::type
        > type;
};
 
template <typename Tiny, typename Pos>
struct prior< chapter5::tiny_iterator<Tiny,Pos> >
{
    typedef chapter5::tiny_iterator<
        Tiny,
        typename boost::mpl::prior<Pos>::type
        > type;
};
 
template <typename Tiny, typename Pos, typename N>
struct advance< chapter5::tiny_iterator<Tiny,Pos>, N >
{
    typedef chapter5::tiny_iterator<
        Tiny,
        typename boost::mpl::plus<Pos,N>::type
        > type;
};
 
template <typename Tiny, typename Pos>
struct deref< chapter5::tiny_iterator<Tiny,Pos> > : at<Tiny,Pos> { };
 
template <typename Tiny, typename Pos1, typename Pos2>
struct distance<
    chapter5::tiny_iterator<Tiny,Pos1>,
    chapter5::tiny_iterator<Tiny,Pos2> >
    : boost::mpl::minus<Pos2, Pos1> { };
 
template <>
struct at_impl<chapter5::tiny_tag>
{
    template <typename Tiny, typename N>
    struct apply : chapter5::tiny_at<Tiny, N::value> { };
};
 
template <>
struct begin_impl<chapter5::tiny_tag>
{
    template <typename Tiny>
    struct apply
    {
        typedef chapter5::tiny_iterator< Tiny, int_<0> > type;
    };
};
 
template <>
struct end_impl<chapter5::tiny_tag>
{
    template <typename Tiny>
    struct apply
    {
        typedef chapter5::tiny_iterator<
            Tiny,
            typename chapter5::tiny_size<
                typename Tiny::t0,
                typename Tiny::t1,
                typename Tiny::t2
                >::type
            > type;
    };
};
 
template <>
struct size_impl<chapter5::tiny_tag>
{
    template <typename Tiny>
    struct apply
        : chapter5::tiny_size<
            typename Tiny::t0,
            typename Tiny::t1,
            typename Tiny::t2
        > { };
};
 
// Extensibility
 
template <>
struct clear_impl<chapter5::tiny_tag>
{
    template <typename Tiny>
    struct apply : chapter5::tiny<> { };
};
 
template <>
struct push_back_impl<chapter5::tiny_tag>
{
    // tiny_push_back and tiny_insert are the same complexity.
    template <typename Tiny, typename T>
#ifdef PRE_EXERCISE_5_3
    struct apply
        : tiny_push_back<Tiny, T, size<Tiny>::value> { };
#else
    struct apply
        : chapter5::tiny_insert<Tiny, T, size<Tiny>::value> { };
#endif
};
 
 
// (Changed) A simple assert that either t2 = none, or size<Tiny> < 3
 
template <>
struct push_front_impl<chapter5::tiny_tag>
{
    template <typename Tiny, typename T>
    struct apply : chapter5::tiny<T, typename Tiny::t0, typename Tiny::t1>
    {
        // See exercise 5-2
        BOOST_STATIC_ASSERT((
            boost::is_same<typename Tiny::t2, chapter5::none>::value));
    };
};
 
// Created tiny_insert, modified push_back (above)
 
template <>
struct insert_impl<chapter5::tiny_tag>
{
    template <typename Tiny, typename Pos, typename T>
    struct apply;
 
    template <typename Tiny, typename Pos, typename T>
    struct apply<Tiny, chapter5::tiny_iterator<Tiny,Pos>, T>
        : chapter5::tiny_insert<Tiny, T, Pos::value> { };
};
 
} // namespace mpl
} // namespace boost
 
 
#include <boost/mpl/erase.hpp>
 
namespace chapter5 {
 
 
template <typename S, int First, int Last>
struct tiny_erase { };
 
template <typename S>
struct tiny_erase<S,0,1> : tiny<typename S::t1, typename S::t2> { };
template <typename S>
struct tiny_erase<S,0,2> : tiny<typename S::t2> { };
template <typename S>
struct tiny_erase<S,0,3> : tiny<> { };
template <typename S>
struct tiny_erase<S,1,2> : tiny<typename S::t0, typename S::t2> { };
template <typename S>
struct tiny_erase<S,1,3> : tiny<typename S::t0> { };
template <typename S>
struct tiny_erase<S,2,3> : tiny<typename S::t0, typename S::t1> { };
 
 
} // namespace chapter5
 
 
namespace boost {
namespace mpl {
 
 
template<>
struct erase_impl<chapter5::tiny_tag>
{
    template <typename S, typename First, typename Last>
    struct apply { };
 
    // We have no end, so ask to delete [First, First+1)...
    template <typename S, typename First>
    struct apply<S, First, mpl_::na /* ??? */>
        : apply<S, First, typename boost::mpl::next<First>::type> { };
 
    template <typename S, typename First, typename Last>
    struct apply< S,
                  chapter5::tiny_iterator<S, First>,
                  chapter5::tiny_iterator<S, Last> >
        : chapter5::tiny_erase<S, First::value, Last::value> { };
};
 
template<>
struct pop_back_impl<chapter5::tiny_tag>
{
    template <typename S>
    struct apply
        : erase_impl<chapter5::tiny_tag>::template apply<
            S,
            typename prior<typename end<S>::type>::type,
            typename end<S>::type> { };
};
 
template<>
struct pop_front_impl<chapter5::tiny_tag>
{
    template <typename S>
    struct apply
        : erase_impl<chapter5::tiny_tag>::template apply<
            S,
            typename begin<S>::type,
            typename next<typename begin<S>::type>::type> { };
};
 
 
} // namespace mpl
} // namespace boost
 
#endif // CHAPTER_5_TINY