xtl_base.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/

// xtl_base.h

#ifndef _CTTL_XTLBASE_H_INCLUDED_
#define _CTTL_XTLBASE_H_INCLUDED_

#include "coreutils.h"
#include "xtl_trace.h"

namespace cttl_impl {

typedef int ( *iswhat_T )( int );

typedef int ( *iswwhat_T )( wint_t );

template< typename ExprT >
struct xtl_wrap {

    // compile-time

    ExprT m_expr;

    xtl_wrap()
    : m_expr( ExprT() )
    {
//      CTTL_TRACE_MESSAGE( CTTL_TRACE_TYPEID( &m_expr ) );
    }

    template< typename GenericT >
    xtl_wrap( GenericT const& x_ )
    : m_expr( ExprT( x_ ) )
    {
//      CTTL_TRACE_MESSAGE( CTTL_TRACE_TYPEID( &m_expr ) );
    }

    xtl_wrap( xtl_wrap< ExprT > const& other_ )
    : m_expr( other_.m_expr )
    {
    }

    template< typename UniverseT >
    size_t match( UniverseT& edge_ )
    {
        return m_expr.match( edge_ );
    }

    template< typename UniverseT >
    size_t find( UniverseT& edge_ )
    {
        return m_expr.find( edge_ );
    }

    template< typename UniverseT >
    size_t bang_find( UniverseT& edge_ )
    {
        return m_expr.bang_find( edge_ );
    }

    template< typename UniverseT >
    size_t runtime_match( UniverseT& edge_ )
    {
        if ( edge_.parent().container().m_flags.test( xtl_flag_runtime_bang_find ) ) {
            edge_.parent().container().m_flags.clear( xtl_flag_runtime_bang_find );
            return m_expr.bang_find( edge_ );

        } else if ( edge_.parent().container().m_flags.test( xtl_flag_runtime_find ) ) {
            edge_.parent().container().m_flags.clear( xtl_flag_runtime_find );
            return m_expr.find( edge_ );
        }
        
        return m_expr.match( edge_ );
    }

};  // xtl_wrap


template< typename EdgeT, typename ExprT >
class xtl_edge {

private:
    EdgeT m_edge;

    ExprT m_expr;

public:
    // compile-time

    xtl_edge( EdgeT const& edge_,  ExprT const& expr_ )
    : m_edge( edge_ ), m_expr( expr_ )
    {
    }

    // run-time

    template< typename UniverseT >
    size_t match( UniverseT& edge_ )
    {
        CTTL_TRACE_LEVEL_MATCH( 'e' );
        size_t match_offset = m_expr.match( edge_ );
        if ( match_offset != UniverseT::string_T::npos ) {
            m_edge.first.offset( match_offset );
            m_edge.second.offset( edge_.first.offset() );
            CTTL_TRACE_EDGE_RESULT_TRUE( 'e' );
            return match_offset;
        }

        CTTL_TRACE_EDGE_RESULT_FALSE( 'e', m_edge.first.identity() );
        return UniverseT::string_T::npos;
    }
    
    template< typename UniverseT >
    size_t find( UniverseT& edge_ )
    {
        CTTL_TRACE_LEVEL_FIND( 'e' );
        size_t match_offset = m_expr.find( edge_ );
        if ( match_offset != UniverseT::string_T::npos ) {
            m_edge.first.offset( match_offset );
            m_edge.second.offset( edge_.first.offset() );
            CTTL_TRACE_EDGE_RESULT_TRUE( 'e' );
            return match_offset;
        }

        CTTL_TRACE_EDGE_RESULT_FALSE( 'e', m_edge.first.identity() );
        return UniverseT::string_T::npos;
    }
    
    template< typename UniverseT >
    size_t bang_find( UniverseT& edge_ )
    {
        CTTL_TRACE_LEVEL_BANG( 'e' );
        size_t match_offset = m_expr.bang_find( edge_ );
        if ( match_offset != UniverseT::string_T::npos ) {
            m_edge.first.offset( match_offset );
            m_edge.second.offset( edge_.first.offset() );
            CTTL_TRACE_EDGE_RESULT_TRUE( 'e' );
            return match_offset;
        }

        CTTL_TRACE_EDGE_RESULT_FALSE( 'e', m_edge.first.identity() );
        return UniverseT::string_T::npos;
    }
    
};  // xtl_edge


template< typename NodeT, typename ExprT >
class xtl_node {

private:
    NodeT m_node;

    ExprT m_expr;

public:
    // compile-time

    xtl_node( NodeT const& node_,  ExprT const& expr_ )
    : m_node( node_ ), m_expr( expr_ )
    {
    }

    // run-time

    template< typename UniverseT >
    size_t match( UniverseT& edge_ )
    {
        typedef typename UniverseT::strict_edge_T strict_universe_T;

        CTTL_TRACE_LEVEL_MATCH( 'n' );
        size_t match_offset = m_expr.match( edge_ );
        if ( match_offset != UniverseT::string_T::npos ) {
            m_node.offset( match_offset );
            // strict_universe_T needed, otherwise a custom policy
            // would have to have a default constructor:
            CTTL_TRACE_NODE_RESULT_TRUE( 'n', strict_universe_T( m_node.parent(), m_node.identity(), edge_.first.identity() ) );
            return match_offset;
        }

        CTTL_TRACE_NODE_RESULT_FALSE( 'n', m_node.identity() );
        return UniverseT::string_T::npos;
    }
    
    template< typename UniverseT >
    size_t find( UniverseT& edge_ )
    {
        typedef typename UniverseT::strict_edge_T strict_universe_T;

        CTTL_TRACE_LEVEL_FIND( 'n' );
        size_t match_offset = m_expr.find( edge_ );
        if ( match_offset != UniverseT::string_T::npos ) {
            m_node.offset( match_offset );
            // strict_universe_T needed, otherwise a custom policy
            // would have to have a default constructor:
            CTTL_TRACE_NODE_RESULT_TRUE( 'n', strict_universe_T( m_node.parent(), m_node.identity(), edge_.first.identity() ) );
            return match_offset;
        }

        CTTL_TRACE_NODE_RESULT_FALSE( 'n', m_node.identity() );
        return UniverseT::string_T::npos;
    }
    
    template< typename UniverseT >
    size_t bang_find( UniverseT& edge_ )
    {
        typedef typename UniverseT::strict_edge_T strict_universe_T;

        CTTL_TRACE_LEVEL_BANG( 'n' );
        size_t match_offset = m_expr.bang_find( edge_ );
        if ( match_offset != UniverseT::string_T::npos ) {
            m_node.offset( match_offset );
            // strict_universe_T needed, otherwise a custom policy
            // would have to have a default constructor:
            CTTL_TRACE_NODE_RESULT_TRUE( 'n', strict_universe_T( m_node.parent(), m_node.identity(), edge_.first.identity() ) );
            return match_offset;
        }

        CTTL_TRACE_NODE_RESULT_FALSE( 'n', m_node.identity() );
        return UniverseT::string_T::npos;
    }
    
};  // xtl_node


}   // namespace cttl_impl

#endif // _CTTL_XTLBASE_H_INCLUDED_

---