function_operation_node.cpp

Go to the documentation of this file.

#include "utils/random.hpp"

#include "general/geo_object.hpp"

#include "server/parser/color_grammar.hpp"

#include "server/eval/function_operation_node.hpp"
#include "server/eval/eval_helpers.hpp"



namespace eval {

FunctionOperationNode::FunctionOperationNode(const node_ptr& enclosed)
    : operation(op::Nothing)
{
    this->enclosed.push_back(enclosed);
}

FunctionOperationNode::FunctionOperationNode(op::FunctionEnum operation, const std::vector<node_ptr>& enclosed)
    : operation(operation)
    , enclosed(enclosed)
{
    assert(enclosed.size());
}


string FunctionOperationNode::eval(GeoObject* obj) const
{
    string first = enclosed.front()->eval(obj);

    switch(operation)
    {
    case op::Str:
    case op::Nothing:
        return first;

    // Canonical
    case op::Boolean:
        {
            bool b;
            Conv<bool>(first, &b);
            return ToString(b);
        } 
        return first;
    case op::Num:
        {
            float f;
            if(Conv(first, &f))
            {
                return first;
            }
            return "";
        }

    // Mathematics
    case op::Sqrt:
        {
            float f;
            if(Conv(first, &f))
            {
                return ToString(sqrt(f));
            }
            return "";
        }
    case op::Int:
        {
            float f;
            if(Conv(first, &f))
            {
                return ToString((int)floor(f));
            }
            return "";
        }
    case op::Not:
        {
            bool b;
            Conv(first, &b);
            return ToString(!b);
        }
    //case op::Metric:
    //case op::ZMetric:


    case op::Tag:
        {
            MaybeCachedString first_uncached(first);
            auto it = obj->getTags().find(first_uncached, boost::hash<MaybeCachedString>(), CachedComparator());
            if(it != obj->getTags().cend())
            {
                return it->second.str();
            }else{
                return "";
            }
        }
    case op::Cond:
        {
            if(enclosed.size() != 3)
                return "";

            bool condition;
            Conv<bool>(first, &condition);

            if(condition)
            {
                return enclosed[1]->eval(obj);
            }else{
                return enclosed[2]->eval(obj);
            }
        }

    case op::Colgen:
        {
            Color base(0xFFFFFFFF);
            Color top(0xFFFFFFFF);
            if(enclosed.size() > 3)
                return "";

            // 0 = direct set
            // 1 = base multiplication
            // 2 = between set
            int operation = 0;

            if(enclosed.size() >= 2)
            {
                if(Conv(enclosed[1]->eval(obj), &base))
                {
                    ++operation;

                    if(enclosed.size() >= 3)
                    {
                        if(Conv(enclosed[2]->eval(obj), &top))
                            ++operation;
                    }
                }
            }

            Color result;
            Random rand(boost::hash_value(first));

            Color randColor((uint8)rand.rand(255), (uint8)rand.rand(255), (uint8)rand.rand(255), (uint8)rand.rand(255));



            switch (operation)
            {
            case 0:
                result = randColor;
                result.a =  0.3f;
                break;
            case 1:
                result = base * randColor;
                result.a = base.a;
                break;
            case 2:
                result = base + randColor * (top - base).max(Color(uint32(0x00000000)));
                break;
            default:
                return "";
            }

            std::ostringstream os;
            uint32 col = result;
            os << '#' << std::hex << std::setw(6) << std::setfill('0') << (col & 0xFFFFFF);
            os << std::hex << std::setw(2) << std::setfill('0') << (col >> 24);

            return os.str();
        }
    default:
        assert(false);
        break;
    }

    assert(!"Unknown operation executed");
    return "";
}





}