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

// inode_writer.h

#ifndef _CTTL_INODE_WRITER_H_INCLUDED_
#define _CTTL_INODE_WRITER_H_INCLUDED_

#include <cassert>
#include <vector>
#include <iterator>
#include <functional>

namespace cttl {

template< int PreviousLinkT = 1, int NextLinkT = 0, typename ContainerT = std::vector< int > >
#ifdef __SGI_STL_PORT
struct inode_writer : public stlport::bidirectional_iterator< inode_writer< PreviousLinkT, NextLinkT, ContainerT > > 
#else
struct inode_writer
#endif
{
    static const int previous_link_field = PreviousLinkT;

    static const int next_link_field = NextLinkT;

    typedef ContainerT container_T;

    typedef typename ContainerT::value_type        value_type;

    typedef inode_writer< PreviousLinkT, NextLinkT, ContainerT >       inode_T;

    typedef inode_writer< PreviousLinkT, NextLinkT, ContainerT >       iterator;

    typedef inode_writer< PreviousLinkT, NextLinkT, ContainerT >       const_iterator;

    typedef typename ContainerT::pointer       pointer;

    typedef typename ContainerT::reference        reference;

    typedef typename ContainerT::const_reference        const_reference;

    typedef typename ContainerT::size_type       size_type;

    typedef typename ContainerT::difference_type    difference_type;

    typedef std::bidirectional_iterator_tag iterator_category;

    // constructors

    inode_writer()
        :
        m_offset( 0 ),
        m_ptr_container( NULL )
    {
    }

    inode_writer( inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& other_ )
        :
        m_offset( other_.m_offset ),
        m_ptr_container( other_.m_ptr_container )
    {
    }

    inode_writer( ContainerT& container_ )
        :
        m_offset( container_.size() ),
        m_ptr_container( &container_ )
    {
    }

    inode_writer( ContainerT& container_, size_type offset_ )
        :
        m_offset( offset_ ),
        m_ptr_container( &container_ )
    {
    }

    inode_writer< PreviousLinkT, NextLinkT, ContainerT >& operator=( inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& other_ )
    {
        if ( this != &other_ ) {
            m_offset = other_.m_offset;
            m_ptr_container = other_.m_ptr_container;
        }

        return *this;
    }

    const_reference operator*() const
    {
        return value( 0 );
    }

    reference operator*()
    {
        return value( 0 );
    }

    value_type const* operator->() const
    {
        return &value( 0 );
    }

    value_type* operator->()
    {
        return &value( 0 );
    }

    inode_writer< PreviousLinkT, NextLinkT, ContainerT >& operator++()
    {
        ++m_offset;
        return *this;
    }

    inode_writer< PreviousLinkT, NextLinkT, ContainerT > operator++( int )
    {
        inode_writer< PreviousLinkT, NextLinkT, ContainerT > sibling( *this );
        ++m_offset;
        return sibling;
    }

    inode_writer< PreviousLinkT, NextLinkT, ContainerT >& operator--()
    {
        --m_offset;
        return *this;
    }

    inode_writer< PreviousLinkT, NextLinkT, ContainerT > operator--( int )
    {
        inode_writer< PreviousLinkT, NextLinkT, ContainerT > sibling( *this );
        --m_offset;
        return sibling;
    }

    inode_writer< PreviousLinkT, NextLinkT, ContainerT > begin() const
    {
        return inode_writer< PreviousLinkT, NextLinkT, ContainerT >( *m_ptr_container, 0 );
    }

    inode_writer< PreviousLinkT, NextLinkT, ContainerT > begin( int offset_ ) const
    {
        return inode_writer< PreviousLinkT, NextLinkT, ContainerT >( *m_ptr_container, offset_ );
    }

    inode_writer< PreviousLinkT, NextLinkT, ContainerT > end() const
    {
        return begin( m_ptr_container->size() );
    }

    // Position and data access functions

    inode_writer< PreviousLinkT, NextLinkT, ContainerT >& operator=( size_type size_ )
    {
        m_offset = size_;
        return *this;
    }
    inode_writer< PreviousLinkT, NextLinkT, ContainerT >& operator+=( size_type size_ )
    {
        m_offset += size_;
        return *this;
    }
    inode_writer< PreviousLinkT, NextLinkT, ContainerT >& operator-=( size_type size_ )
    {
        m_offset -= size_;
        return *this;
    }

    reference value( int field_ )
    {
        return (*m_ptr_container)[ m_offset + field_ ];
    }

    const_reference value( int field_ ) const
    {
        return (*m_ptr_container)[ m_offset + field_ ];
    }

    reference operator[] ( int field_ )
    {
        return value( field_ );
    }

    const_reference operator[] ( int field_ ) const
    {
        return value( field_ );
    }

    void offset( size_type offset_ )
    {
        m_offset = offset_;
    }

    size_type offset() const
    {
        return m_offset;
    }

    size_type& offset()
    {
        return m_offset;
    }

    // Link helper functions

    inode_writer< PreviousLinkT, NextLinkT, ContainerT > operator() ( int field_ ) const
    {
        return inode_writer< PreviousLinkT, NextLinkT, ContainerT >( *m_ptr_container, value( field_ ) );
    }

    int next_link() const
    {
        return NextLinkT;
    }

    int previous_link() const
    {
        return PreviousLinkT;
    }

    // Graph modeling functions

    inode_writer< PreviousLinkT, NextLinkT, ContainerT >& operator<<=( int size_ )
    {
        // 0................m_ptr_container->size()
        // |                |
        // v                v
        // |--------|-fill->|<-resize->|
        //          ^                  ^
        //          |                  |
        //          m_offset...........size_

        assert( size_ ); // node size (number of elements to insert) should not be zero

        if ( m_offset == m_ptr_container->size() ) {
            m_ptr_container->insert(
                m_ptr_container->end(), 
                size_,          // number of elements to insert
                value_type()    // value to insert
                );

        } else {
            // is there an area to fill ?
            if ( m_offset < m_ptr_container->size() ) {
                std::fill(
                    m_ptr_container->begin() + m_offset,
                    m_ptr_container->begin()
                    +
                    std::min(
                        m_offset + size_,
                        m_ptr_container->size()
                    ),
                    value_type()    // value to fill
                    );
            }
            // is there an area to resize ?
            if ( m_ptr_container->size() < m_offset + size_ ) {
                m_ptr_container->resize(
                    m_offset + size_//,
                    //value_type()
                    );
            }
        }

        return *this;
    }

#ifdef _XST_PAIR_H_INCLUDED_    // if lambda.h is included

    template< typename LambdaT >
    inode_writer< PreviousLinkT, NextLinkT, ContainerT >& operator=( xst_lambda_wrap< LambdaT > const& lambda_ )
    {
        typedef typename ContainerT::iterator container_iterator_T;
        container_iterator_T container_iterator( m_ptr_container->begin() + m_offset );
        container_iterator << lambda_;
        return *this;
    }

    template< typename LambdaT >
    inode_writer< PreviousLinkT, NextLinkT, ContainerT >& operator<<=( xst_lambda_wrap< LambdaT > const& lambda_ )
    {
        // is there enough space to accommodate lambda elements ?
        if ( m_ptr_container->size() < m_offset + lambda_.capacity_ ) {
            // yes
            m_ptr_container->resize( m_offset + lambda_.capacity_ );
        }

        return operator=( lambda_ );
    }
#endif // _XST_PAIR_H_INCLUDED_

    template< typename RhsT >
    inode_writer< PreviousLinkT, NextLinkT, ContainerT >& operator+= ( RhsT rhs_ )
    {
        value( NextLinkT ) = rhs_.offset();
        return *this;
    }

    template< typename RhsT >
    inode_writer< PreviousLinkT, NextLinkT, ContainerT >& operator-= ( RhsT rhs_ )
    {
        rhs_.value( rhs_.previous_link() ) = offset();
        return *this;
    }

    template< typename RhsT >
    inode_writer< PreviousLinkT, NextLinkT, ContainerT >& operator^= ( RhsT rhs_ )
    {
        *this += rhs_;
        *this -= rhs_;
        return *this;
    }

    template< typename RhsT >
    inode_writer< PreviousLinkT, NextLinkT, ContainerT >& operator*= ( RhsT child_ )
    {
        *this -= child_;         // negative link with first child
        while ( child_.value( child_.next_link_field )  ) {
            child_.offset( child_.value( child_.next_link_field ) );
            *this -= child_;     // negative link with next child
        }

        return *this;
    }

    ContainerT& container()
    {
        return *m_ptr_container;
    }

    ContainerT const& container() const
    {
        return *m_ptr_container;
    }

protected:
    // inode_writer state variables

    size_type m_offset;

    ContainerT* m_ptr_container;

}; // inode_writer

// Overloaded binary operators

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& operator<<(
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& lhs_,
    int size_
    )
{
    inode_writer< PreviousLinkT, NextLinkT, ContainerT >* plhs_ = const_cast< inode_writer< PreviousLinkT, NextLinkT, ContainerT >* >( &lhs_ );
    plhs_->offset( lhs_.container().size() );
    if ( size_ ) {
        plhs_->container().resize( lhs_.offset() + size_ );
    }

    return lhs_;
}

#ifdef _XST_PAIR_H_INCLUDED_    // if lambda.h is included

template< int PreviousLinkT, int NextLinkT, typename ContainerT, typename LambdaT >
inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& operator<<(
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& lhs_,
    xst_lambda_wrap< LambdaT > const& lambda_
    )
{
    inode_writer< PreviousLinkT, NextLinkT, ContainerT >* plhs_ = const_cast< inode_writer< PreviousLinkT, NextLinkT, ContainerT >* >( &lhs_ );
    plhs_->offset( lhs_.container().size() );
    //container_inserter< ContainerT > inserter( plhs_->container() );
    //lambda_.traverse_top_down( inserter );
    std::back_insert_iterator< ContainerT > inserter( plhs_->container() );
    inserter << lambda_;
    return lhs_;
}
#endif // _XST_PAIR_H_INCLUDED_

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator==(
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& inode_,
    typename ContainerT::size_type offset_
    )
{
    return inode_.offset() == offset_;
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator==(
    typename ContainerT::size_type offset_,
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& inode_
    )
{
    return offset_ == inode_.offset();
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator!=(
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& inode_,
    typename ContainerT::size_type offset_
    )
{
    return inode_.offset() != offset_;
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator!=(
    typename ContainerT::size_type offset_,
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& inode_
    )
{
    return offset_ != inode_.offset();
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator<(
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& inode_,
    typename ContainerT::size_type offset_
    )
{
    return inode_.offset() < offset_;
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator<(
    typename ContainerT::size_type offset_,
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& inode_
    )
{
    return offset_ < inode_.offset();
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator<=(
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& inode_,
    typename ContainerT::size_type offset_
    )
{
    return inode_.offset() <= offset_;
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator<=(
    typename ContainerT::size_type offset_,
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& inode_
    )
{
    return offset_ <= inode_.offset();
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator>(
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& inode_,
    typename ContainerT::size_type offset_
    )
{
    return inode_.offset() > offset_;
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator>(
    typename ContainerT::size_type offset_,
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& inode_
    )
{
    return offset_ > inode_.offset();
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator>=(
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& inode_,
    typename ContainerT::size_type offset_
    )
{
    return inode_.offset() >= offset_;
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator>=(
    typename ContainerT::size_type offset_,
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& inode_
    )
{
    return offset_ >= inode_.offset();
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator== (
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& one_,
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& another_
    )
{
    return ( one_.offset() == another_.offset() );
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator!= (
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& one_,
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& another_
    )
{
    return ( one_.offset() != another_.offset() );
}

template< int PreviousLinkT, int NextLinkT, typename ContainerT >
bool operator! (
    inode_writer< PreviousLinkT, NextLinkT, ContainerT > const& inode_
    )
{
    return !inode_.offset();
}

}   // namespace cttl

#endif // _CTTL_INODE_WRITER_H_INCLUDED_

---