Terminal.h

#ifndef Terminal_h
#define Terminal_h
#include "Primitive.h"
 
namespace Tree {
namespace Primitives {
 
template <class T>
class TerminalT : public Primitive
{
public:
    TerminalT();
    T value_;
    void execute(void* result, Tree& tree);
    void setValue(void* value);
    void getValue(void* value);
    ~TerminalT();
};
// default type is double:
typedef TerminalT<double> Terminal;
 
 
template <class T>
TerminalT<T>::TerminalT()
{
    nArguments_ = 0;
}
 
 
template <class T>
TerminalT<T>::~TerminalT(void)
{   }
 
 
template <class T>
void TerminalT<T>::setValue(void* value)
{
    value_ = *(T*)value;
}
 
 
template <class T>
void TerminalT<T>::getValue(void* value)
{
    *(T*)value = value_;
}
 
 
template <class T>
void TerminalT<T>::execute(void* result, Tree& tree)
{
    T& res = *(T*)result;
    res = value_;
}
 
 
 
template <class T>
class ERC : public Primitive
{
public:
    std::string baseName_;
    T value_;
 
    ERC()
    {
        nArguments_ = 0;
        name_ = "ERC";
        // ime se treba postaviti u Tree::initialize zbog prefiksa po tipu
    }
 
 
    bool initialize(StateP state)
    {
        state_ = state;
        values_ = new std::vector<T>;
 
        name_.erase(name_.end() - 1);
        std::stringstream ss;
        ss << name_;
        ss >> name_;
        char bracket;
        ss >> bracket;
 
        T datum;
        while(ss >> datum) {
            values_->push_back(datum);
        }
 
        return true;
    }
 
 
    void execute(void *result, Tree& tree)
    {
        T& res = *(T*)result;
        res = value_;
    }
 
 
    void setValue(void* value)
    {
        value_ = *(T*)value;
    }
 
 
    void getValue(void* value)
    {
        *(T*)value = value_;
    }
 
 
    PrimitiveP copyWithNode(PrimitiveP primitive)
    {
        return (PrimitiveP) new ERC<T>(*this);
    }
 
    PrimitiveP assignToNode(PrimitiveP primitive)
    {
        // shallow copy - the values_ vector is not copied
        ERC<T> *erc = new ERC<T>(*this);
 
        uint iData = state_->getRandomizer()->getRandomInteger((int)values_->size());
        erc->value_ = values_->at(iData);
        std::ostringstream ss;
        ss << values_->at(iData);
        erc->setName(name_ + ss.str());
        return (PrimitiveP) erc;
    }
 
protected:
    std::vector<T> *values_;
};
 
 
 
class ERCD : public ERC<double>
{
public:
    bool initialize(StateP state)
    {
        useInterval_ = true;
        state_ = state;
        values_ = new std::vector<double>;
 
        if(name_[name_.size() - 1] == '}')
            useInterval_ = false;
        name_.erase(name_.end() - 1);
        std::stringstream ss;
        ss << name_;
        ss >> name_;
        char bracket;
        ss >> bracket;
 
        double datum;
        while(ss >> datum) {
            values_->push_back(datum);
        }
 
        return true;
    }
 
    PrimitiveP assignToNode(PrimitiveP primitive)
    {
        // shallow copy - the values_ are not copied
        ERCD *erc = new ERCD(*this);
 
        // generate a random value in the interval
        if(useInterval_) {
            double r = state_->getRandomizer()->getRandomDouble();
            erc->value_ = (*values_)[0] + r * ((*values_)[1] - (*values_)[0]);
        }
        // or choose a random predefined value
        else {
            uint iData = state_->getRandomizer()->getRandomInteger((int)values_->size());
            erc->value_ = values_->at(iData);
        }
        std::ostringstream ss;
        ss << erc->value_;
        erc->setName(name_ + ss.str());
        return (PrimitiveP) erc;
    }
 
protected:
        bool useInterval_;    
};
 
}
}
 
#endif