MultiplexingContext.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Synchronization/MultiplexingContext.h>

#include <fesa-core/Synchronization/CycleDescriptor.h>
#include <fesa-core/Synchronization/SynchronizationLabObjectFactory.h>
#include <fesa-core/Core/MessageTypes.h>
#include <fesa-core/Core/AbstractEquipment.h>
#include <fesa-core/Diagnostic/FesaStream.h>
#include <fesa-core/Exception/FesaException.h>


namespace fesa
{

MultiplexingContext::MultiplexingContext() :
    cycleName_(""), extraCondition_(""), cycleId_(-1), cycleStamp_(0), type_(NoneCtxt),
    forewarning_(false), timingDomainId_(-1), timingDomainName_(""),  settingAccessMask_(0),  acquisitionAccessMask_(0)
{
    // accessing from specific init, even from the server should be allowed
    AbstractEquipment* pEquipment = AbstractEquipment::getInstance();
    if(!pEquipment->isInitialized())
    {
        setSettingAccess(SET_ALLOWED);
    }
    setAcquisitionAccess(SET_ALLOWED);
}

MultiplexingContext::MultiplexingContext(std::istream& stream)
{
    int32_t type;
    std::string none = "NONE";
    stream >> type;
    type_ = (MuxContextType)type;
    stream >> cycleName_;
    if (!cycleName_.compare(none))
        cycleName_ = "";
    stream >> extraCondition_;
    if (!extraCondition_.compare(none))
        extraCondition_ = "";
    stream >> timingDomainName_;
    if (!timingDomainName_.compare(none))
        timingDomainName_ = "";
    stream >> cycleId_;
    stream >> timingDomainId_;
    stream >> cycleStamp_;
    stream >> forewarning_;
    uint32_t mask; // Using 32-bit variable to force ASCII decoding
    stream >> mask;
    settingAccessMask_ = static_cast<uint8_t>(mask);
    stream >> mask;
    acquisitionAccessMask_ = static_cast<uint8_t>(mask);
}

MultiplexingContext::~MultiplexingContext()
{

}

void MultiplexingContext::serialize(std::ostream& stream)
{

    stream << type_ << NUMBER_SEPARATOR;
    std::string none = "NONE";

    if (cycleName_.empty())
    {
        stream << none << STRING_SEPARATOR;
    }
    else
    {
        stream << cycleName_ << STRING_SEPARATOR;
    }

    if (extraCondition_.empty())
    {
        stream << none << STRING_SEPARATOR;
    }
    else
    {
        stream << extraCondition_ << STRING_SEPARATOR;
    }

    if (timingDomainName_.empty())
    {
        stream << none << STRING_SEPARATOR;
    }
    else
    {
        stream << timingDomainName_ << STRING_SEPARATOR;
    }

    stream << cycleId_;
    stream << NUMBER_SEPARATOR;
    stream << timingDomainId_;
    stream << NUMBER_SEPARATOR;
    stream << cycleStamp_;
    stream << NUMBER_SEPARATOR;
    stream << forewarning_;
    stream << NUMBER_SEPARATOR;
    stream << static_cast<uint32_t>(settingAccessMask_); // Using 32-bit cast to force ASCII encoding
    stream << NUMBER_SEPARATOR;
    stream << static_cast<uint32_t>(acquisitionAccessMask_); // Using 32-bit cast to force ASCII encoding
    stream << NUMBER_SEPARATOR;
}

void MultiplexingContext::setExtraCondition(const std::string& extraCondition)
{

    CycleSelector selector;

    fesa::parseCycleSelector(extraCondition, selector);

    SynchronizationLabObjectFactory* syncFactory = SynchronizationLabObjectFactory::getInstance();
    CycleDescriptor::CycleDescriptor* td = syncFactory->getCycleDescriptor(selector.domain_,selector.criterion_);

    if (td->isValidCycleSelector(extraCondition))
    {
        extraCondition_ = extraCondition;
    }
    else
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorNotValidExtraCondition.c_str(), extraCondition.c_str());

    }
}

uint8_t MultiplexingContext::getSettingAccessMask()
{
    return settingAccessMask_;
}

void MultiplexingContext::setSettingAccess(uint8_t accessMask)
{
    settingAccessMask_ =  accessMask;
}

uint8_t MultiplexingContext::getAcquisitionAccessMask()
{
    return acquisitionAccessMask_;
}

void MultiplexingContext::setAcquisitionAccess(unsigned char accessMask)
{
    acquisitionAccessMask_ =  accessMask;
}

} // fesa