FieldExpression.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

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

#include <cmw-log/Logger.h>

#include <iostream>

namespace
{
CMW::Log::Logger& logger = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core.Sorting.FieldExpression");
}

namespace fesa
{

bool FieldExpression::match(SortingContext sc)
{
    std::string fieldExprCandidate = sc.formula_;
    enum automaton
    {
        initState,
        parenthesisStartState,
        fieldNameState,
        equalityState,
        fieldValueState,
        endState
    };
    automaton state = initState;
    automaton newState = initState;
    std::string::size_type pos;
    while (state != endState)
    {
        switch (state)
        {
            case initState:
                if (fieldExprCandidate.size() == 0)
                    newState = endState;
                else
                    newState = parenthesisStartState;
                break;
            case parenthesisStartState:
                if (fieldExprCandidate[0] != '(')
                    return false;
                fieldExprCandidate.erase(0, 1);
                newState = fieldNameState;
                break;
            case fieldNameState:
                pos = fieldExprCandidate.find("==");
                if ((pos == std::string::npos))
                    return false;
                this->fieldNameStr_ = fieldExprCandidate.substr(0, pos);
                fieldExprCandidate.erase(0, pos + 2);
                newState = equalityState;
                break;
            case equalityState:
                // already confident there was "=="
                newState = fieldValueState;
                break;
            case fieldValueState:
                pos = fieldExprCandidate.rfind(")");
                if ((pos == std::string::npos))
                {
                    return false;
                }
                fieldExprCandidate.erase(pos, 1);
                pos = fieldExprCandidate.find("[");
                if (pos != 0)
                    return false;
                fieldExprCandidate.erase(pos, 1);
                pos = fieldExprCandidate.find("]");
                if (pos != (fieldExprCandidate.length() - 1))
                    return false;
                fieldExprCandidate.erase(pos, 1);
                fieldValueStr_ = fieldExprCandidate; // make it a NULL-terminated string!
                if(logger.isLoggable(CMW::Log::Level::LL_TRACE))
                {
                    std::ostringstream msg;
                    msg << "candidate field value is " << fieldValueStr_;
                    LOG_TRACE_IF(logger, msg.str());
                }
                // the comparison shall be performed
                // with the stringified value of the
                // field (there should be a getStringified)
                // method on the Field class, useful
                // for debug as well as for the sorting
                // criterion matching to be performed below.
                newState = endState;
                break;
            case endState:
                // Check that there are no extra-characters left in the candidate string
                break;
        }
        state = newState;
    }
    // Now update the devColCol attribute
    if (fieldValueStr_ == "?")
    {
        // Implicit device-recruitment => need several sets
        std::map<std::string, HomogeneousDevCol *> m;
        for (uint32_t i = 0; i < pDevCol_->size(); i++)
        {
            AbstractDevice * pDev = (*pDevCol_)[i];
            AbstractField * pField = pDev->getField(fieldNameStr_);
            if (!pField) // the field doesn't exist: the expression is not valid
                return false;
            std::string fieldValue = pField->getAsString();
            // Removing the prefix className if any; That way no additional layers are created due to the prefix
            const std::string classNamePrefix = sc.className_ + "::";
            if (fieldValue.compare(0, classNamePrefix.size(), classNamePrefix) == 0)
            {
                fieldValue = fieldValue.substr(classNamePrefix.size(), fieldValue.size() - classNamePrefix.size());
            }
            std::map<std::string, HomogeneousDevCol*>::iterator p;
            p = m.find(fieldValue);
            if (p != m.end())
            {
                p->second->getDevCol()->insert(pDev);
            }
            else
            {
                // there's no homogeneous device collection sorted for
                // this field.
                HomogeneousDevCol * pHomogeneousDevCol = new HomogeneousDevCol();
                m[fieldValue] = pHomogeneousDevCol;
                pHomogeneousDevCol->getDevCol()->insert(pDev);
                std::string criterion = std::string("(") + fieldNameStr_ + std::string("==") + fieldValue
                    + std::string(")");
                pHomogeneousDevCol->setSharedCriteria(criterion);
            }
        }
        std::map<std::string, HomogeneousDevCol *>::iterator it;
        for (it = m.begin(); it != m.end(); it++)
        {
            if (it->second->getSize() > 0)
            {
                devColCol_.insert(it->second);
            } // otherwise there is no point of adding an empty device-set...
        }
    }
    else
    {
        // Explicit device-recruitment => need only one set
        HomogeneousDevCol* pHomogeneousDevCol = new HomogeneousDevCol();
        if (fieldValueStr_ == "")
        {
            pHomogeneousDevCol->setSharedCriteria("");
            for (uint32_t i = 0; i < pDevCol_->size(); i++)
                pHomogeneousDevCol->getDevCol()->insert((*pDevCol_)[i]);
        }
        else
        {
            std::string criterion = std::string("(") + fieldNameStr_ + std::string("==") + fieldValueStr_
                + std::string(")");
            pHomogeneousDevCol->setSharedCriteria(criterion);
            for (uint32_t i = 0; i < pDevCol_->size(); i++)
            {
                AbstractDevice * pDev = (*pDevCol_)[i];
                AbstractField *pField = pDev->getField(fieldNameStr_);
                if (!pField) // the field doesn't exist: the expression is not valid
                    return false;
                std::string fieldValue = pField->getAsString();

                if (fieldValue == fieldValueStr_)
                {
                    pHomogeneousDevCol->getDevCol()->insert(pDev);
                }
            }
        }
        if (pHomogeneousDevCol->getSize() > 0)
        {
            devColCol_.insert(pHomogeneousDevCol); // only one.
        } // otherwise there is no point in adding an empty set of devices ...
    }
    if (logger.isLoggable(CMW::Log::Level::LL_TRACE))
    {
        std::ostringstream msg;
        msg << "   FieldExpression has been decoded : '" << fieldNameStr_ << "' == '" << fieldValueStr_ << "'";
        LOG_TRACE_IF(logger, msg.str());
    }
    return true;
}

std::set<HomogeneousDevCol *> FieldExpression::evaluate()
{
    return devColCol_;
}

} // fesa