xst_translator.h

Go to the documentation of this file.

// Common Text Transformation Library
// Copyright (C) 1997-2006 by Igor Kholodov. 
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// mailto:cttl@users.sourceforge.net
// http://sourceforge.net/projects/cttl/

// xst_translator.h

#ifndef _XST_TRANSLATOR_H_INCLUDED_
#define _XST_TRANSLATOR_H_INCLUDED_

namespace cttl_impl {

template< typename LambdaT, typename TranslatorT >
struct xst_translator {

    // allow any lambda primitive to access translator implementation
    template< typename D > friend struct xst_lambda_wrap;

    // allow all other translators to access translator implementation
    template< typename D, typename T > friend struct xst_translator;

    enum {
        const_value_ = LambdaT::const_value_,

        depth_ = LambdaT::depth_,

        capacity_ = LambdaT::capacity_,

        primitive_id_ = primitive_id_translator
    };

    typedef LambdaT lambda_T;

    typedef TranslatorT translator_T;

    typedef typename LambdaT::value_T value_T;

    typedef typename LambdaT::dereferenced_value_T dereferenced_value_T;

    typedef xst_translator< LambdaT, TranslatorT > left_T;

    typedef xst_translator< LambdaT, TranslatorT > right_T;

    typedef xst_translator< LambdaT, TranslatorT > reference_T;

    xst_translator( LambdaT const& lambda_, TranslatorT const& translator_ )
    :
    m_lambda( lambda_ ),
    m_translator( translator_ )
    {
    }

    xst_translator( xst_translator< LambdaT, TranslatorT > const& other_ )
    :
    m_lambda( other_.m_lambda ),
    m_translator( other_.m_translator )
    {
    }

    reference_T make_reference() const
    {
        return *this;
    }
    
    template<
        int LocationT
    >
    dereferenced_value_T& dereferenced_value( xst_lambda_wrap< xst_const_scalar< LocationT > > subscript_ )
    {
        return m_lambda.dereferenced_value( subscript_ );
    }

    left_T& left_lambda()
    {
        return *this; //m_lambda; //DEBUG//.left_lambda();
    }

    left_T const& left_lambda() const
    {
        return *this; //m_lambda; //DEBUG//.left_lambda();
    }

    right_T& right_lambda()
    {
        return *this; //m_lambda; //DEBUG//.right_lambda();
    }

    right_T const& right_lambda() const
    {
        return *this; //m_lambda; //DEBUG//.right_lambda();
    }

    // lambda compound traversal algorithms

    template< typename FunctorT >
    void traverse_bottom_up( FunctorT& functor_ )
    {
        m_lambda.traverse_bottom_up( functor_ );
    }
    
    template< typename FunctorT >
    void traverse_top_down( FunctorT& functor_ )
    {
        m_lambda.traverse_top_down( functor_ );
    }
    
    template< typename FunctorT >
    void traverse_bottom_up( FunctorT& functor_ ) const
    {
        m_lambda.traverse_bottom_up( functor_ );
    }
    
    template< typename FunctorT >
    void traverse_top_down( FunctorT& functor_ ) const
    {
        m_lambda.traverse_top_down( functor_ );
    }
    
    template< typename FunctorT >
    void subscript_top_down( FunctorT& functor_ ) const
    {
        m_lambda.subscript_top_down( functor_ );
    }

    template< typename FunctorT >
    void subscript_bottom_up( FunctorT& functor_ ) const
    {
        m_lambda.subscript_bottom_up( functor_ );
    }

    // Lambda primitive stack interface support

    template< typename SubscriptLambdaT, typename InputValueT >
    void push( SubscriptLambdaT subscript_, InputValueT const& data_ )
    {
        m_lambda.push( subscript_, m_translator( data_ ) );
    }

    template< typename SubscriptLambdaT >
    void pop( SubscriptLambdaT subscript_ )
    {
        m_lambda.pop( subscript_ );
    }

    template< typename SubscriptLambdaT >
    value_T const& top( SubscriptLambdaT subscript_ ) const
    {
        return m_lambda.top( subscript_ );
    }

    template< typename SubscriptLambdaT >
    value_T& top( SubscriptLambdaT subscript_ )
    {
        return m_lambda.top( subscript_ );
    }

    template< typename SubscriptLambdaT >
    size_t size( SubscriptLambdaT subscript_ ) const
    {
        return m_lambda.size( subscript_ );
    }

    template< typename SubscriptLambdaT >
    std::stack< value_T >* stack_ptr( SubscriptLambdaT subscript_ )
    {
        return m_lambda.stack_ptr( subscript_ );
    }

    template< typename SubscriptLambdaT >
    std::stack< value_T > const* stack_ptr( SubscriptLambdaT subscript_ ) const
    {
        return m_lambda.stack_ptr( subscript_ );
    }

#ifdef CTTL_LAMBDA_REFLECTION

    typedef xst_translator< typename LambdaT::reflection_T, TranslatorT > reflection_T;

    reflection_T reflection() const
    {
        return reflection_T( m_lambda.reflection() );
    }
#endif // CTTL_LAMBDA_REFLECTION

private:
    // Implementation

    LambdaT m_lambda;

    TranslatorT m_translator;

    // subscript traversal algorithms

    template< typename SubscriptLambdaT, typename FunctorT >
    void xsubscript_top_down_subtree_switch( SubscriptLambdaT subscript_, FunctorT& functor_ ) const
    {
        m_lambda.xsubscript_top_down_subtree_switch( subscript_, functor_ );
    }

    template< int LocationT, typename FunctorT >
    void xsubscript_top_down_descend( FunctorT& functor_ ) const
    {
        m_lambda.xsubscript_top_down_descend< LocationT >( functor_ );
    }

    template< int LocationT, typename SubscriptLambdaT, typename FunctorT >
    void xsubscript_top_down_subtree_descend( SubscriptLambdaT subscript_, FunctorT& functor_ ) const
    {
        m_lambda.xsubscript_top_down_subtree_descend< LocationT >( subscript_, functor_ );
    }

    // subscript bottom up traversal

    template< typename SubscriptLambdaT, typename FunctorT >
    void xsubscript_bottom_up_subtree_switch( SubscriptLambdaT subscript_, FunctorT& functor_ ) const
    {
        m_lambda.xsubscript_bottom_up_subtree_switch( subscript_, functor_ );
    }

    template< int LocationT, typename FunctorT >
    void xsubscript_bottom_up_descend( FunctorT& functor_ ) const
    {
        m_lambda.xsubscript_bottom_up_descend< LocationT >( functor_ );
    }

    template< int LocationT, typename SubscriptLambdaT, typename FunctorT >
    void xsubscript_bottom_up_subtree_descend( SubscriptLambdaT subscript_, FunctorT& functor_ ) const
    {
        m_lambda.xsubscript_bottom_up_subtree_descend< LocationT >( subscript_, functor_ );
    }


    // Lambda primitive stack interface support

    template< int LocationT, typename InputValueT >
    void xpush_at_location( InputValueT const& data_ )
    {
        m_lambda.xpush_at_location< LocationT >( m_translator( data_ ) );
    }

    template< int LocationT, typename InputValueT >
    void xpush_descend( InputValueT const& data_ )
    {
        m_lambda.xpush_descend< LocationT >( m_translator( data_ ) );
    }

    template< typename SubscriptLambdaT, typename InputValueT >
    void xpush_sub_split( SubscriptLambdaT subscript_, InputValueT const& data_ )
    {
        m_lambda.xpush_sub_split( subscript_, m_translator( data_ ) );
    }

    template< int LocationT, typename SubscriptLambdaT, typename InputValueT >
    void xpush_sub_descend( SubscriptLambdaT subscript_, InputValueT const& data_ )
    {
        m_lambda.xpush_sub_descend< LocationT >( subscript_, m_translator( data_ ) );
    }


    template< int LocationT >
    void xpop_at_location()
    {
        m_lambda.xpop_at_location< LocationT >();
    }

    template< int LocationT >
    void xpop_descend()
    {
        m_lambda.xpop_descend< LocationT >();
    }

    template< typename SubscriptLambdaT >
    void xpop_sub_split( SubscriptLambdaT subscript_ )
    {
        m_lambda.xpop_sub_split( subscript_ );
    }

    template< int LocationT, typename SubscriptLambdaT >
    void xpop_sub_descend( SubscriptLambdaT subscript_ )
    {
        m_lambda.xpop_sub_descend< LocationT >( subscript_ );
    }

    template< int LocationT >
    value_T const& xtop_at_location() const
    {
        return m_lambda.xtop_at_location< LocationT >();
    }

    template< int LocationT >
    value_T const& xtop_descend() const
    {
        return m_lambda.xtop_descend< LocationT >();
    }

    template< typename SubscriptLambdaT >
    value_T const& xtop_sub_split( SubscriptLambdaT subscript_ ) const
    {
        return m_lambda.xtop_sub_split( subscript_ );
    }

    template< int LocationT, typename SubscriptLambdaT >
    value_T const& xtop_sub_descend( SubscriptLambdaT subscript_ ) const
    {
        return m_lambda.xtop_sub_descend< LocationT >( subscript_ );
    }


    // mutable data access

    template< int LocationT >
    value_T& xtop_at_location()
    {
        return m_lambda.xtop_at_location< LocationT >();
    }


    template< int LocationT >
    value_T& xtop_descend()
    {
        return m_lambda.xtop_descend< LocationT >();
    }

    // subscript access to lambda primitive

    template< typename SubscriptLambdaT >
    value_T& xtop_sub_split( SubscriptLambdaT subscript_ )
    {
        return m_lambda.xtop_sub_split( subscript_ );
    }

    template< int LocationT, typename SubscriptLambdaT >
    value_T& xtop_sub_descend( SubscriptLambdaT subscript_ )
    {
        return m_lambda.xtop_sub_descend< LocationT >( subscript_ );
    }

    template< int LocationT >
    size_t xsize_at_location() const
    {
        return m_lambda.xsize_at_location< LocationT >();
    }

    template< int LocationT >
    size_t xsize_descend() const
    {
        return m_lambda.xsize_descend< LocationT >();
    }

    template< typename SubscriptLambdaT >
    size_t xsize_sub_split( SubscriptLambdaT subscript_ ) const
    {
        return m_lambda.xsize_sub_split( subscript_ );
    }

    template< int LocationT, typename SubscriptLambdaT >
    size_t xsize_sub_descend( SubscriptLambdaT subscript_ ) const
    {
        return m_lambda.xsize_sub_descend< LocationT >( subscript_ );
    }


    template< int LocationT >
    std::stack< value_T >* xstack_ptr_at_location()
    {
        return m_lambda.xstack_ptr_at_location< LocationT >();
    }

    template< int LocationT >
    std::stack< value_T >* xstack_ptr_descend()
    {
        return m_lambda.xstack_ptr_descend< LocationT >();
    }

    template< typename SubscriptLambdaT >
    std::stack< value_T >* xstack_ptr_sub_split( SubscriptLambdaT subscript_ )
    {
        return m_lambda.xstack_ptr_sub_split( subscript_ );
    }

    template< int LocationT, typename SubscriptLambdaT >
    std::stack< value_T >* xstack_ptr_sub_descend( SubscriptLambdaT subscript_ )
    {
        return m_lambda.xstack_ptr_sub_descend< LocationT >( subscript_ );
    }


    template< int LocationT >
    std::stack< value_T > const* xstack_ptr_at_location() const
    {
        return m_lambda.xstack_ptr_at_location< LocationT >();
    }

    template< int LocationT >
    std::stack< value_T > const* xstack_ptr_descend() const
    {
        return m_lambda.xstack_ptr_descend< LocationT >();
    }

    template< typename SubscriptLambdaT >
    std::stack< value_T > const* xstack_ptr_sub_split( SubscriptLambdaT subscript_ ) const
    {
        return m_lambda.xstack_ptr_sub_split( subscript_ );
    }

    template< int LocationT, typename SubscriptLambdaT >
    std::stack< value_T > const* xstack_ptr_sub_descend( SubscriptLambdaT subscript_ ) const
    {
        return m_lambda.xstack_ptr_sub_descend< LocationT >( subscript_ );
    }


};  // xst_translator


}   // namespace cttl_impl


#endif //_XST_TRANSLATOR_H_INCLUDED_

---