xtl_sym.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_sym.h

#ifndef _CTTL_XTL_SYM_H_INCLUDED_
#define _CTTL_XTL_SYM_H_INCLUDED_

namespace cttl {

using namespace cttl_impl;

template< typename Static_predicateT >
inline xtl_wrap< xtl_predicate< Static_predicateT > >
rule( const Static_predicateT pred_ )
{
    return xtl_wrap< xtl_predicate< Static_predicateT > >( pred_ );
}


template< typename ObjectT, typename PredicateT >
inline xtl_wrap< xtl_member_predicate< ObjectT, PredicateT > >
rule( ObjectT& object_ref_, PredicateT pred_ )
{
    return xtl_wrap< xtl_member_predicate< ObjectT, PredicateT > >( xtl_member_predicate< ObjectT, PredicateT >( object_ref_, pred_ ) );
}

inline xtl_wrap< xtl_char_symbol >
symbol()
{
    return xtl_wrap< xtl_char_symbol >();
}

inline xtl_wrap< xtl_position_bof >
begin()
{
    return xtl_wrap< xtl_position_bof >();
}

inline xtl_wrap< xtl_bool< false > >
symbol( bool bool_ )
{
    // fails on empty universe
    return xtl_wrap< xtl_bool< false > >( bool_ );
}

inline xtl_wrap< xtl_bool< true > >
begin( bool bool_ )
{
    // succeeds on empty universe
    return xtl_wrap< xtl_bool< true > >( bool_ );
}

inline xtl_wrap< xtl_char< CTTL_STD_CHAR > >
symbol( CTTL_STD_CHAR char_ )
{
    return xtl_wrap< xtl_char< CTTL_STD_CHAR > >( char_ );
}

inline xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
symbol( CTTL_STD_WCHAR char_ )
{
    return xtl_wrap< xtl_char< CTTL_STD_WCHAR > >( char_ );
}

inline xtl_wrap< xtl_char< CTTL_STD_CHAR > >
symbol( int char_ )
{
    // allows symbol( 0x0a ) notation for individual characters
    return xtl_wrap< xtl_char< CTTL_STD_CHAR > >( CTTL_STD_CHAR( char_ ) );
}

inline xtl_wrap< xtl_char_begin< CTTL_STD_CHAR > >
begin( CTTL_STD_CHAR char_ )
{
    return xtl_wrap< xtl_char_begin< CTTL_STD_CHAR > >( char_ );
}

inline xtl_wrap< xtl_char_begin< CTTL_STD_WCHAR > >
begin( CTTL_STD_WCHAR char_ )
{
    return xtl_wrap< xtl_char_begin< CTTL_STD_WCHAR > >( char_ );
}

inline xtl_wrap< xtl_char_begin< CTTL_STD_CHAR > >
begin( int char_ )
{
    // allows begin( 0x0a ) notation for individual characters
    return xtl_wrap< xtl_char_begin< CTTL_STD_CHAR > >( CTTL_STD_CHAR( char_ ) );
}

inline xtl_wrap< xtl_char_end< CTTL_STD_CHAR > >
end( CTTL_STD_CHAR char_ )
{
    return xtl_wrap< xtl_char_end< CTTL_STD_CHAR > >( char_ );
}

inline xtl_wrap< xtl_char_end< CTTL_STD_WCHAR > >
end( CTTL_STD_WCHAR char_ )
{
    return xtl_wrap< xtl_char_end< CTTL_STD_WCHAR > >( char_ );
}

inline xtl_wrap< xtl_char_end< CTTL_STD_CHAR > >
end( int char_ )
{
    // allows end( 0x0a ) notation for individual characters
    return xtl_wrap< xtl_char_end< CTTL_STD_CHAR > >( CTTL_STD_CHAR( char_ ) );
}

inline xtl_wrap< xtl_keyword< CTTL_STD_STRING > >
begin( std::set< CTTL_STD_STRING > const& keywords_ )
{
    return xtl_wrap< xtl_keyword< CTTL_STD_STRING > >( keywords_ );
}

inline xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >
begin( std::set< CTTL_STD_WSTRING > const& keywords_ )
{
    return xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >( keywords_ );
}


inline xtl_wrap< xtl_iswhat_begin >
begin( iswhat_T iswhat_ )
{
    return xtl_wrap< xtl_iswhat_begin >( iswhat_ );
}


inline xtl_wrap< xtl_iswhat_end >
end( iswhat_T iswhat_ )
{
    return xtl_wrap< xtl_iswhat_end >( iswhat_ );
}


inline xtl_wrap< xtl_iswhat_first >
first( iswhat_T iswhat_ )
{
    return xtl_wrap< xtl_iswhat_first >( iswhat_ );
}


inline xtl_wrap< xtl_iswhat_entity >
entity( iswhat_T iswhat_ )
{
    return xtl_wrap< xtl_iswhat_entity >( iswhat_ );
}



inline xtl_wrap< xtl_iswwhat_begin >
begin( iswwhat_T iswwhat_ )
{
    return xtl_wrap< xtl_iswwhat_begin >( iswwhat_ );
}


inline xtl_wrap< xtl_iswwhat_end >
end( iswwhat_T iswwhat_ )
{
    return xtl_wrap< xtl_iswwhat_end >( iswwhat_ );
}


inline xtl_wrap< xtl_iswwhat_first >
first( iswwhat_T iswwhat_ )
{
    return xtl_wrap< xtl_iswwhat_first >( iswwhat_ );
}


inline xtl_wrap< xtl_iswwhat_entity >
entity( iswwhat_T iswwhat_ )
{
    return xtl_wrap< xtl_iswwhat_entity >( iswwhat_ );
}



inline xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >
begin( CTTL_STD_CHAR const* any_text_ )
{
    return xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >
begin( CTTL_STD_WCHAR const* any_text_ )
{
    return xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >
begin( CTTL_STD_STRING const& any_text_ )
{
    return xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >
begin( CTTL_STD_WSTRING const& any_text_ )
{
    return xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_ref_begin< CTTL_STD_STRING > >
begin( CTTL_STD_STRING const* any_text_ )
{
    return xtl_wrap< xtl_text_ref_begin< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_ref_begin< CTTL_STD_WSTRING > >
begin( CTTL_STD_WSTRING const* any_text_ )
{
    return xtl_wrap< xtl_text_ref_begin< CTTL_STD_WSTRING > >( any_text_ );
}



inline xtl_wrap< xtl_text_end< CTTL_STD_STRING > >
end( CTTL_STD_CHAR const* any_text_ )
{
    return xtl_wrap< xtl_text_end< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > >
end( CTTL_STD_WCHAR const* any_text_ )
{
    return xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_end< CTTL_STD_STRING > >
end( CTTL_STD_STRING const& any_text_ )
{
    return xtl_wrap< xtl_text_end< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > >
end( CTTL_STD_WSTRING const& any_text_ )
{
    return xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_ref_end< CTTL_STD_STRING > >
end( CTTL_STD_STRING const* any_text_ )
{
    return xtl_wrap< xtl_text_ref_end< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_ref_end< CTTL_STD_WSTRING > >
end( CTTL_STD_WSTRING const* any_text_ )
{
    return xtl_wrap< xtl_text_ref_end< CTTL_STD_WSTRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_first< CTTL_STD_STRING > >
first( CTTL_STD_CHAR const* any_text_ )
{
    return xtl_wrap< xtl_text_first< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_first< CTTL_STD_WSTRING > >
first( CTTL_STD_WCHAR const* any_text_ )
{
    return xtl_wrap< xtl_text_first< CTTL_STD_WSTRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_first< CTTL_STD_STRING > >
first( CTTL_STD_STRING const& any_text_ )
{
    return xtl_wrap< xtl_text_first< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_first< CTTL_STD_WSTRING > >
first( CTTL_STD_WSTRING const& any_text_ )
{
    return xtl_wrap< xtl_text_first< CTTL_STD_WSTRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_ref_first< CTTL_STD_STRING > >
first( CTTL_STD_STRING const* any_text_ )
{
    return xtl_wrap< xtl_text_ref_first< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_ref_first< CTTL_STD_WSTRING > >
first( CTTL_STD_WSTRING const* any_text_ )
{
    return xtl_wrap< xtl_text_ref_first< CTTL_STD_WSTRING > >( any_text_ );
}



inline xtl_wrap< xtl_char< CTTL_STD_CHAR > >
entity( CTTL_STD_CHAR char_ )
{
    return xtl_wrap< xtl_char< CTTL_STD_CHAR > >( char_ );
}


inline xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
entity( CTTL_STD_WCHAR char_ )
{
    return xtl_wrap< xtl_char< CTTL_STD_WCHAR > >( char_ );
}


inline xtl_wrap< xtl_char< CTTL_STD_CHAR > >
entity( int char_ )
{
    // allows entity( 0x0a ) notation for individual characters
    return xtl_wrap< xtl_char< CTTL_STD_CHAR > >( CTTL_STD_CHAR( char_ ) );
}


inline xtl_wrap< xtl_text_entity< CTTL_STD_STRING > >
entity( CTTL_STD_CHAR const* any_text_ )
{
    return xtl_wrap< xtl_text_entity< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_entity< CTTL_STD_WSTRING > >
entity( CTTL_STD_WCHAR const* any_text_ )
{
    return xtl_wrap< xtl_text_entity< CTTL_STD_WSTRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_entity< CTTL_STD_STRING > >
entity( CTTL_STD_STRING const& any_text_ )
{
    return xtl_wrap< xtl_text_entity< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_entity< CTTL_STD_WSTRING > >
entity( CTTL_STD_WSTRING const& any_text_ )
{
    return xtl_wrap< xtl_text_entity< CTTL_STD_WSTRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_ref_entity< CTTL_STD_STRING > >
entity( CTTL_STD_STRING const* any_text_ )
{
    return xtl_wrap< xtl_text_ref_entity< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_ref_entity< CTTL_STD_WSTRING > >
entity( CTTL_STD_WSTRING const* any_text_ )
{
    return xtl_wrap< xtl_text_ref_entity< CTTL_STD_WSTRING > >( any_text_ );
}



inline xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
symbol( CTTL_STD_CHAR const* any_text_ )
{
    return xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
symbol( CTTL_STD_WCHAR const* any_text_ )
{
    return xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >( any_text_ );
}

inline xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
symbol( CTTL_STD_STRING const& any_text_ )
{
    return xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
symbol( CTTL_STD_WSTRING const& any_text_ )
{
    return xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >
symbol( CTTL_STD_STRING const* any_text_ )
{
    return xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >( any_text_ );
}


inline xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >
symbol( CTTL_STD_WSTRING const* any_text_ )
{
    return xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >( any_text_ );
}




inline xtl_wrap< xtl_position_eof >
end()
{
    return xtl_wrap< xtl_position_eof >();
}

}   // namespace cttl

#endif // _CTTL_XTL_SYM_H_INCLUDED_

---