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

// const_edge.h

#ifndef _CTTL_CONST_EDGE_H_INCLUDED_
#define _CTTL_CONST_EDGE_H_INCLUDED_

#include "node.h"
#include "xtl_edge_trait.h"

namespace cttl {

struct policy_default
{
    typedef policy_default strict_policy_T;

    template< typename UniverseT >
    static inline size_t match( UniverseT& universe_ )
    {
        return universe_.first.offset();
    }

    template< typename UniverseT >
    static inline bool lower_bound( size_t, UniverseT& )
    {
        return false;
    }

    static inline size_t lower_bound( size_t offset_, size_t )
    {
        return offset_;
    }

    static inline void region_adjust( size_t, int )
    {
    }

    static inline void region_insert( size_t, size_t )
    {
    }

    static inline void region_erase( size_t, size_t )
    {
    }

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

};  // struct policy_default


template< typename PolicyT = policy_default, typename StringT = CTTL_STD_STRING >
class const_edge
{
public:
    typedef xtl_const_offset_manager offset_manager_T;

    typedef StringT string_T;

    typedef typename StringT::value_type char_T;

    typedef StringT value_type;

    typedef PolicyT policy_T;

    typedef typename PolicyT::strict_policy_T strict_policy_T;

    typedef const_edge< strict_policy_T, StringT > strict_edge_T;

    typedef node< StringT > node_T;


    node< StringT > first;

    node< StringT > second;

protected:
    PolicyT& m_space_policy;

    static inline PolicyT& default_policy()
    {
        // Because m_space_policy is initialized with default_policy(),
        // the static policy has to be mutable:
        static PolicyT policy;
        return policy;
    }

public:

    PolicyT& space_policy()
    {
        return m_space_policy;
    }

    PolicyT const& space_policy() const
    {
        return m_space_policy;
    }

    // CONSTRUCTORS, CONVERSIONS, AND ASSIGNMENT OPERATORS OF THE EDGE OBJECT //

    const_edge( input< StringT >& inp_, int start_, int finish_ )
        :
        first( inp_, start_ ),
        second( inp_, finish_ ),
        m_space_policy( default_policy() )
    {
    }

    const_edge( node< StringT >& node_first_, node< StringT >& node_second_ )
        :
        first( node_first_ ),
        second( node_second_ ),
        m_space_policy( default_policy() )
    {
        assert( &node_first_.parent().container() == &node_second_.parent().container() );
    }

    template< typename Other_policyT >
    const_edge( const_edge< Other_policyT, StringT > const& other_ )
        :
        first( other_.first ),
        second( other_.second ),
        m_space_policy( default_policy() )
    {
    }

    const_edge( const_edge< PolicyT, StringT > const& other_ )
        :
        first( other_.first ),
        second( other_.second ),
        m_space_policy( other_.m_space_policy )
    {
    }

    template< typename Other_policyT >
        const_edge( const_edge< Other_policyT, StringT > const& other_, PolicyT& policy_ )
        :
        first( other_.first ),
        second( other_.second ),
        m_space_policy( policy_ )
    {
    }

    const_edge< PolicyT, StringT >& operator= ( const_edge< PolicyT, StringT > const& other_ )
    {
        if ( this != &other_ ) {
            first = other_.first;
            second = other_.second;
        }
        return *this;
    }


    operator StringT() const
    {
        return text();
    }

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

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

public:
    StringT text() const
    {
        return parent().container().text_substring( first.identity(), second.identity() );
    }

    int length() const
    {
        return int( parent().container().identity_offset( second.identity() ) - parent().container().identity_offset( first.identity() ) );
    }

    void push()
    {
        first.push();
        second.push();
    }

    void pop()
    {
        second.pop();
        first.pop();
    }

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

    void region_insert()
    {
        space_policy().region_insert(
            first.offset(),
            second.offset()
            );
    }

    void region_erase()
    {
        space_policy().region_erase(
            first.offset(),
            second.offset()
            );
    }

    StringT region_difference()
    {
        return space_policy().region_difference(
            parent().container().text(),
            first.offset(),
            second.offset()
            );
    }

    void text_tolower()
    {
        parent().container().text_tolower( first.identity(), second.identity() );
    }

    void text_toupper()
    {
        parent().container().text_toupper( first.identity(), second.identity() );
    }

    template< typename ExprT >
    xtl_wrap<
        xtl_edge<
            const_edge< PolicyT, StringT >,
            xtl_wrap< ExprT >
            >
        >
    operator() ( xtl_wrap< ExprT > const& expr_ )
    {
        typedef
            xtl_edge<
                const_edge< PolicyT, StringT >,
                xtl_wrap< ExprT >
            > xtl_edge_T;

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

};  // class const_edge

template< typename StringT > 
inline const_edge< policy_default, StringT >
operator- ( node< StringT >& one_, node< StringT >& another_ )
{
    return const_edge< policy_default, StringT >( another_, one_ );
}

template< typename StringT >
inline const_edge< policy_default, StringT >
operator+ ( node< StringT >& one_, node< StringT >& another_ )
{
    return const_edge< policy_default, StringT >( one_, another_ );
}

template< typename PolicyT, typename StringT >
inline const_edge< PolicyT, StringT >
new_edge( const_edge< PolicyT, StringT >& other_ )
{
    size_t start = other_.parent().container().identity_vector_push_back( other_.first.offset() );
    size_t finish = other_.parent().container().identity_vector_push_back( other_.second.offset() );
    return const_edge< PolicyT, StringT >( other_.parent(), start, finish );
}

template< typename StringT >
inline const_edge< policy_default, StringT >
new_edge( input< StringT >& inp_ )
{
    int start = inp_.container().identity_vector_push_back( 0 );
    int finish = inp_.container().identity_vector_push_back( inp_.length() );
    return const_edge< policy_default, StringT >( inp_, start, finish );
}

template< typename StringT >
inline const_edge< policy_default, StringT >
new_edge( input< StringT >& inp_, size_t lhs_offset_, size_t rhs_offset_ )
{
    int start = inp_.container().identity_vector_push_back( lhs_offset_ );
    int finish = inp_.container().identity_vector_push_back( rhs_offset_ );
    return const_edge< policy_default, StringT >( inp_, start, finish );
}

// Overloaded comparison operators for edges


template< typename PolicyT, typename StringT >
bool operator< ( const_edge< PolicyT, StringT > const& one_, const_edge< PolicyT, StringT > const& another_ )
{
    return one_.text() < another_.text();
}

template< typename PolicyT, typename StringT >
bool operator> ( const_edge< PolicyT, StringT > const& one_, const_edge< PolicyT, StringT > const& another_ )
{
    return one_.text() > another_.text();
}

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

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

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

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

}   // namespace cttl

#endif // _CTTL_CONST_EDGE_H_INCLUDED_

---