AbstractEquipment.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef ABSTRACT_EQUIPMENT_H_
#define ABSTRACT_EQUIPMENT_H_

#include <fesa-core/Core/FesaDefs.h>
#include <fesa-core/Utilities/ProcessConfiguration.h>

#include <map>
#include <string>
#include <boost/shared_ptr.hpp>

namespace fesa
{

class AbstractComponentEquipment;
class Diagnostics;

class AbstractEquipment
{
  public:

    AbstractComponentEquipment* getServerComponent();

    AbstractComponentEquipment* getRTComponent();

    inline const ProcessConfiguration* getProcessConfiguration();

    const boost::shared_ptr<Diagnostics>& getDiagnostics() const;
        
    virtual void initialize() = 0;

    static AbstractEquipment* getInstance();

    void start();

    const std::string& getEquipmentName();

    const FesaProcessType& getProcessType();

    std::string getProcessTypeAsString();

    const std::string& getFesaVersion();

    const std::string& getVersion();

    const std::string& getFesaBuildDate();

    const std::string& getHostName();

    const std::string getDeviceDataFileName();

    const std::string getPersistencyFileName(const std::string& className);


    const std::string getNotificationFileName();

    bool getTimingSimulationMode();

    void setClassOptional (const std::string& className,bool optional);

    bool isClassOptional (const std::string &className);

    bool isInitialized ();

  protected:

    AbstractEquipment(const std::string& equipmentName, FesaProcessType processType, const boost::shared_ptr<ProcessConfiguration>& configuration, const boost::shared_ptr<Diagnostics>& diagnostics);

    //Default constructor only used for unit-tests
    AbstractEquipment()
    {
    }

    virtual ~AbstractEquipment();

    std::string equipmentName_;

    FesaProcessType processType_;

    AbstractComponentEquipment* theRTEquipmentComponent_;

    AbstractComponentEquipment* theServerEquipmentComponent_;

    std::map<std::string,bool> optionalClasses_;

    /*
     * \brief version of the used fesa-framework (e.g 1.2.3)
     */
    std::string fesaVersion_;

    /*
     * \brief version of this equipment (deploy-unit version e.g. 4.5.6)
     */
    std::string version_;

    /*
     * \brief Equipment compilation date and time
     */
    std::string madeAt_;

    /*
     * \brief This flag indicates if the Equipment has been already initialized
     */
    bool initialized_;

    static AbstractEquipment* instance_;

  private:

    std::string hostName_;
    boost::shared_ptr<ProcessConfiguration> configuration_;
    boost::shared_ptr<Diagnostics> diagnostics_;
};

//------------------ inline methods ------------------

inline AbstractComponentEquipment* AbstractEquipment::getServerComponent()
{
    return theServerEquipmentComponent_;
}

inline AbstractComponentEquipment* AbstractEquipment::getRTComponent()
{
    return theRTEquipmentComponent_;
}

inline AbstractEquipment* AbstractEquipment::getInstance()
{
    return instance_;
}

inline const std::string& AbstractEquipment::getEquipmentName()
{
    return equipmentName_;
}

inline const FesaProcessType& AbstractEquipment::getProcessType()
{
    return processType_;
}

inline const std::string& AbstractEquipment::getHostName()
{
    return hostName_;
}

inline const ProcessConfiguration* AbstractEquipment::getProcessConfiguration()
{
    return configuration_.get();
}

inline bool AbstractEquipment::getTimingSimulationMode()
{
    return configuration_->isInTimingSimulationMode();
}

inline const std::string& AbstractEquipment::getFesaVersion()
{
    return fesaVersion_;
}

inline const std::string& AbstractEquipment::getVersion()
{
    return version_;
}

inline const std::string& AbstractEquipment::getFesaBuildDate()
{
    return madeAt_;
}

inline bool AbstractEquipment::isInitialized ()
{
    return initialized_;
}

} // fesa

#endif // ABSTRACT_EQUIPMENT_H_