#ifndef BOOST_MPL_WHILE_HPP_INCLUDED
#define BOOST_MPL_WHILE_HPP_INCLUDED
// Copyright Larry Evans 2009
//

// $Id: while.cpp,v 1.20 2009/04/23 15:29:47 evansl Exp evansl $
// $Date: 2009/04/23 15:29:47 $
// $Revision: 1.20 $

#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/apply.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/arg.hpp>
#include <boost/mpl/always.hpp>

namespace boost
{
namespace mpl
{
    //Notation:
    //  MFC_or_LE = Metafunction class or Lambda Expression
    //    (See Description on libs/mpl/doc/refmanual/apply.html)
    //
    //  State = Any type.
    //    (this is term used in libs/mpl/doc/refmanual/fold.html)
    //
      template
      < class StateMeta//nullary metafunction returning current State.
      , class PredOp=always<false_>//unary MFC_or_LE from State to Bool.
      , class ThenOp=identity<arg<1> >//unary MFC_or_LE from State to State,
      >
    struct while_
    {
            typedef        
          typename eval_if
          < typename apply<PredOp,typename StateMeta::type>::type
          , while_
            < apply<ThenOp,typename StateMeta::type>
            , PredOp
            , ThenOp
            >
          , StateMeta
          >::type
        type
        ;
    };
    
}//exit mpl namespace
}//exit boost namespace
#endif

#ifndef BOOST_MPL_WHILE_RECUR_SEQ_HPP_INCLUDED
#define BOOST_MPL_WHILE_RECUR_SEQ_HPP_INCLUDED
//#include <boost/mpl/while.hpp>
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/next.hpp>
#include <boost/mpl/deref.hpp>
#include <boost/mpl/push_front.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/list.hpp>

namespace boost
{
namespace mpl
{
namespace aux
{
namespace while_recur_seq
{

  template
  < typename State
  >
struct while_state
{
    typedef State state;
    typedef while_state type;
};
  template
  < typename Stack
  , typename State
  >
struct while_stack_state
: while_state<State>
{
    typedef Stack stack;
    typedef while_stack_state type;
};
  template
  < typename State
  , typename Iter
  >
struct while_state_iter
: State //either while_state or while_stack_state
{
    typedef Iter iter;
    typedef while_state_iter type;
};

  template
  < typename State
  , typename Op
  >
struct forward_step
{
        typedef
      typename deref<typename State::iter>::type
    item;
        typedef
      while_state_iter
      < while_stack_state
        < typename push_front<typename State::stack, item>::type
        , typename apply<Op,typename State::state,item>::type
        >
      , typename next<typename State::iter>::type
      >
    type;
    
};

  template
  < typename State
  , typename Op
  >
struct backward_step
{
        typedef
      typename deref<typename State::iter>::type
    item;
        typedef
      while_state_iter
      < while_state<typename apply<Op,typename State::state,item>::type>
      , typename next<typename State::iter>::type
      >
    type;
    
};

  template
  < typename State
  , typename Op
  >
struct direction_step
;

  template
  < typename State
  , typename Iter
  , typename Op
  >
struct direction_step
  < while_state_iter
    < while_state<State>
    , Iter
    >
  , Op
  >
: backward_step
  < while_state_iter<State,Iter>
  , Op
  >
{  
};

  template
  < typename Stack
  , typename State
  , typename Iter
  , typename Op
  >
struct direction_step
  < while_state_iter
    < while_stack_state<Stack,State>
    , Iter
    >
  , Op
  >
: forward_step
  < while_state_iter
    < while_stack_state<Stack,State>
    , Iter
    >
  , Op
  >
{  
};

  template
  < typename StateNow
  , typename IterLast
  >
struct not_iter_last
: not_
  < is_same
    < typename StateNow::iter
    , IterLast
    >
  >
{
};

  template
  < typename Op
  , typename LazyExpr
  >
struct apply_lazy1
{
    typedef typename apply<Op,typename LazyExpr::type>::type type;
};  
  template
  < typename StateNow
  , typename IterLast
  , typename Predicate=always<true_>
  >
struct not_iter_last_pred
: and_
  < not_iter_last<StateNow,IterLast>
  , apply_lazy1<Predicate, deref<typename StateNow::iter> >
  >
{
};

}//exit while_recur_seq namespace

}//exit aux namespace

  template
  < typename Seq
  , typename State
  , typename OperStateVal
  , typename PredicateVal=always<true_>
  , template<class,class>class Step=while_recur_seq::backward_step
  >
struct while_seq
{
        typedef
      typename begin<Seq>::type
    first;
        typedef
      typename end<Seq>::type
    last;
        typedef
      while_recur_seq::while_state_iter<State,first>
    state_iter;
        typedef
      Step
      < arg<1>
      , typename lambda<OperStateVal>::type
      >
    oper_state_ref;
        typedef
      while_recur_seq::not_iter_last_pred
      < arg<1>
      , last
      , typename lambda<PredicateVal>::type
      >
    predicate_ref;
        typedef
      typename while_
      < state_iter
      , predicate_ref
      , oper_state_ref
      >::type
    type;
};

  template
  < typename BOOST_MPL_AUX_NA_PARAM(Sequence)
  , typename BOOST_MPL_AUX_NA_PARAM(State)
  , typename BOOST_MPL_AUX_NA_PARAM(ForwardOp)
  , typename BOOST_MPL_AUX_NA_PARAM(ForwardPredicate)
  , typename BOOST_MPL_AUX_NA_PARAM(BackwardOp)
  , typename BOOST_MPL_AUX_NA_PARAM(BackwardPredicate)
  >
struct while_recur_seq
{
    struct forward
    {
      #if 0
        typedef list<> stack0;
        typedef Sequence seq;
        typedef State state;
        typedef typename begin<seq>::type first;
        typedef typename end<seq>::type last;
        typedef typename lambda<ForwardOp>::type state_op;
        typedef typename lambda<ForwardPredicate>::type pred_op;
        
            typedef 
          aux::while_recur_seq::while_state_iter
          < aux::while_recur_seq::while_stack_state<stack0,state>
          , first
          > 
        aux_state;
        typedef aux::while_recur_seq::not_iter_last_pred< arg<1>, last, pred_op> aux_pred;
        typedef aux::while_recur_seq::forward_step< arg<1>, state_op> aux_op;
        
        typedef typename while_<aux_state,aux_pred,aux_op>::type result;
      #else
            typedef
          typename while_seq
          < seq
          , aux::while_recur_seq::while_stack_state
            < list<>
            , State
            >
          , ForwardOp
          , ForwardPredicate
          , aux::while_recur_seq::forward_step
          >::type
        result
        ;
      #endif
    };

    struct backward
    {
        typedef typename forward::result::stack seq;
        typedef typename forward::result::state state;
        typedef typename begin<seq>::type first;
        typedef typename end<seq>::type last;
        typedef typename lambda<BackwardOp>::type state_op;
        typedef typename lambda<BackwardPredicate>::type pred_op;
        
            typedef 
          aux::while_recur_seq::while_state_iter
          < aux::while_recur_seq::while_state<state>
          , first
          > 
        aux_state;
        typedef aux::while_recur_seq::not_iter_last_pred< arg<1>, last, pred_op> aux_pred;
        typedef aux::while_recur_seq::backward_step<arg<1>,state_op> aux_op;
        
        typedef typename while_<aux_state,aux_pred,aux_op>::type result;
    };

    typedef typename backward::result::state type;
        
};

}//exit mpl namespace
}//exit boost namespace
#endif

//-{--while_recur_seq_test--
#include <boost/mpl/list.hpp>
#include <boost/mpl/list_c.hpp>
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/vector_c.hpp>

#include <boost/mpl/less.hpp>
#include <boost/mpl/greater.hpp>
#include <boost/mpl/equal.hpp>

#include <boost/mpl/aux_/test.hpp>

namespace boost
{
namespace mpl
{
namespace test_while
{
    typedef
  int
int_type
;  
    typedef
#if 0
  range_c< int_type, 9, 13>
#else
  list_c< int_type, 9, 10, 11, 12>
#endif
numbers
;
  namespace palindrome
  {
        typedef
      while_recur_seq
      < numbers
      , vector<>
      , push_front<arg<1>, arg<2> >
      , always<true_>
      , push_front<arg<1>, arg<2> >
      , always<true_>
      >
    while_result
    ;
        typedef
      while_result::type
    actual_result
    ;
        typedef
      vector_c<int_type, 9,10,11,12,12,11,10,9>
    expected_result
    ;
    BOOST_MPL_ASSERT((equal<actual_result,expected_result>))
    ;
  
  }//exit palindrome namespace
  
  namespace palindrome_pred_fwd
  {
        typedef
      while_recur_seq
      < numbers
      , vector<>
      , push_front<arg<1>, arg<2> >
      , less<arg<1>,integral_c<int_type,12> >
      , push_front<arg<1>, arg<2> >
      , always<true_>
      >
    while_result
    ;
        typedef
      while_result::type
    actual_result
    ;
        typedef
      vector_c<int, 9,10,11,11,10,9>
    expected_result
    ;
    BOOST_MPL_ASSERT((equal<actual_result,expected_result>))
    ;
  
  }//exit palindrome_pred_fwd namespace
   
  namespace palindrome_pred_both
  {
        typedef
      while_recur_seq
      < numbers
      , vector<>
      , push_front<arg<1>, arg<2> >
      , less<arg<1>,integral_c<int_type,12> >
      , push_front<arg<1>, arg<2> >
      , greater<arg<1>,integral_c<int_type,9> >
      >
    while_result
    ;
        typedef
      while_result::type
    actual_result
    ;
        typedef
      vector_c<int, 10,11,11,10,9>
    expected_result
    ;
    BOOST_MPL_ASSERT((equal<actual_result,expected_result>))
    ;
  
  }//exit palindrome_pred_both namespace
   
}//exit test_while namespace4
}//exit mpl namespace
}//exit boost namespace
//-}--while_recur_seq_test--