inode_reader.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_reader.h

#ifndef _CTTL_INODE_READER_H_INCLUDED_
#define _CTTL_INODE_READER_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_reader : public stlport::bidirectional_iterator< inode_reader< PreviousLinkT, NextLinkT, ContainerT > > 
#else
struct inode_reader
#endif
{
    static const int previous_link_field = PreviousLinkT;

    static const int next_link_field = NextLinkT;

    typedef ContainerT container_T;

    typedef typename ContainerT::reference container_reference_T;

    typedef typename ContainerT::const_reference container_const_reference_T;

    typedef inode_reader< PreviousLinkT, NextLinkT, ContainerT >       iterator;

    typedef inode_reader< PreviousLinkT, NextLinkT, ContainerT >       const_iterator;

    typedef inode_reader< PreviousLinkT, NextLinkT, ContainerT >        value_type;

    typedef inode_reader< PreviousLinkT, NextLinkT, ContainerT >*       pointer;

    typedef inode_reader< PreviousLinkT, NextLinkT, ContainerT >        reference;

    typedef inode_reader< PreviousLinkT, NextLinkT, ContainerT >        const_reference;

    typedef typename ContainerT::size_type size_type;

    typedef ptrdiff_t    difference_type;

    typedef std::bidirectional_iterator_tag iterator_category;

    // constructors

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

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

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

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

    inode_reader< PreviousLinkT, NextLinkT, ContainerT >& operator=( inode_reader< 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 *this;
    }

    reference operator*()
    {
        return *this;
    }

    value_type const* operator->() const
    {
        return this;
    }

    value_type* operator->()
    {
        return this;
    }

    inode_reader< PreviousLinkT, NextLinkT, ContainerT >& operator++()
    {
        offset( value( NextLinkT ) );
        return *this;
    }

    inode_reader< PreviousLinkT, NextLinkT, ContainerT > operator++( int )
    {
        inode_reader< PreviousLinkT, NextLinkT, ContainerT > sibling( *this );
        offset( value( NextLinkT ) );
        return sibling;
    }

    inode_reader< PreviousLinkT, NextLinkT, ContainerT >& operator--()
    {
        offset( value( PreviousLinkT ) );
        return *this;
    }

    inode_reader< PreviousLinkT, NextLinkT, ContainerT > operator--( int )
    {
        inode_reader< PreviousLinkT, NextLinkT, ContainerT > sibling( *this );
        offset( value( PreviousLinkT ) );
        return sibling;
    }

    bool operator== ( inode_reader< PreviousLinkT, NextLinkT, ContainerT > const& other_ ) const
    {
        return ( offset() == other_.offset() );
    }

    bool operator!= ( inode_reader< PreviousLinkT, NextLinkT, ContainerT > const& other_ ) const
    {
        return ( offset() != other_.offset() );
    }

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

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

    inode_reader< PreviousLinkT, NextLinkT, ContainerT > end() const
    {
        return begin();
    }

    // Position and data access functions

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

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

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

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

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

    size_type offset() const
    {
        return m_offset;
    }

    // Tree linkage helper functions

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

    int next_link() const
    {
        return NextLinkT;
    }

    int previous_link() const
    {
        return PreviousLinkT;
    }

protected:
    // inode_reader state variables

    size_type m_offset;

    ContainerT* m_ptr_container;

}; // inode_reader


}   // namespace cttl

#endif // _CTTL_INODE_READER_H_INCLUDED_

---