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

// policy.h

#ifndef _CTTL_POLICY_H_INCLUDED_
#define _CTTL_POLICY_H_INCLUDED_

#include "xtl_region_map.h"

namespace cttl {

using namespace cttl_impl;  

const int flag_follow_space     = 1;

const int flag_follow_region    = 2;

const int flag_greedy           = 4;

const int flag_cpp_comments     = 8;

const int flag_follow_either    = flag_follow_space | flag_follow_region;

class policy_mapped_space
{
protected:
    xtl_region_map m_region_map;

public:
    typedef policy_default strict_policy_T;


    template< typename ExprT, typename UniverseT >
    size_t match( xtl_wrap< ExprT > derived_expr_, UniverseT& universe_ )
    {
        for( ;; ) {
            if ( derived_expr_.match( universe_ ) != UniverseT::string_T::npos ) {
                if ( lower_bound( universe_.first.offset(), universe_ ) )
                    continue;
                else
                    break;
            }

            if ( lower_bound( universe_.first.offset(), universe_ ) )
                continue;

            break;
        }

        return universe_.first.offset();
    }

    template< typename UniverseT >
    bool lower_bound( size_t old_offset_, UniverseT& universe_ )
    {
        size_t new_offset = lower_bound( old_offset_, universe_.second.offset() );
        if ( new_offset != old_offset_ ) {
            universe_.first.offset( new_offset );
            return true;
        }

        return false;
    }

    size_t lower_bound( size_t offset_, size_t universe_length_ )
    {
        return m_region_map.find_not_region( offset_, universe_length_ );
    }

    template< typename StringT, typename CharT >
    void text_insert_go( node< StringT >& node_, CharT const* pchar_ )
    {
        text_insert_go( node_, StringT( pchar_ ) );
    }

    template< typename StringT >
    void text_insert_go( node< StringT >& node_, StringT const& str_ )
    {
        size_t str_length = str_.length();

        if ( !str_.length() )
            return; // nothing to do

        size_t insertion_offset = node_.offset();

        node_.parent().container().text().insert(
            insertion_offset,
            str_
            );
        
        m_region_map.adjust(
            insertion_offset,
            str_length
            );
        
        xtl_identity_insert_go< StringT > insert_go(
            insertion_offset,
            int( str_length )
            );

        size_t idx = 0;
        for ( idx = 0; idx < node_.parent().container().identity_vector().size(); ++idx )
            insert_go.adjust( node_.parent().container().identity_vector()[ idx ] );

        for ( idx = 0; idx < node_.parent().container().offset_stack().size(); ++idx )
            insert_go.adjust( node_.parent().container().offset_stack()[ idx ] );
    }

    template< typename StringT, typename PolicyT >
    void text_insert_go( node< StringT >& node_target_, const_edge< PolicyT, StringT > const& edge_source_ )
    {
        StringT const& str = edge_source_.parent().container().text();
        size_t source_from_offset_ = edge_source_.first.offset();   // a substring of the source string
        size_t source_to_offset_ = edge_source_.second.offset();

        size_t str_length = source_to_offset_ - source_from_offset_;

        if ( !str.length() )
            return; // nothing to do

        size_t insertion_offset = node_target_.offset();

        node_target_.parent().container().text().insert(
            insertion_offset,
            str,
            source_from_offset_,
            str_length
            );
        
        m_region_map.adjust(
            insertion_offset,
            str_length
            );
        
        xtl_identity_insert_go< StringT > insert_go(
            insertion_offset,
            int( str_length )
            );

        size_t idx = 0;
        for ( idx = 0; idx < node_target_.parent().container().identity_vector().size(); ++idx )
            insert_go.adjust( node_target_.parent().container().identity_vector()[ idx ] );

        for ( idx = 0; idx < node_target_.parent().container().offset_stack().size(); ++idx )
            insert_go.adjust( node_target_.parent().container().offset_stack()[ idx ] );
    }
    

    template< typename StringT, typename CharT >
    void text_insert_stay( node< StringT >& node_, CharT const* pchar_ )
    {
        text_insert_stay( node_, StringT( pchar_ ) );
    }

    template< typename StringT >
    void text_insert_stay( node< StringT >& node_, StringT const& str_ )
    {
        size_t str_length = str_.length();

        if ( !str_length )
            return; // nothing to do

        size_t insertion_offset = node_.offset();

        node_.parent().container().text().insert(
            insertion_offset,
            str_
            );

        m_region_map.adjust(
            insertion_offset,
            str_length
            );
        
        xtl_identity_insert_stay< StringT > insert_stay(
            insertion_offset,
            str_length
            );

        size_t idx = 0;
        for ( idx = 0; idx < node_.parent().container().identity_vector().size(); ++idx )
            insert_stay.adjust( node_.parent().container().identity_vector()[ idx ] );

        for ( idx = 0; idx < node_.parent().container().offset_stack().size(); ++idx )
            insert_stay.adjust( node_.parent().container().offset_stack()[ idx ] );
    }


    template< typename StringT, typename PolicyT >
    void text_insert_stay( node< StringT >& node_target_, const_edge< PolicyT, StringT > const& edge_source_ )
    {
        StringT const& str = edge_source_.parent().container().text();
        size_t source_from_offset_ = edge_source_.first.offset();   // a substring of the source string
        size_t source_to_offset_ = edge_source_.second.offset();

        size_t str_length = source_to_offset_ - source_from_offset_;

        if ( !str_length )
            return; // nothing to do

        size_t insertion_offset = node_target_.offset();

        node_target_.parent().container().text().insert(
            insertion_offset,
            str,
            source_from_offset_,
            str_length
            );

        m_region_map.adjust(
            insertion_offset,
            str_length
            );
        
        xtl_identity_insert_stay< StringT > insert_stay(
            insertion_offset,
            str_length
            );

        size_t idx = 0;
        for ( idx = 0; idx < node_target_.parent().container().identity_vector().size(); ++idx )
            insert_stay.adjust( node_target_.parent().container().identity_vector()[ idx ] );

        for ( idx = 0; idx < node_target_.parent().container().offset_stack().size(); ++idx )
            insert_stay.adjust( node_target_.parent().container().offset_stack()[ idx ] );
    }

    void region_clear()
    {
        m_region_map.clear();
    }

    void region_adjust( size_t after_offset_, int delta_offset_ )
    {
        m_region_map.adjust( after_offset_, delta_offset_ );
    }

    void region_insert( size_t first_offset_, size_t second_offset_ )
    {
        m_region_map.insert(
            first_offset_,
            second_offset_
            );
    }

    void region_erase( size_t first_offset_, size_t second_offset_ )
    {
        m_region_map.erase(
            first_offset_,
            second_offset_
            );
    }

    template< typename StringT >
    StringT region_difference( StringT const& str_, size_t first_offset_, size_t second_offset_ )
    {
        return m_region_map.text_difference(
            str_,
            first_offset_,
            second_offset_
            );
    }

};  // class policy_mapped_space

template< int White_spaceT = flag_follow_space >
struct policy_space
{
};  // struct policy_space<>

template<>
struct policy_space< flag_follow_space > : public policy_default
{
    template< typename UniverseT >
    size_t match( UniverseT& universe_ )
    {
        CTTL_TRACE_SILENT( true );
        typedef typename UniverseT::char_T char_T;
        size_t non_greedy_offset = universe_.first.offset();
        (
            true
            ^
            +(
                symbol( char_T( ' ' ) )
                |
                symbol( char_T( '\n' ) )
                |
                symbol( char_T( '\r' ) )
                |
                symbol( char_T( '\t' ) )
                |
                symbol( char_T( '\v' ) )
                |
                symbol( char_T( '\f' ) )
            )
        ).match( universe_ );
        // policy_space is non-greedy:
        return non_greedy_offset;
    }
};  // struct policy_space< flag_follow_space >

template<>
struct policy_space< flag_follow_region > : public policy_mapped_space
{
    template< typename UniverseT >
    size_t match( UniverseT& universe_ )
    {
        size_t non_greedy_offset = universe_.first.offset();
        lower_bound( non_greedy_offset, universe_ );
        // policy_space is non-greedy:
        return non_greedy_offset;
    }
};  // struct policy_space< flag_follow_region >


template<>
struct policy_space< flag_follow_space | flag_follow_region > : public policy_space< flag_follow_region >
{
    template< typename UniverseT >
    size_t match( UniverseT& universe_ )
    {
        CTTL_TRACE_SILENT( true );
        typedef typename UniverseT::char_T char_T;
        size_t non_greedy_offset = universe_.first.offset();
        policy_mapped_space::match(
            true
            ^
            +(
                symbol( char_T( ' ' ) )
                |
                symbol( char_T( '\n' ) )
                |
                symbol( char_T( '\r' ) )
                |
                symbol( char_T( '\t' ) )
                |
                symbol( char_T( '\v' ) )
                |
                symbol( char_T( '\f' ) )
            ),
            universe_
        );
        // policy_space is non-greedy:
        return non_greedy_offset;
    }
};  // struct policy_space< flag_follow_space | flag_follow_region >


template<>
struct policy_space< flag_greedy | flag_follow_space > : public policy_space< flag_follow_space >
{
    template< typename UniverseT >
    size_t match( UniverseT& universe_ )
    {
        CTTL_TRACE_SILENT( true );
        typedef typename UniverseT::char_T char_T;
        (
            true
            ^
            +(
                symbol( char_T( ' ' ) )
                |
                symbol( char_T( '\n' ) )
                |
                symbol( char_T( '\r' ) )
                |
                symbol( char_T( '\t' ) )
                |
                symbol( char_T( '\v' ) )
                |
                symbol( char_T( '\f' ) )
            )
        ).match( universe_ );
        // greedy evaluation:
        return universe_.first.offset();
    }
};  // struct policy_space< flag_greedy | flag_follow_space >


template<>
struct policy_space< flag_greedy > : public policy_space< flag_greedy | flag_follow_space >
{
};  // struct policy_space< flag_greedy >


template<>
struct policy_space< flag_greedy | flag_follow_region > : public policy_space< flag_follow_region >
{
    template< typename UniverseT >
    size_t match( UniverseT& universe_ )
    {
        lower_bound( universe_.first.offset(), universe_ );
        // greedy evaluation:
        return universe_.first.offset();
    }
};  // struct policy_space< flag_greedy | flag_follow_region >


template<>
struct policy_space< flag_greedy | flag_follow_space | flag_follow_region > : public policy_space< flag_follow_space | flag_follow_region >
{
    template< typename UniverseT >
    size_t match( UniverseT& universe_ )
    {
        CTTL_TRACE_SILENT( true );
        typedef typename UniverseT::char_T char_T;
        policy_mapped_space::match(
            true
            ^
            +(
                symbol( char_T( ' ' ) )
                |
                symbol( char_T( '\n' ) )
                |
                symbol( char_T( '\r' ) )
                |
                symbol( char_T( '\t' ) )
                |
                symbol( char_T( '\v' ) )
                |
                symbol( char_T( '\f' ) )
            ),
            universe_
        );
        // greedy evaluation:
        return universe_.first.offset();
    }
};  // struct policy_space< flag_greedy | flag_follow_space | flag_follow_region >


template<>
struct policy_space< flag_cpp_comments > : public policy_default
{
    template< typename UniverseT >
    static size_t match( UniverseT& universe_ )
    {
        CTTL_TRACE_SILENT( true );
        size_t non_greedy_offset = universe_.first.offset();
        (
            true ^ rule( policy_space< flag_cpp_comments >::space_and_comment )

        ).match( universe_ );

        // policy_space is non-greedy:
        return non_greedy_offset;
    }

    static size_t space_and_comment( const_edge< policy_default, CTTL_STD_STRING >& universe_ )
    {
        return (
            (
                entity( isspace )
                +
                (
                    (
                        rule( policy_space< flag_cpp_comments >::comment )
                        +
                        rule( policy_space< flag_cpp_comments >::space_and_comment )
                    )
                    |
                    begin( true )
                )
            )
            |
            (
                rule( policy_space< flag_cpp_comments >::comment )
                +
                (
                    rule( policy_space< flag_cpp_comments >::space_and_comment )
                    |
                    begin( true )
                )
            )
            |
            begin( true )

        ).match( universe_ );
    }

    static size_t comment( const_edge< policy_default, CTTL_STD_STRING >& universe_ )
    {
        return (
            begin( '/' )
            +
            (
                ( symbol( '/' ) + symbol( '/' ) + !universe_.first( symbol( '\n' ) | end() ) )
                |
                ( symbol( '/' ) + symbol( '*' ) + !!( symbol( '*' ) + symbol( '/' ) ) )
            )
        ).match( universe_ );
    }

};  // struct policy_space< flag_cpp_comments >


template<>
struct policy_space< flag_greedy | flag_cpp_comments > : public policy_space< flag_cpp_comments >
{
    template< typename UniverseT >
    static size_t match( UniverseT& universe_ )
    {
        policy_space< flag_cpp_comments >::match( universe_ );
        return universe_.first.offset();
    }

};

}   // namespace cttl

#endif // _CTTL_POLICY_H_INCLUDED_

---