UnionExpression.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Sorting/UnionExpression.h>

#include <fesa-core/Sorting/HomogeneousDevCol.h>


namespace fesa
{

bool UnionExpression::match(SortingContext sc)
{
    std::string unionExprCandidate = sc.formula_;

    typedef enum
    {
        initState, parenthesesState, expr1State, unionState, expr2State, endState
    } automaton;

    automaton state = initState, newState = initState;

    std::string::size_type pos;

    while (state != endState)
    {

        switch (state)
        {

            case initState:
                newState = parenthesesState;
                break;

            case parenthesesState:
                pos = unionExprCandidate.find("(");

                if (pos != 0)
                    return false;

                unionExprCandidate.erase(0, 1);

                pos = unionExprCandidate.rfind(")");

                if (pos != (unionExprCandidate.length() - 1))
                    return false;

                unionExprCandidate.erase(pos, 1);

                newState = expr1State;

                break;

            case expr1State:
            {
                pos = unionExprCandidate.find("or(");

                if ((pos == std::string::npos))
                    return false;

                std::string s1 = unionExprCandidate.substr(0, pos);

                SortingContext aSc;
                aSc.formula_ = s1;
                aSc.className_ = sc.className_;

                pExpr1_ = SortingExpression::tryMatch(aSc);

                if (pExpr1_ == 0)
                {
                    return false;
                }

                unionExprCandidate.erase(0, pos + 2);

                newState = unionState;
                break;
            }

            case unionState:
                newState = expr2State;
                break;

            case expr2State:
            {
                std::string s2 = unionExprCandidate;

                SortingContext aSc;
                aSc.formula_ = s2;
                aSc.className_ = sc.className_;

                pExpr2_ = SortingExpression::tryMatch(aSc);

                if (pExpr2_ == 0)
                {
                    return false;
                }

                newState = endState;
                break;

            }

            case endState:
                break;

        }

        state = newState;

    }

    return true;
}

std::set<HomogeneousDevCol*> UnionExpression::evaluate()
{

    std::set<HomogeneousDevCol*> resultDevCol;

    std::set<HomogeneousDevCol*> set1 = pExpr1_->evaluate();
    std::set<HomogeneousDevCol*> set2 = pExpr2_->evaluate();

    std::set<HomogeneousDevCol*>::const_iterator it1, it2;

    for (it1 = set1.begin(); it1 != set1.end(); it1++)
    {
        for (it2 = set2.begin(); it2 != set2.end(); it2++)
        {
            HomogeneousDevCol* pResult = new HomogeneousDevCol();
            HomogeneousDevCol c1 = *(*it1);
            HomogeneousDevCol c2 = *(*it2);
            *pResult = c1 + c2; // union of homogeneous device collections
            resultDevCol.insert(pResult);
        }
    }

    return resultDevCol;

}

UnionExpression::UnionExpression():pExpr1_(0),pExpr2_(0){}

UnionExpression::~UnionExpression()
{
    if (pExpr1_ != NULL)
    {
        delete pExpr1_;
        pExpr1_ = NULL;
    }
    if (pExpr2_ != NULL)
    {
        delete pExpr2_;
        pExpr2_ = NULL;
    }
}

} // fesa