Ticket #4175: test_boost_proto.cpp

// test_boost_proto 
// - Small test program to illustrate wrapper removal issue

#include  <boost/proto/proto.hpp>

namespace clifford {

    namespace proto = boost::proto;

    // expression tags 
    namespace tag  {
        struct reverse_ {};
    }


    ////////////////////////////////////////////////////////////////////
    // Grammar    
    struct ga_grammar;

    struct ga_grammar_cases {
        template <class Tag>
        struct case_ : proto::not_<proto::_> {};
    };

    // terminals - usually multivectors or doubles 
    template<> struct  ga_grammar_cases::case_<proto::tag::terminal>
    : proto::_ {};

    // reverse operator
    template<> struct  ga_grammar_cases::case_<tag::reverse_>
    : proto::unary_expr<tag::reverse_, ga_grammar> {};

    struct ga_grammar : proto::switch_<ga_grammar_cases> {};


    struct ga_domain;

    template<typename Expr>
    struct ga_expr
        : proto::extends<Expr, ga_expr<Expr>, ga_domain>
    {
        typedef proto::extends<Expr, ga_expr<Expr>, ga_domain> base_type;

        typedef void clifford_is_expr_;

        ga_expr(const Expr& expr = Expr() )
            : base_type( expr )
            {}
    };

    struct ga_domain : proto::domain<proto::generator<ga_expr>, ga_grammar> {};


    //////////////////////////////////////////////////////////////////
    // Capture the expression 

    // control overloads 
    namespace detail_
    {
        template <class Tag, class Arg, class Enable = void>
        struct make_unary_expr_if {};

        template <class T, class Arg>
        struct make_unary_expr_if<T, Arg, typename Arg::clifford_is_multivector_>
            : proto::result_of::make_expr<T, ga_domain,  const Arg&> {};

        template <class T, class Arg>
        struct make_unary_expr_if<T, Arg, typename Arg::clifford_is_expr_>
            : proto::result_of::make_expr<T, ga_domain, const Arg&> {};

    } // namespace detail_ 

#define  CLIFFORD_DEFINE_UNARY_OPERATOR(OP, TAG)                        \
    template<typename A>                                                \
    const typename detail_::make_unary_expr_if<TAG, A>::type                    \
    OP(A const &a)  {                                                   \
        return proto::make_expr<TAG, ga_domain >(boost::ref(a));        \
    }

    CLIFFORD_DEFINE_UNARY_OPERATOR(operator~, tag::reverse_)


    ////////////////////////////////////////////////////////////////////
    /// Transform the expression

    //struct transform_expression : proto::_ {}; // <= this is fine  

     struct transform_expression
        : proto::nary_expr<proto::_, proto::vararg<transform_expression> > {};


    //////////////////////////////////////////////////////////////////
    // Evaluate the expression

    template <class Res, class Expr>
    void evaluate_expr(Res& res, const ga_expr<Expr>& expr)  {
        // do something ... 
    }

    template <class Res, class Expr>
    void evaluate(Res& res, const ga_expr<Expr>& expr)  {
        BOOST_MPL_ASSERT((proto::matches< ga_expr<Expr>, ga_grammar>));
        evaluate_expr(res, transform_expression()(expr) );
    }

    // "stub" structs for multivector terminals

    template <class T>  struct multivector_base {
        typedef void clifford_is_multivector_;
        /// \brief cast to the actual mulivector type
        T& operator()() { return static_cast<T&>(*this); }
        /// \overload
        const T& operator()() const { return static_cast<const T&>(*this); }
    };

    // general geometric algebra multivector template
    template <class B, class A>
    class multivector : public multivector_base< multivector<B, A> >
    {
    public:
        multivector () {};

        // generalised assign 
        template <class T>
        multivector& operator=(const ga_expr<T>& expr) {
            evaluate(*this, expr);
            return *this;
        }

        // implementation ... 
    }; // class multivector

    ///////////////////////////////////////////////////////////////////// 
    // make some multivector types - stubs

    // (p,q) signature of space, p positive and q negative basis elements
    template <size_t p, size_t q>
    struct algebra {}; // implementation ... 

    typedef algebra<4,1> ga41;

    namespace cga3 {
        struct cga3 : ga41{};      // 3D conformal geometric algebra,  cga 

        // some bases ( implemented using mpl integral sequences wrappers)
        struct ebivector_basis{};     // {e12, e13, e23 }
        struct rotator_basis{};    //  {1, e12, e23, e31} 
        // ...  

        // some useful general multivector types
        typedef multivector<ebivector_basis, cga3> ebivector;
        typedef multivector<rotator_basis, cga3> rotator; // Rotation about origin, aka Quaternion
        // ...  

    } // namespace cga3
} // namespace clifford


int main()
{
    clifford::cga3::rotator R;
    clifford::cga3::ebivector B;

    R = ~B;
}