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

// node.h

#ifndef _CTTL_NODE_H_INCLUDED_
#define _CTTL_NODE_H_INCLUDED_

#include "input.h"
#include "xtl_base.h"

namespace cttl {

template< typename StringT = CTTL_STD_STRING >
class node
{
protected:
    int m_identity;

    input< StringT >& m_input;

public:
    // CONSTRUCTORS, CONVERSIONS, AND ASSIGNMENT OPERATORS OF THE NODE OBJECT //

    typedef StringT string_T;

    typedef typename StringT::value_type char_T;

    typedef typename StringT::value_type value_type;

    node( input< StringT >& inp_, int identity_ )
        :
        m_identity( identity_ ),
        m_input( inp_ )
    {
    }

    node( node< StringT > const& other_, int identity_ )
        :
        m_identity( identity_ ),
        m_input( other_.m_input )
    {
        parent().container().identity_assign( m_identity, other_.m_identity );
    }

    node( node< StringT > const& other_ )
        :
        m_identity( other_.m_identity ),
        m_input( other_.m_input )
    {
    }

    node< StringT >& operator= ( node< StringT > const& other_ )
    {
        if ( this != &other_ )
            m_identity = other_.m_identity;

        return *this;
    }

    node< StringT >& operator= ( size_t offset_ )
    {
        parent().container().identity_go_offset( m_identity, offset_ );
        return *this;
    }

    node< StringT >& operator+= ( StringT const& str_ )
    {
        insert_go( str_ );
        return *this;
    }

    node< StringT >& operator-= ( StringT const& str_ )
    {
        insert_stay( str_ );
        return *this;
    }

    // PROPERTIES OF THE NODE OBJECT //

    input< StringT >& parent()
    {
        return m_input;
    }

    input< StringT > const& parent() const
    {
        return m_input;
    }

public:
    int identity() const
    {
        return m_identity;
    }

    int identity( int identity_ )
    {
        m_identity = identity_;
        return m_identity;
    }

    template< typename PredicateT >
    bool find_class( PredicateT ( *iswhat_ )( PredicateT ) )
    {
        StringT const& str = parent().container().text();
        if ( iswhat_( str[ offset() ] ) ) {
            // successful match found for the specified character class,
            // find ending position
            typename StringT::const_iterator it = str.begin() + offset();
            it = std::find_if( it, str.end(), std::not1( std::ptr_fun( iswhat_ ) ) );
            if ( it != str.end() )
                offset( std::distance( str.begin(), it ) ); // set ending position
            else
                offset( str.length() ); // set ending position

            return true;
        }
        return false;
    }

    template< typename PredicateT >
    bool rfind_class( PredicateT ( *iswhat_ )( PredicateT ) )
    {
        StringT const& str = parent().container().text();
        if ( offset() && iswhat_( str[ offset() - 1 ] ) ) {
            // successful match found for the specified character class,
            // find beginning position for the character class:
            typename StringT::const_reverse_iterator it( str.begin() + offset() );
            typename StringT::const_reverse_iterator it_end( str.begin() );
            it = std::find_if( it, it_end, std::not1( std::ptr_fun( iswhat_ ) ) );
            offset( std::distance( it, it_end ) );  // set beginning position

            return true;
        }
        return false;
    }

    size_t offset() const
    {
        return parent().container().identity_offset( m_identity );
    }
    
    size_t offset( size_t offset_ )
    {
        return parent().container().identity_go_offset( m_identity, offset_ );
    }

    size_t line() const
    {
        return parent().container().identity_get_line( m_identity );
    }
    
    size_t go_line( size_t line_ )
    {
        return parent().container().identity_go_line( m_identity, line_ );
    }

    // VERBS OF THE NODE OBJECT //

    size_t push()
    {
        return parent().container().push_identity( m_identity );
    }

    size_t pop()
    {
        return parent().container().pop_identity( m_identity );
    }

    void pop_discard()
    {
        parent().container().pop_offset();
    }


    size_t go_bof()
    {
        return parent().container().identity_go_bof( m_identity );
    }

    size_t go_eof()
    {
        return parent().container().identity_go_eof( m_identity );
    }
    
    size_t go_line_next()
    {
        return parent().container().identity_go_next_line( m_identity );
    }
    
    size_t go_line_previous()
    {
        size_t current_line = line();
        if ( --current_line )
            return go_line( current_line );
        return offset();
    }

    size_t go_line_home()
    {
        return parent().container().identity_go_line_home( m_identity );
    }

    size_t go_line_home( size_t line_ )
    {
        go_line( line_ );
        return parent().container().identity_go_line_home( m_identity );
    }

    size_t go_line_end()
    {
        return parent().container().identity_go_line_end( m_identity );
    }

    size_t go_line_end( size_t line_ )
    {
        go_line( line_ );
        return parent().container().identity_go_line_end( m_identity );
    }

    size_t insert_go( StringT const& str_ )
    {
        text_insert_go( str_ );
        return offset();
    }

    void insert_stay( StringT const& str_ )
    {
        text_insert_stay( str_ );
    }

    char_T const& operator[] ( int subscript_ ) const
    {
        return parent().container().text()[ offset() + subscript_ ];
    }
    
    char_T& operator[] ( int subscript_ )
    {
        return parent().container().text()[ offset() + subscript_ ];
    }
    
    // compile-time functions

    template< typename ExprT >
    xtl_wrap<
        xtl_node<
            node< StringT >,
            xtl_wrap< ExprT >
        >
    >
    operator() ( xtl_wrap< ExprT > const& expr_ )
    {
        // function-call operator must be a nonstatic member function
        typedef
            xtl_node<
                node< StringT >,
                xtl_wrap< ExprT >
            > xtl_node_T;

        return xtl_wrap< xtl_node_T >( xtl_node_T( *this, expr_ ) );
    }

private:
    void text_insert_go( StringT const& str_ )
    {
        size_t str_length = str_.length();

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

        size_t insertion_offset = offset();

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

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

        for ( idx = 0; idx < parent().container().offset_stack().size(); ++idx )
            insert_go.adjust( parent().container().offset_stack()[ idx ] );
    }
    
    void text_insert_go(
        StringT const& str_,
        size_t source_from_offset_, // a substring of the source string
        size_t source_to_offset_
        )
    {
        size_t str_length = source_to_offset_ - source_from_offset_;

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

        size_t insertion_offset = offset();

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

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

        for ( idx = 0; idx < parent().container().offset_stack().size(); ++idx )
            insert_go.adjust( parent().container().offset_stack()[ idx ] );
    }
    
    void text_insert_stay( StringT const& str_ )
    {
        size_t str_length = str_.length();

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

        size_t insertion_offset = offset();

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

        xtl_identity_insert_stay< StringT > insert_stay(
            insertion_offset,
            str_length
            );

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

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

    void text_insert_stay(
        StringT const& str_,
        size_t source_from_offset_, // a substring of the source string
        size_t source_to_offset_
        )
    {
        size_t str_length = source_to_offset_ - source_from_offset_;

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

        size_t insertion_offset = offset();

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

        xtl_identity_insert_stay< StringT > insert_stay(
            insertion_offset,
            str_length
            );

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

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

};  // class node


template< typename StringT >
inline node< StringT >
new_node( input< StringT >& inp_, size_t offset_ )
{
    return node< StringT >( inp_, inp_.container().identity_vector_push_back( offset_ ) );
}

template< typename StringT >
inline node< StringT >
new_node( input< StringT >& inp_ )
{
    return new_node< StringT >( inp_, inp_.length() );
}

template< typename StringT >
inline node< StringT >
new_node( node< StringT >& other_ )
{
    return node< StringT >(
        other_.parent(),
        other_.parent().container().identity_vector_push_back( other_.offset() )
        );
}

// Overloaded operators to compare nodes

template< typename StringT >
bool operator== ( node< StringT > const& one_, node< StringT > const& another_ )
{
    return one_.offset() == another_.offset();
}

template< typename StringT >
bool operator!= ( node< StringT > const& one_, node< StringT > const& another_ )
{
    return one_.offset() != another_.offset();
}

template< typename StringT >
bool operator> ( node< StringT > const& one_, node< StringT > const& another_ )
{
    return one_.offset() > another_.offset();
}

template< typename StringT >
bool operator< ( node< StringT > const& one_, node< StringT > const& another_ )
{
    return one_.offset() < another_.offset();
}

template< typename StringT >
bool operator>= ( node< StringT > const& one_, node< StringT > const& another_ )
{
    return one_.offset() >= another_.offset();
}

template< typename StringT >
bool operator<= ( node< StringT > const& one_, node< StringT > const& another_ )
{
    return one_.offset() <= another_.offset();
}
    
template< typename StringT >
node< StringT >& operator++ ( node< StringT >& node_ )
{
    node_.offset( node_.offset() + 1 );
    return node_;
}

template< typename StringT >
node< StringT >& operator-- ( node< StringT >& node_ )
{
    node_.offset( node_.offset() - 1 );
    return node_;
}

}   // namespace cttl

#endif // _CTTL_NODE_H_INCLUDED_

---