// $Id$
//
// Copyright (C) 2006 
// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
// Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
//     Stefan Bund <stefan.bund@fokus.fraunhofer.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#ifndef IH_SocketPolicy_
#define IH_SocketPolicy_ 1

// Custom includes
#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/seq/for_each_i.hpp>
#include <boost/preprocessor/seq/size.hpp>
#include <boost/preprocessor/seq/pop_front.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/seq/elem.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/iteration/local.hpp>
#include <boost/preprocessor/control/if.hpp>
#include <boost/preprocessor/comparison/equal.hpp>

#include <boost/type_traits.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/fold.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/utility.hpp> // for enable_if

#include "GenericSockAddr.hh"

///////////////////////////////ih.p////////////////////////////////////////

namespace senf {


#   define SENF_SOCKET_POLICIES_N BOOST_PP_SEQ_SIZE( SENF_SOCKET_POLICIES )
    
    // This REALLY is bad ... but we just need an Address member in
    // AddressingPolicyBase as long as ClientSocketHandle /
    // ServerSocketHandle don't make use of enable_if for each and
    // every member they define ...

    struct AddressingPolicyBase
    {
        virtual ~ AddressingPolicyBase() {}
        
	typedef GenericSockAddr Address;
    };

#   define SP_DeclareBase(x1,x2,SomePolicy)                                             \
        struct BOOST_PP_CAT(SomePolicy,Base)                                            \
        { virtual ~ BOOST_PP_CAT(SomePolicy,Base) () {} };                              \
        typedef BOOST_PP_CAT(SomePolicy,Base) BOOST_PP_CAT(Unspecified,SomePolicy);

    BOOST_PP_SEQ_FOR_EACH( SP_DeclareBase, , BOOST_PP_SEQ_POP_FRONT( SENF_SOCKET_POLICIES ) )

#   undef SP_DeclareBase
        
    struct SocketPolicyBase
    {
        virtual ~SocketPolicyBase() {}

#       define SP_DeclareTypedef(x1,x2,SomePolicy)                                              \
            typedef BOOST_PP_CAT(SomePolicy,Base) SomePolicy;                                   \
            BOOST_PP_CAT(SomePolicy,Base) BOOST_PP_CAT(BOOST_PP_CAT(the,SomePolicy),_);         \
            virtual BOOST_PP_CAT(SomePolicy,Base) const & BOOST_PP_CAT(the,SomePolicy) () const \
                { return BOOST_PP_CAT(BOOST_PP_CAT(the,SomePolicy),_); }

        BOOST_PP_SEQ_FOR_EACH( SP_DeclareTypedef, , SENF_SOCKET_POLICIES )

#       undef SP_DeclareTypedef
    };

#   define SP_TemplateArgs(x1,x2,n,SomePolicy)                                  \
        BOOST_PP_COMMA_IF( n )                                                  \
        class BOOST_PP_CAT(SomePolicy,_) = BOOST_PP_CAT(SomePolicy,Base)

    template < BOOST_PP_SEQ_FOR_EACH_I( SP_TemplateArgs, , SENF_SOCKET_POLICIES ) >
    struct SocketPolicy
        : public SocketPolicyBase
    {
#   define SP_DeclarePolicyMember(x1,x2,SomePolicy)                                     \
        typedef BOOST_PP_CAT(SomePolicy,_) SomePolicy;                                  \
        SomePolicy BOOST_PP_CAT(BOOST_PP_CAT(the,SomePolicy),_);                        \
        BOOST_PP_CAT(SomePolicy,Base) const & BOOST_PP_CAT(the,SomePolicy) () const     \
            { return BOOST_PP_CAT(BOOST_PP_CAT(the,SomePolicy),_); }

        BOOST_PP_SEQ_FOR_EACH( SP_DeclarePolicyMember, , SENF_SOCKET_POLICIES )
#   undef SP_DeclarePolicyMember

        static void checkBaseOf(SocketPolicyBase const & other);
    };

#   undef SP_TemplateArgs

namespace impl {

    struct nil {};

    template <int N>
    struct SocketPolicy_rv
    { int v[N+1]; };
    
    template <class Base, class Policy, int N>
    struct MakeSocketPolicy_merge
    {};

#   define SP_DeclareMakeSocketPolicy_merge_member(r,n,m,SomePolicy)            \
        BOOST_PP_COMMA_IF( m )                                                  \
        BOOST_PP_IIF( BOOST_PP_EQUAL(n,m), Policy, typename Base::SomePolicy )

#    define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC( SENF_SOCKET_POLICIES_N ) )
#    define BOOST_PP_LOCAL_MACRO(n)                                                                                             \
        SocketPolicy_rv<n> MakeSocketPolicy_merge_(BOOST_PP_CAT( BOOST_PP_SEQ_ELEM( n, SENF_SOCKET_POLICIES ),Base)*);        \
                                                                                                                                \
        template <class Base, class Policy>                                                                                     \
        struct MakeSocketPolicy_merge<Base,Policy,sizeof(SocketPolicy_rv<n>)>                                                   \
        {                                                                                                                       \
            typedef SocketPolicy<                                                                                               \
               BOOST_PP_SEQ_FOR_EACH_I( SP_DeclareMakeSocketPolicy_merge_member, n, SENF_SOCKET_POLICIES )                    \
               > type;                                                                                                          \
        };

#   include BOOST_PP_LOCAL_ITERATE()

#   undef SP_DeclareMakeSocketPolicy_merge_member

    struct MakeSocketPolicy_fold
    {
        template <class Base, class Policy>
        struct apply
            : MakeSocketPolicy_merge<Base,
                                     Policy,
                                     sizeof(MakeSocketPolicy_merge_(static_cast<Policy*>(0)))>
        {};

        template <class Base>
        struct apply<Base,nil>
        {
            typedef Base type;
        };
    };

    template <class Base, class Vector>
    struct MakeSocketPolicy_impl
    {
        typedef typename boost::mpl::fold< Vector, Base, MakeSocketPolicy_fold >::type policy;
    };

#   define SP_DeclareArguments(x1,x2,n,SomePolicy)      \
    	BOOST_PP_COMMA_IF( n )                          \
	typename Base::SomePolicy *

    template <class Base>
    SocketPolicy_rv<1> SocketPolicy_checkcompat_(
        BOOST_PP_SEQ_FOR_EACH_I( SP_DeclareArguments, , SENF_SOCKET_POLICIES ) );

#   undef SP_DeclareArguments

    template <class Base>
    SocketPolicy_rv<2> SocketPolicy_checkcompat_( 
        BOOST_PP_ENUM_PARAMS( SENF_SOCKET_POLICIES_N, void * BOOST_PP_INTERCEPT ) );

    template <int Size>
    struct SocketPolicy_checkcompat
        : public boost::false_type
    {};

    template<>
    struct SocketPolicy_checkcompat<sizeof(SocketPolicy_rv<1>)>
        : public boost::true_type
    {};


#   define SP_DeclareArguments(x1,x2,n,SomePolicy)      \
        BOOST_PP_COMMA_IF( n )                          \
        static_cast<typename Derived::SomePolicy *>(0)

    template <class Base, class Derived>
    struct SocketPolicy_compatibility
        : public SocketPolicy_checkcompat< sizeof(
            SocketPolicy_checkcompat_<Base>(
                BOOST_PP_SEQ_FOR_EACH_I( SP_DeclareArguments, , SENF_SOCKET_POLICIES ) )) >
    {};

} // namespace impl

    template < BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( SENF_SOCKET_POLICIES_N, class T, senf::impl::nil ) >
    class MakeSocketPolicy
        : public boost::mpl::if_< boost::is_convertible< T0*, SocketPolicyBase* >,
                                  impl::MakeSocketPolicy_impl< T0, boost::mpl::vector< BOOST_PP_ENUM_SHIFTED_PARAMS( SENF_SOCKET_POLICIES_N, T ) > >,
                                  impl::MakeSocketPolicy_impl< SocketPolicy<>,
                                                               boost::mpl::vector< BOOST_PP_ENUM_PARAMS( SENF_SOCKET_POLICIES_N, T ) > > >::type
    {};

    template <class BasePolicy, class DerivedPolicy>
    struct SocketPolicyIsBaseOf
        : public boost::mpl::if_< boost::mpl::and_< boost::is_convertible< BasePolicy*, SocketPolicyBase* >,
                                                    boost::is_convertible< DerivedPolicy*, SocketPolicyBase* > >,
                                  impl::SocketPolicy_compatibility<BasePolicy,DerivedPolicy>,
                                  boost::false_type >::type
    {};

#   define SP_DefineConditions(x1,x2,SomePolicy)                                                \
        template <class Policy, class Trait>                                                    \
        struct BOOST_PP_CAT(SomePolicy,Is)                                                      \
            : public boost::is_convertible< typename Policy::SomePolicy*, Trait* >              \
        {};                                                                                     \
                                                                                                \
        template <class Policy, class Trait>                                                    \
        struct BOOST_PP_CAT(BOOST_PP_CAT(If,SomePolicy),Is)                                     \
            : public boost::enable_if< BOOST_PP_CAT(SomePolicy,Is)<Policy,Trait> >              \
        {};                                                                                     \
                                                                                                \
        template <class Policy, class Trait>                                                    \
        struct BOOST_PP_CAT(BOOST_PP_CAT(If,SomePolicy),IsNot)                                  \
            : public boost::enable_if_c< ! BOOST_PP_CAT(SomePolicy,Is)<Policy,Trait>::value >   \
        {};

    BOOST_PP_SEQ_FOR_EACH( SP_DefineConditions, , SENF_SOCKET_POLICIES )

#   undef SP_DefineConditions

}

///////////////////////////////ih.e////////////////////////////////////////
#endif


// Local Variables:
// mode: c++
// c-file-style: "senf"
// End: