factoryBaseImpl.h

/*
 * Nominal Device Support v3 (NDS3)
 *
 * Copyright (c) 2015 Cosylab d.d.
 *
 * For more information about the license please refer to the license.txt
 * file included in the distribution.
 */

#ifndef NDSFACTORYBASEIMPL_H
#define NDSFACTORYBASEIMPL_H

#include <map>
#include <mutex>
#include <memory>
#include <thread>
#include "nds3/definitions.h"

namespace nds
{

class InterfaceBaseImpl;
class BaseImpl;
class NodeImpl;
class PVBaseImpl;
class LogStreamGetterImpl;
class ThreadBaseImpl;
class IniFileParserImpl;

class NDS3_API FactoryBaseImpl: public std::enable_shared_from_this<FactoryBaseImpl>
{
    friend class InterfaceBaseImpl;
public:
    FactoryBaseImpl();

    virtual ~FactoryBaseImpl();

    virtual void preDelete();

    virtual ThreadBaseImpl* runInThread(const std::string& name, threadFunction_t function);

    static void loadDriver(const std::string& libraryName);

    void* createDevice(const std::string& driverName, const std::string& deviceName, const namedParameters_t& parameters);

    void destroyDevice(void* pDevice);

    void destroyDevice(const std::string& deviceName);

    void holdNode(void* pDeviceObject, std::shared_ptr<NodeImpl> pHoldNode);

    const std::string& getSeparator(const std::uint32_t nodeLevel) const;

    void loadNamingRules(std::istream& rules);
    void setNamingRules(const std::string& rulesName);

    std::string getRootNodeName(const std::string& name) const;
    std::string getGenericChannelName(const std::string& name) const;
    std::string getInputChannelName(const std::string& name) const;
    std::string getOutputChannelName(const std::string& name) const;
    std::string getSourceChannelName(const std::string& name) const;
    std::string getSinkChannelName(const std::string& name) const;
    std::string getInputPVName(const std::string& name) const;
    std::string getOutputPVName(const std::string& name) const;
    std::string getStateMachineNodeName(const std::string& name) const;
    std::string getStateMachineSetStateName(const std::string& name) const;
    std::string getStateMachineGetStateName(const std::string& name) const;
    std::string getStateMachineGetGlobalStateName(const std::string& name) const;
    std::string getDecimationPVName(const std::string& name) const;

    std::string buildNameFromRule(const std::string& name,
                                  const std::string& rule0,
                                  const std::string& rule1 = "",
                                  const std::string& rule2 = "",
                                  const std::string& rule3 = "",
                                  const std::string& rule4 = ""
                                  ) const;

    virtual const std::string& getDefaultSeparator(const std::uint32_t nodeLevel) const = 0;

    virtual const std::string getName() const = 0;


    virtual InterfaceBaseImpl* getNewInterface(const std::string& fullName) = 0;

    virtual void run(int argc,char *argv[]) = 0;

    virtual LogStreamGetterImpl* getLogStreamGetter() = 0;

    virtual void registerCommand(const BaseImpl& node,
                                 const std::string& command,
                                 const std::string& usage,
                                 const size_t numParameters, command_t commandFunction) = 0;

    virtual void deregisterCommand(const BaseImpl& node) = 0;

private:
    struct allocatedDevice_t
    {
        void* m_pDevice;
        deallocateDriver_t m_deallocationFunction;
    };

    typedef std::map<std::string, allocatedDevice_t> allocatedDevices_t;
    allocatedDevices_t m_allocatedDevices;

    typedef std::list<std::shared_ptr<NodeImpl> > nodesList_t;
    typedef std::map<void*, nodesList_t> heldNodes_t;
    heldNodes_t m_heldNodes;

    std::mutex m_mutex;

    std::unique_ptr<IniFileParserImpl> m_namingRules;
    std::string m_namingRulesName;

};

}


#endif // NDSFACTORYBASEIMPL_H