xst_scalar.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_scalar.h

#ifndef _XST_SCALAR_H_INCLUDED_
#define _XST_SCALAR_H_INCLUDED_

namespace cttl_impl {


template< typename ValueT >
struct xst_scalar {

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

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

    typedef typename xst_storage_adaptor< ValueT >::value_type value_T;

    typedef typename xst_non_scalar_traits< value_T >::value_type unmodified_dereferenced_T;

    typedef typename xst_dereference_traits< value_T, unmodified_dereferenced_T >::value_type dereferenced_value_T;

    typedef xst_scalar< ValueT > left_T;

    typedef xst_scalar< ValueT > right_T;
    
    enum {
        const_value_,

        depth_ = 1,

        capacity_ = xst_dereference_traits< value_T, unmodified_dereferenced_T >::capacity_,

        primitive_id_ = primitive_id_scalar
    };

    typedef xst_scalar< typename xst_storage_adaptor< ValueT >::reference > reference_T;

    xst_scalar()
    {
    }

    xst_scalar( ValueT data_ )
    :
    m_value( data_ )
    {
    }

    xst_scalar( xst_scalar< ValueT > const& other_ )
    :
    m_value( other_.m_value )
    {
    }

    reference_T make_reference() const
    {
        return reference_T( const_cast< xst_scalar< ValueT >* >( this )->m_value.value() );
    }
    
    template<
        int LocationT
    >
    dereferenced_value_T&
    dereferenced_value( xst_lambda_wrap< xst_const_scalar< LocationT > > subscript_ )
    {
        // if unmodified_dereferenced_T is void, no dereference is attempted
        return xst_dereference_traits< value_T, unmodified_dereferenced_T >::dereference( top( subscript_ ) );
    }

    // Direct access to scalar primitive

    left_T& left_lambda()
    {
        return *this;
    }

    left_T const& left_lambda() const
    {
        return *this;
    }

    right_T& right_lambda()
    {
        return *this;
    }

    right_T const& right_lambda() const
    {
        return *this;
    }


    // subscript traversal algorithms

    template< typename FunctorT >
    static void subscript_top_down( FunctorT& functor_ )
    {
        functor_( const_scalar( 0 ) );
    }

    template< typename FunctorT >
    static void subscript_bottom_up( FunctorT& functor_ )
    {
        functor_( const_scalar( 0 ) );
    }

    // lambda compound traversal algorithms

    template< typename FunctorT >
    void traverse_bottom_up( FunctorT& functor_ )
    {
        functor_( *this );
    }
    
    template< typename FunctorT >
    void traverse_top_down( FunctorT& functor_ )
    {
        functor_( *this );
    }
    
    template< typename FunctorT >
    void traverse_bottom_up( FunctorT& functor_ ) const
    {
        functor_( *this );
    }
    
    template< typename FunctorT >
    void traverse_top_down( FunctorT& functor_ ) const
    {
        functor_( *this );
    }
    

    // Lambda primitive stack interface support

    template<
        int LocationT,
        typename InputValueT
    >
    void
    push(
        xst_lambda_wrap< xst_const_scalar< LocationT > >,
        InputValueT const& data_
        )
    {
        xpush_descend< depth_ - LocationT - 1 >( data_ );
    }

    template<
        int LocationT
    >
    void
    pop(
        xst_lambda_wrap< xst_const_scalar< LocationT > >
        )
        
    {
        xpop_descend< depth_ - LocationT - 1 >();
    }

    template<
        int LocationT
    >
    value_T const& top(
        xst_lambda_wrap< xst_const_scalar< LocationT > >
        )
         const
    {
        return xtop_descend< depth_ - LocationT - 1 >();
    }

    template<
        int LocationT
    >
    value_T& top(
        xst_lambda_wrap< xst_const_scalar< LocationT > >
        )
        
    {
        return xtop_descend< depth_ - LocationT - 1 >();
    }

    template<
        int LocationT
    >
    size_t
    size(
        xst_lambda_wrap< xst_const_scalar< LocationT > >
        )
        const
    {
        return 1;
    }

    template<
        int LocationT
    >
    std::stack< value_T > const*
    stack_ptr(
        xst_lambda_wrap< xst_const_scalar< LocationT > >
        )
        const
    {
        assert( !LocationT );
        return NULL;
    }

    template<
        int LocationT
    >
    std::stack< value_T >*
    stack_ptr(
        xst_lambda_wrap< xst_const_scalar< LocationT > >
        )
    {
        assert( !LocationT );
        return NULL;
    }

#ifdef CTTL_LAMBDA_REFLECTION

    typedef xst_scalar< ValueT > reflection_T;

    reflection_T reflection() const
    {
        return *this;
    }
#endif // CTTL_LAMBDA_REFLECTION

private:
    // Implementation

    xst_storage_adaptor< ValueT > m_value;

    template< int LocationT, typename InputValueT >
    void xpush_at_location( InputValueT const& data_ )
    {
        assert( !LocationT );
        m_value.value() = data_;
    }

    template< int LocationT >
    void xpop_at_location()
    {
        assert( !LocationT );
    }

    template< int LocationT >
    value_T const& xtop_at_location() const
    {
        assert( !LocationT );
        CTTL_TRACE_DEPOSIT_TEXT( xst_storage_adaptor< ValueT >::trace_char() );
        CTTL_TRACE_DEPOSIT_TEXT( xst_non_scalar_traits< value_T >::identity( m_value.const_value() ) );
        CTTL_TRACE_DEPOSIT_TEXT( ' ' );
        return m_value.const_value();
    }

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

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

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

    // subscript traversal algorithms

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

    template< int LocationT, typename FunctorT >
    static void xsubscript_top_down_descend( FunctorT& )
    {
        assert( false );
    }

    template< int LocationT, typename SubscriptLambdaT, typename FunctorT >
    static void xsubscript_top_down_subtree_descend( SubscriptLambdaT, FunctorT& )
    {
        assert( false );
    }

    // subscript bottom up traversal

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

    template< int LocationT, typename FunctorT >
    static void xsubscript_bottom_up_descend( FunctorT& )
    {
        assert( false );
    }

    template< int LocationT, typename SubscriptLambdaT, typename FunctorT >
    static void xsubscript_bottom_up_subtree_descend( SubscriptLambdaT, FunctorT& )
    {
        assert( false );
    }

    // Lambda primitive stack interface support

    template< typename SubscriptLambdaT, typename InputValueT >
    void xpush_sub_split( SubscriptLambdaT, InputValueT const& )
    {
        assert( false );
    }

    template< int LocationT, typename SubscriptLambdaT, typename InputValueT >
    void xpush_sub_descend( SubscriptLambdaT, InputValueT const& )
    {
        assert( false );
    }

    template< typename SubscriptLambdaT >
    void xpop_sub_split( SubscriptLambdaT )
    {
        assert( false );
    }

    template< int LocationT, typename SubscriptLambdaT >
    void xpop_sub_descend( SubscriptLambdaT )
    {
        assert( false );
    }



    template< typename SubscriptLambdaT >
    value_T const& xtop_sub_split( SubscriptLambdaT ) const
    {
        assert( false );
        return m_value.const_value();
    }

    template< int LocationT, typename SubscriptLambdaT >
    value_T const& xtop_sub_descend( SubscriptLambdaT ) const
    {
        assert( false );
        return m_value.const_value();
    }

    // mutable data access

    template< int LocationT >
    value_T& xtop_at_location()
    {
        assert( !LocationT );
        CTTL_TRACE_DEPOSIT_TEXT( "->" );
        CTTL_TRACE_DEPOSIT_TEXT( xst_storage_adaptor< ValueT >::trace_char() );
        CTTL_TRACE_DEPOSIT_TEXT( xst_non_scalar_traits< value_T >::identity( m_value.const_value() ) );
        CTTL_TRACE_DEPOSIT_TEXT( ' ' );
        return m_value.value();
    }

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

    template< typename SubscriptLambdaT >
    value_T& xtop_sub_split( SubscriptLambdaT )
    {
        assert( false );
        return m_value.value();
    }

    template< int LocationT, typename SubscriptLambdaT >
    value_T& xtop_sub_descend( SubscriptLambdaT )
    {
        assert( false );
        return m_value.value();
    }


    template< int LocationT >
    size_t xsize_at_location() const
    {
        assert( !LocationT );
        return 1;
    }

    template< int LocationT >
    size_t xsize_descend() const
    {
        assert( !LocationT );
        return 1;
    }

    template< typename SubscriptLambdaT >
    size_t xsize_sub_split( SubscriptLambdaT ) const
    {
        assert( false );
        return 1;
    }

    template< int LocationT, typename SubscriptLambdaT >
    size_t xsize_sub_descend( SubscriptLambdaT ) const
    {
        assert( false );
        return 1;
    }

    template< int LocationT >
    std::stack< value_T > const* xstack_ptr_at_location() const
    {
        assert( !LocationT );
        return NULL;
    }

    template< int LocationT >
    std::stack< value_T > const* xstack_ptr_descend() const
    {
        assert( !LocationT );
        return NULL;
    }

    template< typename SubscriptLambdaT >
    std::stack< value_T > const* xstack_ptr_sub_split( SubscriptLambdaT ) const
    {
        assert( false );
        return NULL;
    }

    template< int LocationT, typename SubscriptLambdaT >
    std::stack< value_T > const* xstack_ptr_sub_descend( SubscriptLambdaT ) const
    {
        assert( false );
        return NULL;
    }


    template< int LocationT >
    std::stack< value_T >* xstack_ptr_at_location()
    {
        assert( !LocationT );
        return NULL;
    }

    template< int LocationT >
    std::stack< value_T >* xstack_ptr_descend()
    {
        assert( !LocationT );
        return NULL;
    }

    template< typename SubscriptLambdaT >
    std::stack< value_T >* xstack_ptr_sub_split( SubscriptLambdaT )
    {
        assert( false );
        return NULL;
    }

    template< int LocationT, typename SubscriptLambdaT >
    std::stack< value_T >* xstack_ptr_sub_descend( SubscriptLambdaT )
    {
        assert( false );
        return NULL;
    }

};  // xst_scalar


}   // namespace cttl_impl


#endif //_XST_SCALAR_H_INCLUDED_

---