//prototype whether initial mpl::set can be done by using repeated inserts.
//
#include <boost/mpl/set.hpp>
#include <boost/mpl/insert.hpp>
#include <boost/mpl/erase_key.hpp>
#include <boost/mpl/equal.hpp>
#include <boost/mpl/fold.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/empty.hpp>
#include <boost/mpl/size.hpp>

#include <boost/mpl/assert.hpp>

namespace boost{namespace mpl{
namespace assoc_impl
//prototype namespace:
{
#define USE_SET_INSERT
#ifdef USE_SET_INSERT
//{set
  template
  < typename... Elements
  >
  struct
set
;
  template
  <
  >
  struct
set
  <
  >
  : mpl::set<> 
{
};

  template
  < typename HeadElement
  , typename... TailElements
  >
  struct
set
  < HeadElement
  , TailElements...
  >
  : mpl::insert
    < assoc_impl::set<TailElements...>
    , HeadElement
    >::type
{
};
//}set
  template
  < typename Set0
  , typename Set1
  >
  struct
erase_sets
/**@brief
 *  erases Set1 from Set0
 */
: fold
  < Set1
  , Set0
  , erase_key<arg<1>,arg<2> >
  >
{
};
  template
  < typename Set0
  , typename Set1
  >
  struct
equal_sets
/**@brief
 *  Is Set1 equal to Set0?
 */
: and_
  < empty<typename erase_sets<Set0,Set1>::type>
  , empty<typename erase_sets<Set1,Set0>::type>
  >
{
};
  
#endif

void set_insert_erase_test(void)
{
    typedef set<> empty_set;
    typedef insert<empty_set, int>::type set_int;
    BOOST_MPL_ASSERT((has_key<set_int,int>));
    typedef insert<set_int, float>::type set_int_float;
    BOOST_MPL_ASSERT((has_key<set_int_float,int>));
    BOOST_MPL_ASSERT((has_key<set_int_float,float>));
    typedef insert<set_int_float, int>::type set_int_float_int;
    BOOST_MPL_ASSERT((boost::is_same<set_int_float,set_int_float_int>));
    typedef erase_key<set_int_float, float>::type set_int_float_erase_float;
    BOOST_MPL_ASSERT((boost::is_same<set_int,set_int_float_erase_float>));
    typedef insert<empty_set, float>::type set_float;
    typedef erase_key<set_int_float, int>::type set_int_float_erase_int;
    BOOST_MPL_ASSERT_NOT((boost::is_same<set_float,set_int_float_erase_int>));
    BOOST_MPL_ASSERT((equal<set_float,set_int_float_erase_int>));
    typedef insert<set_float, int>::type set_float_int;
    BOOST_MPL_ASSERT_NOT((boost::is_same<set_float_int,set_int_float>));
  #ifdef USE_SET_INSERT
    #if 0
      typedef erase_sets<set_int_float,set_float_int>::type erase_sets_result;
      BOOST_MPL_ASSERT((is_same<erase_sets_result,void>));
    #endif
    BOOST_MPL_ASSERT((equal_sets<set_int_float,set_float_int>));
    BOOST_MPL_ASSERT_NOT((equal_sets<set_int,set_float_int>));
    BOOST_MPL_ASSERT_NOT((equal_sets<set_int_float,set_float>));
  #endif
}

void set_dup_key_con_test(void)
{
        typedef 
      ::boost::mpl::
    #ifdef USE_SET_INSERT
      assoc_impl::
    #endif
      set
      < int
      , int
      > 
    int2_set;
    BOOST_MPL_ASSERT((has_key<int2_set,int>));
    unsigned const size_int2_set=size<int2_set>::type::value;
    BOOST_MPL_ASSERT_RELATION(size_int2_set,==,1);
    //^1)according to "normal: interpretation of "set".
    typedef erase_key<int2_set,int>::type int2_erase_int;
    unsigned const size_int2_erase_int=size<int2_erase_int>::type::value;
    BOOST_MPL_ASSERT_RELATION(size_int2_erase_int,==,0);
    BOOST_MPL_ASSERT_NOT((has_key<int2_erase_int,int>));
    //^2)according to "Semantics:" on:
    //  http://www.boost.org/libs/mpl/doc/refmanual/erase-key.html
    typedef erase_key<int2_set,float>::type int2_erase_float;
    unsigned const size_int2_erase_float=size<int2_erase_float>::type::value;
    BOOST_MPL_ASSERT_RELATION(size_int2_erase_float,==,1);
    //^3)according to "Postcondition:" on:
    //  http://www.boost.org/libs/mpl/doc/refmanual/erase-key.html
}

}//exit assoc_impl namespace
}}//exit boost::mpl