//-----------------------------------------------------------------------------

 // boost-libs variant/test/test3.cpp source file

 // See http://www.boost.org for updates, documentation, and revision history.

 //-----------------------------------------------------------------------------

 //

 // Copyright (c) 2003

 // Eric Friedman, Itay Maman

 //

 // 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)

 /*

  * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

 */

 #include "boost/test/minimal.hpp"

 #include "boost/variant.hpp"

 #include <iostream>

 #include <sstream>

 #include <string>

 #ifdef __SYMBIAN32__

 #include "std_log_result.h"

 #define LOG_FILENAME_LINE __FILE__, __LINE__

 #endif

 /////////////////////////////////////////////////////////////////////

 using boost::variant;

 using boost::recursive_wrapper;

 #ifndef __SYMBIAN32__

 using std::cout;

 #endif

 using std::endl;

 /////////////////////////////////////////////////////////////////////

 /////////////////////////////////////////////////////////////////////

 struct Add;

 struct Sub;

 typedef variant<int, recursive_wrapper<Add>, recursive_wrapper<Sub> > Expr;

 struct Sub

 {

    Sub();

    Sub(const Expr& l, const Expr& r);

    Sub(const Sub& other);

    Expr lhs_;

    Expr rhs_;

 };

 struct Add

 {

    Add() { }

    Add(const Expr& l, const Expr& r) : lhs_(l), rhs_(r) { }

    Add(const Add& other) : lhs_(other.lhs_), rhs_(other.rhs_) { }

    Expr lhs_;

    Expr rhs_;

 };

 Sub::Sub() { }

 Sub::Sub(const Expr& l, const Expr& r) : lhs_(l), rhs_(r) { }

 Sub::Sub(const Sub& other) : lhs_(other.lhs_), rhs_(other.rhs_) { }

 //

 // insert-to operators

 //

 std::ostream& operator<<(std::ostream& out, const Sub& a);

 std::ostream& operator<<(std::ostream& out, const Add& a)

 {

    out << '(' << a.lhs_ << '+' << a.rhs_ << ')';

    return out;

 }

 std::ostream& operator<<(std::ostream& out, const Sub& a)

 {

    out << '(' << a.lhs_ << '-' << a.rhs_ << ')';

    return out;

 }

 //

 // Expression evaluation visitor

 //

 struct Calculator : boost::static_visitor<int>

 {

    Calculator()  { }

    int operator()(Add& x) const

    {

       Calculator calc;

       int n1 = boost::apply_visitor(calc, x.lhs_);

       int n2 = boost::apply_visitor(calc, x.rhs_);

       return n1 + n2;

    }

    int operator()(Sub& x) const

    {

       return boost::apply_visitor(Calculator(), x.lhs_) 

          - boost::apply_visitor(Calculator(), x.rhs_);

    }

    int operator()(Expr& x) const

    {

       Calculator calc;

       return boost::apply_visitor(calc, x);

    }

    int operator()(int x) const

    {

       return x;

    }

 }; // Calculator

 /////////////////////////////////////////////////////////////////////

 int test_main(int, char* [])

 {

 std_log(LOG_FILENAME_LINE,"[Test Case for test3]");

    int n = 13;

    Expr e1( Add(n, Sub(Add(40,2),Add(10,4))) ); //n + (40+2)-(10+14) = n+28

    std::ostringstream e1_str;

    e1_str << e1;

    BOOST_CHECK(e1.type() == typeid(Add));

    BOOST_CHECK(e1_str.str() == "(13+((40+2)-(10+4)))");

    //Evaluate expression

    int res = boost::apply_visitor(Calculator(), e1);

    BOOST_CHECK(res == n + 28);

 #ifdef __SYMBIAN32__

    	testResultXml("test3");

 	close_log_file();

 #endif

    return 0;

 }