xtl_edge_trait.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_edge_trait.h

#ifndef _CTTL_XTL_EDGE_TRAIT_H_INCLUDED_
#define _CTTL_XTL_EDGE_TRAIT_H_INCLUDED_

#include "xtl_container_impl.h"

namespace cttl_impl {

class xtl_const_offset_manager
{
    size_t m_offset;
public:
    template< typename StringT >
    xtl_const_offset_manager( xtl_text_container< StringT >&, size_t offset_ )
        :
        m_offset( offset_ )
    {
    }

    xtl_const_offset_manager& operator=( size_t offset_ )
    {
        m_offset = offset_;
        return *this;
    }

    operator size_t() const
    {
        return m_offset;
    }
};

template< typename StringT >
class xtl_mutable_offset_manager
{
    xtl_text_container< StringT >& m_container;

    size_t m_stack_identity;

public:

    xtl_mutable_offset_manager( xtl_text_container< StringT >& container_, size_t offset_ )
        :
        m_container( container_ )
    {
        m_stack_identity = m_container.stack_size();
        m_container.push_offset( offset_ );
    }

    ~xtl_mutable_offset_manager()
    {
        m_container.pop_offset();
    }

    xtl_mutable_offset_manager< StringT >& operator=( size_t offset_ )
    {
        m_container.stack_offset( m_stack_identity, offset_ );
        return *this;
    }

    xtl_mutable_offset_manager< StringT >& operator=( xtl_mutable_offset_manager< StringT > const& other_ )
    {
        m_container.stack_offset( m_stack_identity, size_t( other_ ) );
        return *this;
    }

    operator size_t() const
    {
        return m_container.stack_offset( m_stack_identity );
    }

    size_t stack_identity() const
    {
        return m_stack_identity;
    }
};


template< typename EdgeT >
struct xtl_edge_offset_manager
{
    typename EdgeT::offset_manager_T first;

    typename EdgeT::offset_manager_T second;

    xtl_edge_offset_manager( EdgeT& edge_ )
        :
        first( edge_.parent().container(), edge_.first.offset() ),
        second( edge_.parent().container(), edge_.second.offset() )
    {
    }

    void save( EdgeT& edge_ )
    {
        first = edge_.first.offset();
        second = edge_.second.offset();
    }

    void swap( EdgeT& edge_ )
    {
        size_t temp = first;
        first = edge_.first.offset();
        edge_.first.offset( temp );

        temp = second;
        second = edge_.second.offset();
        edge_.second.offset( temp );
    }

    void restore( EdgeT& edge_ )
    {
        edge_.first.offset( first );
        edge_.second.offset( second );
    }
};  // struct xtl_edge_offset_manager

}   // namespace cttl_impl

#endif // _CTTL_XTL_EDGE_TRAIT_H_INCLUDED_

---