Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

text transformation samples

SourceForge.net Logo     CTTL on    
    SourceForge     		    Download    
    Latest     		    Documentation    
    Index     		    Library    
    News     		    CVS    
    Repository     		   Other    
   Links    

See also:
overloaded subscript operator

text transformation

cttl::edge class, overloaded assignment operator for strings 
size_t match_and_replace( edge<>& universe_ )
{
    return
        (
            *(
                symbol( "target" )
                &
                *(
                    scalar( &universe_ ) = scalar( std::string( "source" ) )
                )
            )
        ).match( universe_ );
}

Alternatively, explicit call to cttl::edge::text() can be used in place of assignment 
size_t match_and_replace( edge<>& universe_ )
{
    lambda< edge<> >::scalar_reference scalar_universe( &universe );
    return
        (
            *(
                symbol( "target" )
                &
                *(
                    alias::text( &scalar_universe, std::string( "source" ) )
                )
            )
        ).match( universe_ );
}

conversion to uppercase

closure (delayed function call) 
void f()
{
    input<> inp( "abc" );
    const_edge<> universe( new_edge( inp ) );
    lambda< char >::scalar ch; // temp character value
    lambda< node<> >::scalar character( new_node( inp ) );

    size_t result = (
        *(  // for each character,
            character.top()( first( isalpha ) ) // match single character
            +
            *(
                ch = character[ 0 ],            // get character value
                character[ 0 ] = *scalar(
                    CTTL_STATIC_ACTION(         // convert to UPPERCASE
                        std::ptr_fun( &toupper ),
                        ch.top()
                    )
                )
            )
        )
    ).match( universe );

    assert( result != std::string::npos );
    assert( inp.text() == "ABC" );
}

alias::text, string manipulation

 
#define CTTL_TRACE_RULES // automatically turns lambda tracing on

#include "cttl/cttl.h"
#include "lambda/lambda.h"

using namespace cttl;

int main(int argc, char* argv[])
{
    input<> inp( "hello" );
    lambda< edge<> >::scalar universe( new_edge( inp ) );
    lambda< CTTL_STD_STRING >::scalar str;

    // text, write
    ( alias::text( &universe, std::string( "bye" ) )
        ).evaluate();

    // text, read
    ( str = alias::text( universe )
        ).evaluate();

    ( CTTL_LAMBDA_ASSERT( str == scalar( std::string( "bye" ) ) )
        ).evaluate();

    assert( inp.text() == "bye" );

    // basic_string push_back
    ( alias::basic_string::push_back( &str, 'X' )
        ).evaluate();

    ( CTTL_LAMBDA_ASSERT( str == scalar( std::string( "byeX" ) ) )
        ).evaluate();

    // append
    ( alias::append( &str, std::string( "YZ" ) )
        ).evaluate();

    ( CTTL_LAMBDA_ASSERT( str == scalar( std::string( "byeXYZ" ) ) )
        ).evaluate();

    // assign
    ( alias::assign( &str, std::string( "hi" ) )
        ).evaluate();

    ( CTTL_LAMBDA_ASSERT( str == scalar( std::string( "hi" ) ) )
        ).evaluate();

    // compare
    ( CTTL_LAMBDA_ASSERT( !alias::compare( str, std::string( "hi" ) ) )
        ).evaluate();

    // length
    ( CTTL_LAMBDA_ASSERT( std::string( "hi" ).length() == alias::length( str ) )
        ).evaluate();
        
    return 0;
}

substring assignment using alias call

 
#include "cttl/cttl.h"
#include "lambda/lambda.h"

using namespace cttl;

int main(int argc, char* argv[])
{
    input<> inp( "XYZABC" );
    lambda< const_edge<> >::scalar source( new_edge( inp, 3, inp.length() ) );
    lambda< edge<> >::scalar target( new_edge( inp, 0, 3 ) );
    (
        CTTL_LAMBDA_ASSERT(
            alias::text( target ) == scalar( std::string( "XYZ" ) )
            ),
        alias::text(
            &target,
            alias::text( source ).top()
            ),
        CTTL_LAMBDA_ASSERT(
            alias::text( target ) == scalar( std::string( "ABC" ) )
            )
    ).evaluate();

    assert( inp.text() == "ABCABC" );
    return 0;
}

substring assignment using edge assignment operator

 
#include "cttl/cttl.h"
#include "lambda/lambda.h"

using namespace cttl;

int main(int argc, char* argv[])
{
    input<> inp( "XYZABC" );
    lambda< const_edge<> >::scalar source( new_edge( inp, 3, inp.length() ) );
    lambda< edge<> >::scalar target( new_edge( inp, 0, 3 ) );
    (
        CTTL_LAMBDA_ASSERT(
            alias::text( target ) == scalar( std::string( "XYZ" ) )
            ),
        target = alias::text( source ),
        CTTL_LAMBDA_ASSERT(
            alias::text( target ) == scalar( std::string( "ABC" ) )
            )
    ).evaluate();

    assert( inp.text() == "ABCABC" );
    return 0;
}


Copyright © 1997-2006 Igor Kholodov mailto:cttl@users.sourceforge.net.

Permission to copy, use, modify, sell and distribute this document is granted provided this copyright notice appears in all copies. This document is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose.

Generated on Thu Nov 2 17:48:53 2006 for CTTL Lambda Expression by  doxygen 1.3.9.1