//Purpose:
//  See if while_ can be used to solve problem posed here:
//
//    http://article.gmane.org/gmane.comp.lib.boost.user/60307
//
/*Original code:

  template
  < typename totalsize 
  , typename maxelement 
  , typename poolsize 
  >
struct loop
{
  typedef mpl::times< totalsize , maxelement > part0;
  typedef mpl::times< part0 , mpl::int_< 3 > > part1;
  typedef mpl::greater< part1 , poolsize > gr;
      typedef 
    mpl::if_
    < gr 
    , typename loop
      < totalsize 
      , mpl::divides
        < maxelement 
        , mpl::int_< 2 > 
        > 
      , poolsize 
      >::value 
    , maxelement 
    > 
  value;
};

template< class totalsize , class poolsize >
struct loop< totalsize , mpl::int_< 1 > , poolsize >
{
  typedef mpl::int_< 1 > value;
};


typename loop< mpl::int_< 144 > , mpl::int_< 1024 > , mpl::int_< 140000 >
 ::value max;
*/

#include <boost/mpl/while.hpp>
#include <boost/mpl/times.hpp>
#include <boost/mpl/divides.hpp>
#include <boost/mpl/greater.hpp>

#include <iostream>

namespace boost
{
namespace mpl
{
namespace example
{
    template
    < typename totalsize
    , typename poolsize
    >
  struct curry
  {
      struct if_ops
      {
            template
            < typename maxelement
            >
          struct if_
          {
              typedef times< totalsize , maxelement > part0;
              typedef times< part0 , int_< 3 > > part1;
              typedef typename greater< part1, poolsize>::type type;
          };
            template
            < typename maxelement
            >
          struct then_
          : divides
            < maxelement 
            , int_< 2 > 
            > 
          {
          };
      };
      
        template
        < typename maxelement
        >
      struct loop
      : while_
        < maxelement
        , if_ops
        >
      {
      };
      
  };
  
  void test(void)
  {
      typedef int_< 144 > totalsize_t;
      typedef int_< 140000 > poolsize_t;
      typedef int_< 1024 > maxelement_t;
      typedef curry<totalsize_t,poolsize_t>::loop<maxelement_t>::type actual;
      int const totalsize_v=totalsize_t::value;
      int const poolsize_v=poolsize_t::value;
      int maxelement_v=maxelement_t::value;
      while( totalsize_v * maxelement_v * 3 > poolsize_v )
          maxelement_v >>= 1;

      std::cout<<"actual result="<<actual::value<<"\n";
      std::cout<<"expected result="<<maxelement_v<<"\n";
  }
 
}//exit example namespace 
}//exit mpl namespace
}//exit boost namespace

int main(void)
{
    boost::mpl::example::test();
    return 0;
}