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

cttl::node, cttl::edge access

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

alias lambda access to cttl::node, cttl::edge

 
#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 ) );

    // node::push, pop
    // push returns stack identity. pop restores and returns original offset
    lambda< node<> >::scalar_reference universe_second( &universe.top().second );
    (   alias::node::push( &universe_second ),
        alias::node::pop( &universe_second )
        ).evaluate();

    // identity
    lambda< node<> >::scalar_reference universe_first( &universe.top().first );
    ( alias::identity( &universe_first, universe.top().first.identity() )
        ).evaluate();

    // line
    ( CTTL_LAMBDA_ASSERT(
        alias::line( universe_first ) == scalar( size_t( 1 ) ) )
        ).evaluate();
    
    // node::push, pop_discard
    // push returns stack identity. pop restores and returns original offset
    (   alias::node::push( &universe_second ),
        alias::pop_discard( &universe_second )
        ).evaluate();

    // node::insert_go, insert_stay
    (   alias::insert_go( &universe_second, std::string( "one" ) ),
        alias::insert_stay( &universe_second, std::string( "two" ) )
        ).evaluate();

    ( CTTL_LAMBDA_ASSERT(
        alias::text( universe ) == scalar( std::string( "hello!one" ) ) )
        ).evaluate();

    // edge::length
    ( CTTL_LAMBDA_ASSERT(
        int( std::string( "hello!one" ).length() ) == alias::edge::length( universe ) )
        ).evaluate();

    // edge::push, pop, pop_discard
    // push returns stack identity. pop restores and returns original offset
    (   alias::edge::push( &universe ),
        alias::pop( &universe ),
        alias::edge::push( &universe ),
        alias::pop_discard( &universe )
        ).evaluate();

    // text_toupper
    ( alias::text_toupper( &universe )
        ).evaluate();

    ( CTTL_LAMBDA_ASSERT(
        alias::text( universe ) == scalar( std::string( "HELLO!ONE" ) ) )
        ).evaluate();

    // text_swap
    node<> node_tail = new_node( universe.top().parent() );
    edge<> edge_tail( universe.top().second, node_tail );
    edge_tail = new_edge( edge_tail );
    ( alias::text_swap( &universe, &edge_tail )
        ).evaluate();

    ( CTTL_LAMBDA_ASSERT(
        scalar( std::string( "HELLO!ONE" ) ) == alias::text( scalar( &edge_tail ) ) )
        ).evaluate();


    return 0;
}

edge translator

 
#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( "123" );
    const_edge< policy_space<> > universe = new_edge( inp );
    const_edge<> data( new_edge( inp ) );
    std::vector< int > vect( 1 );
    lambda< std::vector< int > >::scalar_reference scalar_v( &vect );
    lambda< std::vector< int >::iterator >::scalar it;
    size_t result = (
        data( entity( isdigit ) )
        +
        *(
            *alias::begin( &scalar_v ) = 4,
            it = alias::begin( &scalar_v ),
            *it = ++( scalar( 0 )^atoi^data ) // edge translator
        )
    ).match( universe );

    assert( result != std::string::npos );
    assert( vect[ 0 ] == 123 );

    (
        *it = *alias::begin( &scalar_v ),  // ok
        //*it = *alias::begin( scalar_v ), // will not compile
        *alias::begin( &scalar_v ) = 4
    ).evaluate();
    assert( vect[ 0 ] == 4 );
    return 0;
}

node insertions

 
#define CTTL_TRACE_EVERYTHING

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

using namespace cttl;

int main(int argc, char* argv[])
{
    input<> inp;
    lambda< std::string >::scalar_reference sinp( &inp.text() );
    lambda< node<> >::scalar snode( new_node( inp ) );
    lambda< node<> >::scalar snode2( new_node( inp ) );
    
    (
        CTTL_LAMBDA_ASSERT( size_t( 0 ) == alias::offset( snode ) ),

        snode -= scalar( std::string( "1" ) ),
        // positions of nodes at insertion point remain unchanged:
        CTTL_LAMBDA_ASSERT( sinp == scalar( std::string( "1" ) ) ),
        CTTL_LAMBDA_ASSERT( size_t( 0 ) == alias::offset( snode ) ),
        CTTL_LAMBDA_ASSERT( size_t( 0 ) == alias::offset( snode2 ) ),

        snode += scalar( std::string( "2" ) ),
        // positions of all nodes adjusted:
        CTTL_LAMBDA_ASSERT( sinp == scalar( std::string( "21" ) ) ),
        CTTL_LAMBDA_ASSERT( size_t( 1 ) == alias::offset( snode ) ),
        CTTL_LAMBDA_ASSERT( size_t( 1 ) == alias::offset( snode2 ) ),

        snode -= scalar( std::string( "3" ) ),
        CTTL_LAMBDA_ASSERT( sinp == scalar( std::string( "231" ) ) ),
        CTTL_LAMBDA_ASSERT( size_t( 1 ) == alias::offset( snode ) ),
        CTTL_LAMBDA_ASSERT( size_t( 1 ) == alias::offset( snode2 ) ),

        snode += scalar( std::string( "4" ) ),
        CTTL_LAMBDA_ASSERT( sinp == scalar( std::string( "2431" ) ) ),
        CTTL_LAMBDA_ASSERT( size_t( 2 ) == alias::offset( snode ) ),
        CTTL_LAMBDA_ASSERT( size_t( 2 ) == alias::offset( snode2 ) ),

        (sinp^itos) = alias::offset( snode2 ),   // translate node offset
        CTTL_LAMBDA_ASSERT( sinp == scalar( std::string( "2" ) ) ),

        snode = size_t( 0 ),                    // set node offset
        snode2 = size_t( 1 ),
        CTTL_LAMBDA_ASSERT( snode <= snode2 ),  // comapare node offsets

        // edge may be used anywhere in place of std::string:
        snode += scalar( const_edge<>( snode.top(), snode2.top() ) ),
        CTTL_LAMBDA_ASSERT( sinp == scalar( std::string( "22" ) ) )
    ).evaluate();

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

    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:54 2006 for CTTL Lambda Expression by  doxygen 1.3.9.1