token_iterator.hpp

CGAL is a collaborative effort of several sites in Europe and Israel. The goal is to make the most i

//  (C) Copyright Gennadiy Rozental 2004.
//  Distributed under the Boost Software License, Version 1.0.
//  (See accompanying file LICENSE_1_0.txt or copy at 
//  http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/test for the library home page.
//
//  File        : $RCSfile: token_iterator.hpp,v $
//
//  Version     : $Revision: 1.1.1.1 $
//
//  Description : token iterator for string and range tokenization
// ***************************************************************************

#ifndef BOOST_TOKEN_ITERATOR_HPP_071894GER
#define BOOST_TOKEN_ITERATOR_HPP_071894GER

// Boost
#include <boost/iterator/iterator_categories.hpp>
#include <boost/iterator/iterator_traits.hpp>

#include <boost/test/detail/iterator/input_iterator_facade.hpp>
#include <boost/test/detail/basic_cstring/basic_cstring.hpp>

// STL
#include <iosfwd>
#include <cctype>

#ifdef BOOST_NO_STDC_NAMESPACE
namespace std{ using ::ispunct; using ::isspace; }
#endif

namespace boost {

namespace unit_test {

// ************************************************************************** //
// **************               ti_delimeter_type              ************** //
// ************************************************************************** //

enum ti_delimeter_type { use_delim, use_ispunct, use_isspace };

namespace ut_detail {

// ************************************************************************** //
// **************                 delim_policy                 ************** //
// ************************************************************************** //

template<typename CharT,typename CharCompare>
class delim_policy {
    typedef basic_cstring<CharT const> cstring;
public:
    // Constructor
    explicit    delim_policy( ti_delimeter_type t = use_delim ) : m_type( t ) {}
    explicit    delim_policy( cstring d, ti_delimeter_type t )
    {
        use_delimeters( d, t );
    }

    void        use_delimeters( cstring d, ti_delimeter_type t )
    {
        m_delimeters = d;
        m_type       = d.is_empty() ? t : use_delim;
    }

    bool        operator()( CharT c )
    {
        switch( m_type ) {
        case use_delim: {
            typename cstring::iterator it = m_delimeters.begin();
            for( ; it != m_delimeters.end(); ++it )
                if( CharCompare()( *it, c ) )
                    break;
            return it != m_delimeters.end();
        }
        case use_ispunct:   return (std::ispunct)( c ) != 0;
        case use_isspace:   return (std::isspace)( c ) != 0;
        }

        return false;
    }

    // Data members
    cstring             m_delimeters;
    ti_delimeter_type   m_type;
};

// ************************************************************************** //
// **************                 token_assigner               ************** //
// ************************************************************************** //

template<typename TraversalTag>
struct token_assigner {
#if BOOST_WORKAROUND( BOOST_DINKUMWARE_STDLIB, < 306 )
    template<typename Iterator, typename C, typename T>
    static void assign( Iterator b, Iterator e, std::basic_string<C,T>& t )
    { for( ; b != e; ++b ) t += *b; }
    
    template<typename Iterator, typename C>
    static void assign( Iterator b, Iterator e, basic_cstring<C>& t )  { t.assign( b, e ); }
#else
    template<typename Iterator, typename Token>
    static void assign( Iterator b, Iterator e, Token& t )  { t.assign( b, e ); }
#endif
    template<typename Iterator, typename Token>
    static void append_move( Iterator& b, Token& )          { ++b; }

    template<typename Token>
    static void clear( Token& )                             {}
};

template<>
struct token_assigner<single_pass_traversal_tag> {
    template<typename Iterator, typename Token>
    static void assign( Iterator b, Iterator e, Token& t )  {}

    template<typename Iterator, typename Token>
    static void append_move( Iterator& b, Token& t )        { t += *b; ++b; }

#if BOOST_WORKAROUND( BOOST_DINKUMWARE_STDLIB, < 306 ) \
    || BOOST_WORKAROUND( __GNUC__, < 3 ) && !defined(__SGI_STL_PORT) \
        && !defined(_STLPORT_VERSION)
    template<typename Token>
    static void clear( Token& t )                           { t.erase(); }
#else
    template<typename Token>
    static void clear( Token& t )                           { t.clear(); }
#endif
};

// ************************************************************************** //
// **************             default_char_compare             ************** //
// ************************************************************************** //

template<typename CharT>
class default_char_compare {
public:
    bool operator()( CharT c1, CharT c2 )
    {
#ifdef BOOST_CLASSIC_IOSTREAMS
        return std::string_char_traits<CharT>::eq( c1, c2 );
#else
        return std::char_traits<CharT>::eq( c1, c2 );
#endif
    }
};

// ************************************************************************** //
// **************             dropped_delimeters_m             ************** //
// ************************************************************************** //

template<typename CharT>
struct dropped_delimeters_m
{
    explicit dropped_delimeters_m( basic_cstring<CharT const> delims )
    : m_delims( delims ) {}

    template<typename CharCompare>
    void apply( delim_policy<CharT,CharCompare>& is_drop, delim_policy<CharT,CharCompare>&, bool ) const
    {
        is_drop.use_delimeters( m_delims, use_isspace );
    }

    basic_cstring<CharT const> m_delims;
};

//____________________________________________________________________________//

template<>
struct dropped_delimeters_m<ti_delimeter_type>
{
    explicit dropped_delimeters_m( ti_delimeter_type type )
    : m_type( type ) {}

    template<typename CharT, typename CharCompare>
    void apply( delim_policy<CharT,CharCompare>& is_drop, delim_policy<CharT,CharCompare>&, bool ) const
    {
        is_drop.use_delimeters( "", m_type );
    }

    ti_delimeter_type m_type;
};

//____________________________________________________________________________//

// ************************************************************************** //
// **************               kept_delimeters_m              ************** //
// ************************************************************************** //

template<typename CharT>
struct kept_delimeters_m
{
    explicit kept_delimeters_m( basic_cstring<CharT const> delims, ti_delimeter_type type = use_ispunct )
    : m_delims( delims ), m_type( type ) {}

    template<typename CharCompare>
    void apply( delim_policy<CharT,CharCompare>&, delim_policy<CharT,CharCompare>& is_kept, bool ) const
    {
        is_kept.use_delimeters( m_delims, m_type );
    }

    basic_cstring<CharT const>  m_delims;
    ti_delimeter_type           m_type;
};

//____________________________________________________________________________//

template<>
struct kept_delimeters_m<ti_delimeter_type>
{
    explicit kept_delimeters_m( ti_delimeter_type type )
    : m_type( type ) {}

    template<typename CharT, typename CharCompare>
    void apply( delim_policy<CharT,CharCompare>&, delim_policy<CharT,CharCompare>& is_kept, bool ) const
    {
        is_kept.use_delimeters( "", m_type );
    }

    ti_delimeter_type m_type;
};

//____________________________________________________________________________//

// ************************************************************************** //
// **************              keep_empty_tokens_m             ************** //
// ************************************************************************** //

struct keep_empty_tokens_m
{
    explicit keep_empty_tokens_m( bool v )
    : m_keep_empty_tokens( v ) {}

    template<typename CharT,typename CharCompare>
    void apply( delim_policy<CharT,CharCompare>&, delim_policy<CharT,CharCompare>&, bool& keep_empty_tokens ) const
    {
        keep_empty_tokens = m_keep_empty_tokens;
    }

    bool m_keep_empty_tokens;
};

} // namespace ut_detail

// ************************************************************************** //
// **************              modifiers generators            ************** //
// ************************************************************************** //

static struct dropped_delimeters_generator {
    template<typename CharT>
    ut_detail::dropped_delimeters_m<CharT>
    operator=( basic_cstring<CharT const> d ) { return ut_detail::dropped_delimeters_m<CharT>( d ); }
    template<typename CharT>
    ut_detail::dropped_delimeters_m<CharT>
    operator=( CharT const* d ) { return ut_detail::dropped_delimeters_m<CharT>( basic_cstring<CharT const>( d ) ); }

    ut_detail::dropped_delimeters_m<ti_delimeter_type>
    operator=( ti_delimeter_type t ) { return ut_detail::dropped_delimeters_m<ti_delimeter_type>( t ); }
} dropped_delimeters;

//____________________________________________________________________________//

static struct kept_delimeters_generator {
    template<typename CharT>
    ut_detail::kept_delimeters_m<CharT>
    operator=( basic_cstring<CharT const> d ) { return ut_detail::kept_delimeters_m<CharT>( d ); }
    template<typename CharT>
    ut_detail::kept_delimeters_m<CharT>
    operator=( CharT const* d ) { return ut_detail::kept_delimeters_m<CharT>( basic_cstring<CharT const>( d ) ); }

    ut_detail::kept_delimeters_m<ti_delimeter_type>
    operator=( ti_delimeter_type t ) { return ut_detail::kept_delimeters_m<ti_delimeter_type>( t ); }
} kept_delimeters;

//____________________________________________________________________________//

static struct keep_empty_tokens_generator : ut_detail::keep_empty_tokens_m {
    keep_empty_tokens_generator() : ut_detail::keep_empty_tokens_m( true ) {}

    ut_detail::keep_empty_tokens_m
    operator=( bool v ) { return ut_detail::keep_empty_tokens_m( v ); }
} keep_empty_tokens;

//____________________________________________________________________________//

// ************************************************************************** //
// **************             token_iterator_base              ************** //
// ************************************************************************** //

template<typename Derived,
         typename CharT,
         typename CharCompare   = ut_detail::default_char_compare<CharT>,
         typename ValueType     = basic_cstring<CharT const>,
         typename Reference     = basic_cstring<CharT const>,
         typename Traversal     = forward_traversal_tag>
class token_iterator_base
: public input_iterator_facade<Derived,ValueType,Reference,Traversal> {
    typedef basic_cstring<CharT const>                                      cstring;
    typedef ut_detail::delim_policy<CharT,CharCompare>                      delim_policy;
    typedef input_iterator_facade<Derived,ValueType,Reference,Traversal>    base;