AbstractServerDeviceClass.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Server/AbstractServerDeviceClass.h>

#include <fesa-core/Server/AbstractServerEquipment.h>
#include <fesa-core/Server/Property.h>
#include <fesa-core/Server/AbstractServerActionFactory.h>
#include <fesa-core/Server/AbstractServerAction.h>
#include <fesa-core/DataStore/EquipmentData.h>
#include <fesa-core/DataStore/FieldSynchroManager.h>
#include <fesa-core/DataStore/AbstractDeviceFactory.h>
#include <fesa-core/DataStore/AbstractDevice.h>
#include <fesa-core/DataStore/GlobalDevice.h>
#include <fesa-core/Diagnostic/FesaStream.h>

#include <cmw-log/Logger.h>

#include <iostream>

namespace
{

CMW::Log::Logger& logger = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core.Server.AbstractServerDeviceClass");

}

namespace fesa
{

AbstractServerDeviceClass::AbstractServerDeviceClass(const std::string& name, const std::string& version) :
    AbstractDeviceClass(name, version)
{
    // Register itself
    AbstractServerEquipment::getInstance()->registerDeviceClass(this);
}

AbstractServerDeviceClass::~AbstractServerDeviceClass()
{
    std::map<std::string, Property*>::iterator properties;

    for (properties = propertiesCol_.begin(); properties != propertiesCol_.end(); properties++)
        if (properties->second != NULL)
        {
            delete properties->second;
            properties->second = NULL;
        }

    relatedClassCol_.clear();
    propertiesCol_.clear();

    try
    {
        AbstractServerEquipment::getInstance()->deregisterDeviceClass(name_);
    }
    // the class might have already been deleted
    catch (FesaException& ex)
    {

    }
}

void AbstractServerDeviceClass::initialize()
{
    // configure the properties
    configurePropertiesActions();

    *(EquipmentData::getInstance()->srvProcessPid_) = getpid();

    // The user's init is now called
    specificInit();

    // Synchronize the setting fields
    FieldSynchroManager* pFieldSynchroManager = FieldSynchroManager::getInstance();
    pFieldSynchroManager->commitModifiedFieldSynchronization();

    AbstractDeviceFactory* pAbstractDeviceFactory = getDeviceFactory();
    const std::vector<AbstractDevice*>& abstractDevCol = pAbstractDeviceFactory->getAbstractDeviceCollection();
    for (uint32_t i = 0; i < abstractDevCol.size(); ++i)
    {
        abstractDevCol[i]->synchronizeSettingFields();
    }

    GlobalDevice* pGlobalDevice = pAbstractDeviceFactory->getGlobalDevice();
    if (pGlobalDevice != NULL)
    {
        pGlobalDevice->synchronizeSettingFields();
    }

}

void AbstractServerDeviceClass::configurePropertiesActions()
{
    // get the properties information from the design document
    std::vector<PropertyInfo*>* propertiesConfig = fillProperties();
    std::map<std::string, std::vector<std::string> >* actionsConfig = fillActions();

    for (uint32_t i = 0; i < propertiesConfig->size(); i++)
    {
        // CRFESA-764 put this verbose option
        if(logger.isLoggable(CMW::Log::Level::LL_DEBUG))
        {
            std::ostringstream msg;
            msg << "setting property " << (*propertiesConfig)[i]->name_;
            LOG_DEBUG_IF(logger, msg.str());
        }

        AbstractServerAction* getServerAction = NULL;
        AbstractServerAction* setServerAction = NULL;

        if (!(((*propertiesConfig)[i])->getActionProperty_.name_.empty()))
        {
            ServerActionConfig config = (*propertiesConfig)[i]->getActionProperty_;
            getServerAction = actionFactory_->createServerAction(config);
        }

        if (!(*propertiesConfig)[i]->setActionProperty_.name_.empty())
        {
            ServerActionConfig config = (*propertiesConfig)[i]->setActionProperty_;
            //fill the notified properties of Server Set-actions
            std::map<std::string, std::vector<std::string> >::iterator iter = actionsConfig->find(config.name_);
            if (iter != actionsConfig->end())
                config.notifiedPropertiesCol_ = (*iter).second;
            setServerAction = actionFactory_->createServerAction(config);
        }

        //create the property. Exceptions will be caught in the main
        Property* prop = new Property((*propertiesConfig)[i]->name_, (*propertiesConfig)[i]->isGlobal_,
                                      (*propertiesConfig)[i]->isOnChange_, (*propertiesConfig)[i]->isSubscribable_,
                                      (*propertiesConfig)[i]->type_, (*propertiesConfig)[i]->multiplexed_,
                                      (*propertiesConfig)[i]->priorityOffset_, (*propertiesConfig)[i]->notificationThreadKey_, getServerAction, setServerAction, (*propertiesConfig)[i]->className_);
        propertiesCol_.insert(std::make_pair(prop->getName(), prop));
    }// end loop the properties

    /* To avoid memory leak, content of propertiesConfig has to be deleted!
     * This does not work if we use an iterator in the loop and call
     * properties = propertiesConfig.erase(properties)
     */
    if (propertiesConfig != NULL)
    {
        for (uint32_t i = 0; i < propertiesConfig->size(); i++)
        {
            delete (*propertiesConfig)[i];
        }
        delete propertiesConfig;
        propertiesConfig = NULL;
    }
    if (actionsConfig != NULL)
    {
        delete actionsConfig;
        actionsConfig = NULL;
    }
}

Property* AbstractServerDeviceClass::getProperty(const std::string& propertyName)
{
    std::map<std::string, Property*>::iterator itr = propertiesCol_.find(propertyName);
    if (itr != propertiesCol_.end())
    {
        return (*itr).second;
    }
    else if (baseClass_ != NULL)
    {
        return ((AbstractServerDeviceClass*) baseClass_)->getProperty(propertyName);
    }

    return NULL;
}

// why is this service here?
void AbstractServerDeviceClass::reportErrorToSubscribers(std::string Message)
{
}

void AbstractServerDeviceClass::printConfig(FesaStream* configStream)
{
    *configStream << "\t\t<class name=\"" << name_ << "\" version=\"" << version_ << "\">" << std::endl;
    *configStream << "\t\t\t<relationship>" << std::endl;
    if(baseClass_ != NULL)
    {
        *configStream << "\t\t\t\t<inheritance name=\"" << baseClass_->getName() << "\" version=\"" << baseClass_->getVersion() << "\"/>" << std::endl;
    }
    if (!relatedClassCol_.empty())
    {
        for(std::vector<AbstractDeviceClass*>::iterator it=relatedClassCol_.begin(); it!=relatedClassCol_.end(); ++it)
        {
            AbstractDeviceClass* pADC = (AbstractDeviceClass*)*it;
            *configStream << "\t\t\t\t<composition name=\"" << pADC->getName() << "\" version=\"" << pADC->getVersion() << "\"/>" << std::endl;
        }
    }
    *configStream << "\t\t\t</relationship>" << std::endl;
    *configStream << "\t\t\t<interface>" << std::endl;
    *configStream << "\t\t\t\t<device-interface>" << std::endl;
    std::map<std::string, Property*>::iterator itProp;
    // iterate trough the collection properties and extract first the device ones
    for (itProp = propertiesCol_.begin(); itProp != propertiesCol_.end(); ++itProp)
    {
        if (!itProp->second->isGlobal()) //device property
        {
            itProp->second->printConfig(configStream);
        }
    }
    *configStream << "\t\t\t\t</device-interface>" << std::endl;
    *configStream << "\t\t\t\t<global-interface>" << std::endl;
    // iterate trough the collection properties and extract first the global ones
    for (itProp = propertiesCol_.begin(); itProp != propertiesCol_.end(); ++itProp)
    {
        if (itProp->second->isGlobal()) //global property
        {
            itProp->second->printConfig(configStream);
        }
    }
    *configStream << "\t\t\t\t</global-interface>" << std::endl;
}

void AbstractServerDeviceClass::printState(FesaStream* fesaStream, double elapsedTime)
{
}

} // fesa