/Users/paul/Documents/phlogo/core/Operator.cpp

/*
 *  Operator.cpp
 *
 *  Author: Paul Hamilton
 *      Date: 14 Aug 2011
 *
 */
#include "Operator.h"
        
#include "World.h"
#include "Interpreter.h"
#include "TokenStream.h"
#include "Thing.h"
#include "Exceptions.h"

#include <boost/lexical_cast.hpp>
#include <math.h>

using namespace std;
using namespace boost;

namespace phlogo {

void Operator::doOp(Interpreter *itp, World *world, TokenStream *ts, long n1) {
    
    pThing thing;
    itp->getNextThing(world, ts, &thing);
    if (thing->isWord()) {
        try {
            op(n1, lexical_cast<long>(thing->getWord()));
        }
        catch (bad_cast &x) {
            try {
                op(n1, lexical_cast<double>(thing->getWord()));
            }
            catch (bad_cast &x) {
                BOOST_THROW_EXCEPTION( no_word_in_thing_exception() );
            }
        }
    }
    else if (thing->isLong()) {
        op(n1, thing->getLong());
    }
    else if (thing->isDouble()) {
        op(n1, thing->getDouble());
    }
    else
        BOOST_THROW_EXCEPTION( no_word_in_thing_exception() );
}

void Operator::doOp(Interpreter *itp, World *world, TokenStream *ts, double n1) {
    
    pThing thing;
    itp->getNextThing(world, ts, &thing);
    if (thing->isWord()) {
        try {
            op(n1, lexical_cast<long>(thing->getWord()));
        }
        catch (bad_cast &x) {
            try {
                op(n1, lexical_cast<double>(thing->getWord()));
            }
            catch (bad_cast &x) {
                BOOST_THROW_EXCEPTION( no_word_in_thing_exception() );
            }
        }
    }
    else if (thing->isLong()) {
        op(n1, thing->getLong());
    }
    else if (thing->isDouble()) {
        op(n1, thing->getDouble());
    }
    else
        BOOST_THROW_EXCEPTION( no_word_in_thing_exception() );
}

void Operator::doOp(Interpreter *itp, World *world, TokenStream *ts) {
    
    pThing thing;
    itp->getNextThing(world, ts, &thing);
    if (thing->isWord()) {
        try {
            doOp(itp, world, ts, lexical_cast<long>(thing->getWord()));
        }
        catch (bad_cast &x) {
            try {
                doOp(itp, world, ts, lexical_cast<double>(thing->getWord()));
            }
            catch (bad_cast &x) {
                BOOST_THROW_EXCEPTION( no_word_in_thing_exception() );
            }
        }
    }
    else if (thing->isLong()) {
        doOp(itp, world, ts, thing->getLong());
    }
    else if (thing->isDouble()) {
        doOp(itp, world, ts, thing->getDouble());
    }
    else
        BOOST_THROW_EXCEPTION( no_word_in_thing_exception() );
}

void Mul::op(long n1, long n2) {
    _world->allocResult()->set((long)(n1 * n2));
}
void Mul::op(double n1, long n2) {
    _world->allocResult()->set((double)(n1 * n2));
}
void Mul::op(long n1, double n2) {
    _world->allocResult()->set((double)(n1 * n2));
}
void Mul::op(double n1, double n2) {
    _world->allocResult()->set((double)(n1 * n2));
}

void Div::op(long n1, long n2) {
    _world->allocResult()->set((double)n1 / (double)n2);
}
void Div::op(double n1, long n2) {
    _world->allocResult()->set(n1 / (double)n2);
}
void Div::op(long n1, double n2) {
    _world->allocResult()->set((double)n1 / n2);
}
void Div::op(double n1, double n2) {
    _world->allocResult()->set(n1 / n2);
}

void Add::op(long n1, long n2) {
    _world->allocResult()->set(n1 + n2);
}
void Add::op(double n1, long n2) {
    _world->allocResult()->set(n1 + n2);
}
void Add::op(long n1, double n2) {
    _world->allocResult()->set(n1 + n2);
}
void Add::op(double n1, double n2) {
    _world->allocResult()->set(n1 + n2);
}

void Sub::op(long n1, long n2) {
    _world->allocResult()->set(n1 - n2);
}
void Sub::op(double n1, long n2) {
    _world->allocResult()->set(n1 - n2);
}
void Sub::op(long n1, double n2) {
    _world->allocResult()->set(n1 - n2);
}
void Sub::op(double n1, double n2) {
    _world->allocResult()->set(n1 - n2);
}
    
}