ParserElements.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Utilities/ParserElements.h>
#include <fesa-core/Exception/FesaException.h>
#include <iostream>

namespace fesa
{

RollingMultiplexingElement::RollingMultiplexingElement(int32_t depth, const std::string base) :
    depth_(depth),
    base_(base)
{
}

RollingMultiplexingElement::~RollingMultiplexingElement()
{
}

int32_t RollingMultiplexingElement::getDepth()
{
    return depth_;
}

std::string RollingMultiplexingElement::getBase()
{
    return base_;
}

FieldElement::FieldElement(const std::string fieldName)
{
    fieldName_ = fieldName;
    dimension1_ = 0;
    dimension2_ = 0;
}

FieldElement::~FieldElement()
{

}

uint32_t FieldElement::getExtraConditionDepth()
{

    return static_cast<uint32_t>(fieldExtraValuesCol_.size());
}

uint32_t FieldElement::getMultiplexingDepth()
{
    return static_cast<int32_t>(fieldValuesCol_.size());
}

std::string FieldElement::getCycleName(int32_t cycleId)
{
    std::map<int32_t, std::string>::iterator iter = cyclesNamesCol_.find(cycleId);
    if (iter != cyclesNamesCol_.end())
    {
        return iter->second;
    }
    else
    {
        return "";
    }
}

void FieldElement::getDimensions(uint32_t& dimension1, uint32_t& dimension2)
{
    dimension1 = dimension1_;
    dimension1 = dimension2_;
}

DataStoreElement::DataStoreElement(const std::string name)
{
    setFieldValue("name", name);
}

DataStoreElement::~DataStoreElement()
{

    for (std::map<std::string, FieldElement*>::iterator iter = fieldElements_.begin(); iter != fieldElements_.end(); iter++)
        delete iter->second;

    fieldElements_.clear();

}

FieldElement* DataStoreElement::getFieldElement(std::string fieldName)
{
    std::map<std::string, FieldElement*>::iterator iter = fieldElements_.find(fieldName);
    if (iter != fieldElements_.end())
    {
        return iter->second;
    }
    return NULL;

}

const std::map<std::string, FieldElement*>& DataStoreElement::getFieldElementMap()
{
    return fieldElements_;
}

const std::string& DataStoreElement::getFieldValue(std::string fieldName)
{

    FieldElement* fieldElement = NULL;
    std::map<std::string, FieldElement*>::iterator iter = fieldElements_.find(fieldName);
    if (iter != fieldElements_.end())
    {
        fieldElement = iter->second;
    }
    if (fieldElement != NULL)
    {
        std::map<int32_t, std::string>::iterator iterCriterion = fieldElement->fieldValuesCol_.begin();

        if (iterCriterion != fieldElement->fieldValuesCol_.end())
        {
            return iterCriterion->second;

        }
    }
    throw FesaException(__FILE__, __LINE__, FesaErrorDataStoreElementRetrievingFieldValue.c_str(),
                        fieldName.c_str());
}

void DataStoreElement::addFieldElement(FieldElement* fieldElement)
{
    std::map<std::string, FieldElement*>::iterator iter = fieldElements_.find(fieldElement->fieldName_);
    if (iter != fieldElements_.end())
    {
        iter->second = fieldElement;
    }
    else
    {
        fieldElements_.insert(make_pair(fieldElement->fieldName_, fieldElement));
    }
}

void DataStoreElement::setFieldValue(std::string fieldName, std::string fieldValue)
{

    FieldElement* fieldElement = NULL;
    std::map<std::string, FieldElement*>::iterator iter = fieldElements_.find(fieldName);
    if (iter != fieldElements_.end())
    {
        fieldElement = iter->second;
    }
    if (fieldElement != NULL)
    {

        fieldElement->fieldValuesCol_.insert(make_pair(1, fieldValue));

    }
    else
    {
        fieldElement = new FieldElement(fieldName);

        fieldElement->fieldValuesCol_.insert(make_pair(1, fieldValue));
        fieldElements_.insert(make_pair(fieldElement->fieldName_, fieldElement));
    }
}

const std::string& DataStoreElement::getName()
{
    return getFieldValue("name");
}

int32_t DataStoreElement::getSize()
{
    return static_cast<int32_t>(fieldElements_.size());
}

const std::string& DataStoreElement::getTimingDomain()
{
    return getFieldValue("timingDomain");
}
const std::string& DataStoreElement::getTimingCriterion()
{
    return getFieldValue("mainMuxCriterion");
}

bool DataStoreElement::isMultiplexed ()
{

    if (getTimingCriterion().compare("NONE") != 0 && getTimingDomain().compare("NONE") != 0)
    {
        return true;
    }
    else
    {
        return false;
    }

}

//***************************************

GlobalDeviceElement::GlobalDeviceElement(const std::string name) :
    DataStoreElement(name)
{

}

GlobalDeviceElement::~GlobalDeviceElement()
{

}

// Fields from GlobalDevice
const std::string& GlobalDeviceElement::getClassName()
{
    return getFieldValue("className");
}

const std::string& GlobalDeviceElement::getDescription()
{
    return getFieldValue("description");
}

//***************************************

DeviceElement::DeviceElement(const std::string name) :
    DataStoreElement(name)
{

}

DeviceElement::~DeviceElement()
{

}

const std::string& DeviceElement::getAccelerator()
{
    return getFieldValue("accelerator");
}

const std::string& DeviceElement::getDescription()
{
    return getFieldValue("description");
}

bool DeviceElement::isMultiplexed()
{
    std::string fieldValue = getFieldValue("isMux");
    if (fieldValue == "true")
    {
        return true;
    }
    else
    {
        return false;
    }
}

//***************************************

DomainStoreElement::DomainStoreElement(const std::string name) :
    DataStoreElement(name)
{

}

DomainStoreElement::~DomainStoreElement()
{

}

const std::string& DomainStoreElement::getTimingDomain()
{
    return getFieldValue("timingDomain");
}

const std::string& DomainStoreElement::getMultiplexingCriterion()
{
    return getFieldValue("multiplexing-criterion");
}

} // fesa