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

#ifndef _CTTL_XTL_CONTAINER_H_INCLUDED_
#define _CTTL_XTL_CONTAINER_H_INCLUDED_

#include "xtl_container_impl.h"
#include "xtl_identity_functors.h"

namespace cttl_impl {

const int xtl_flag_default = 0;

const int xtl_flag_runtime_find = 1;

const int xtl_flag_runtime_bang_find = 2;

template< typename StringT = CTTL_STD_STRING >
class xtl_text_container : public xtl_text_container_impl< StringT >
{
public:

    typedef typename xtl_text_container_impl< StringT >::string_T string_T;

    typedef typename xtl_text_container_impl< StringT >::char_T char_T;

    xtl_bitflags m_flags;


    // Constructors                                                                 //

public:
    xtl_text_container(
        xtl_bitflags::value_type flags_ = xtl_flag_default,
        size_t vector_size_ = xtl_identity_vector_default_size )
        :
        xtl_text_container_impl< StringT >( vector_size_ ),
        m_flags( flags_ )
    {
    }

    template< typename CharT >
    xtl_text_container(
        CharT const* pchar_,
        xtl_bitflags::value_type flags_ = xtl_flag_default,
        size_t vector_size_ = xtl_identity_vector_default_size
        )
        :
        xtl_text_container_impl< std::basic_string< CharT > >( pchar_, vector_size_ ),
        m_flags( flags_ )
    {
    }

    xtl_text_container(
        StringT const& str_,
        xtl_bitflags::value_type flags_ = xtl_flag_default,
        size_t vector_size_ = xtl_identity_vector_default_size
        )
        :
        xtl_text_container_impl< StringT >( str_, vector_size_ ),
        m_flags( flags_ )
    {
    }

private:
    /*Copy constructor is disabled due to complexity of @c xtl_text_container object.*/
    explicit xtl_text_container( xtl_text_container< StringT > const& )
        :
        xtl_text_container_impl< StringT >( xtl_identity_vector_default_size )
    {
    }

    /*Direct assignment is disabled due to complexity of @c xtl_text_container object.*/
    xtl_text_container const& operator=( xtl_text_container< StringT > const& )
    {
        return *this;
    }

public:
    std::vector< size_t >& identity_vector()
    {
        return this->m_identity_vector;
    }

    std::vector< size_t >& offset_stack()
    {
        return this->m_offset_stack;
    }

    size_t identity_vector_size() const
    {
        return this->m_identity_vector.size();
    }
    
    size_t identity_vector_size( size_t new_size_ )
    {
        if ( new_size_ ) {
            this->m_identity_vector.resize( new_size_ );
            return this->m_identity_vector.size();
        }

        this->m_identity_vector.clear();
        return 0;
    }

    size_t identity_vector_push_back( size_t offset_ )
    {
        this->m_identity_vector.push_back( offset_ );
        return this->m_identity_vector.size() - 1;
    }

// Functions to store, access, and maintain encapsulated text
public:
    void text( char_T const* pchar_ )
    {
        if ( pchar_ )
            this->m_client_str = pchar_;
        else
            this->m_client_str.clear();
        
        this->identity_zero_all();
    }
    
    void text( StringT const& str_ )
    {
        this->m_client_str = str_;
        this->identity_zero_all();
    }


    StringT const&  text() const
    {
        return this->m_client_str;
    }

    StringT& text()
    {
        return this->m_client_str;
    }

    // Functions to manipulate substrings
public:
    void text_tolower( int from_id_, int to_id_ )
    {
        typename StringT::iterator first = this->m_client_str.begin() + identity_offset( from_id_ );
        typename StringT::iterator last = this->m_client_str.begin() + identity_offset( to_id_ );
        
        std::transform(
            first,
            last,
            first,
            tolower
            );
    }
    
    void text_toupper( int from_id_, int to_id_ )
    {
        typename StringT::iterator first = this->m_client_str.begin() + identity_offset( from_id_ );
        typename StringT::iterator last = this->m_client_str.begin() + identity_offset( to_id_ );
        
        std::transform(
            first,
            last,
            first,
            toupper
            );
    }
    

    StringT text_substring( int from_id_, int to_id_ ) const
    {
        assert( this->m_identity_vector[ from_id_ ] + this->m_identity_vector[ to_id_ ] - this->m_identity_vector[ from_id_ ] <= this->m_client_str.length() );

        if ( this->m_identity_vector[ from_id_ ] == this->m_identity_vector[ to_id_ ] )
            return StringT();

        return this->m_client_str.substr(
            this->m_identity_vector[ from_id_ ],
            this->m_identity_vector[ to_id_ ] - this->m_identity_vector[ from_id_ ]
            );
    }

    StringT text_absolute_substring( size_t from_offset_, size_t to_offset_ ) const
    {
        assert( from_offset_ + to_offset_ - from_offset_ <= this->m_client_str.length() );

        if ( from_offset_ == to_offset_ )
            return StringT();

        return this->m_client_str.substr(
            from_offset_,
            to_offset_ - from_offset_
            );
    }

    // Functions to manipulate identities

    size_t identity_go_bof( int id_ )
    {
        return this->m_identity_vector[ id_ ] = 0;
    }

    size_t identity_go_eof( int id_ )
    {
        return this->m_identity_vector[ id_ ] = this->m_client_str.length();
    }

    size_t identity_offset( int id_ ) const
    {
        return this->m_identity_vector[ id_ ];
    }

    size_t identity_go_offset( int id_, size_t offset_ )
    {
        /* returns old offset_ */
        size_t old_offset = this->m_identity_vector[ id_ ];
        this->m_identity_vector[ id_ ] = offset_;
        return old_offset;
    }

    size_t identity_add_offset( int id_, size_t offset_ )
    {
        return this->m_identity_vector[ id_ ] += offset_;
    }

    void push_offset( size_t x_ )
    {
        this->m_offset_stack.push_back( x_ );
    }

    size_t pop_offset()
    {
        size_t temp = this->m_offset_stack.back();
        this->m_offset_stack.pop_back();
        return temp;
    }

    size_t push_identity( int id_ )
    {
        this->m_offset_stack.push_back( this->m_identity_vector[ id_ ] );
        return this->m_offset_stack.size() - 1;
    }

    void pop_identity()
    {
        this->m_offset_stack.pop_back();
    }

    size_t pop_identity( int id_ )
    {
        this->m_identity_vector[ id_ ] = this->m_offset_stack.back();
        this->m_offset_stack.pop_back();
        return this->m_identity_vector[ id_ ];
    }

    size_t stack_size() const
    {
        return this->m_offset_stack.size();
    }

    size_t stack_offset( int sp_ ) const
    {
        return this->m_offset_stack[ sp_ ];
    }

    void stack_offset( int sp_, size_t offset_ )
    {
        this->m_offset_stack[ sp_ ] = offset_;
    }

    void identity_assign( int target_i_, int source_i_ )
    {
        this->m_identity_vector[ target_i_ ] = this->m_identity_vector[ source_i_ ];
    }

    size_t identity_get_line( int id_ ) const
    {
        return offset_2_line( identity_offset( id_ ) );
    }

    size_t identity_go_line( int id_, int line_ )
    {
        return this->m_identity_vector[ id_ ] = this->line_2_offset( line_ );
    }

    size_t identity_go_next_line( int id_ )
    {
        return this->m_identity_vector[ id_ ] = offset_2_next_line_offset( identity_offset( id_ ) );
    }

    size_t identity_go_line_home( int id_ )
    {
        return this->m_identity_vector[ id_ ] = offset_2_line_home_offset( identity_offset( id_ ) );
    }

    size_t identity_go_line_end( int id_ )
    {
        return this->m_identity_vector[ id_ ] = offset_2_line_end_offset( identity_offset( id_ ) );
    }

};  // class xtl_text_container

}   // namespace cttl_impl

#endif // _CTTL_XTL_CONTAINER_H_INCLUDED_

---