ndsFactoryImpl.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 NDSFACTORYIMPL_H
#define NDSFACTORYIMPL_H

#include <string>
#include <map>
#include <list>
#include <memory>
#include <mutex>
#include <dirent.h>
#include "nds3/definitions.h"

namespace nds
{

class FactoryBaseImpl;
class DynamicModule;
class PVBaseInImpl;
class PVBaseOutImpl;

class NdsFactoryImpl
{
public:
    static NdsFactoryImpl& getInstance();

    NdsFactoryImpl();

    ~NdsFactoryImpl();

    std::shared_ptr<FactoryBaseImpl> getControlSystem(const std::string& controlSystem);

    void loadDriver(const std::string& driverModuleName);

    void registerDriver(const std::string& driverName, allocateDriver_t allocateFunction, deallocateDriver_t deallocateFunction);

    void registerControlSystem(std::shared_ptr<FactoryBaseImpl> pControlSystem);

    std::pair<void*, deallocateDriver_t> createDevice(FactoryBaseImpl& factory, const std::string& driverName, const std::string& deviceName, const namedParameters_t& parameters);

    void subscribe(const std::string& pushFrom, PVBaseOutImpl* pReceiver);

    void subscribe(const std::string& pushFrom, const std::string& pushTo);

    void unsubscribe(PVBaseOutImpl* pReceiver);

    void unsubscribe(const std::string& pushTo);

    void replicate(const std::string& replicateSource, PVBaseInImpl* pDestination);

    void replicate(const std::string& replicateSource, const std::string& replicateDestination);

    void stopReplicationTo(PVBaseInImpl* pDestination);

    void stopReplicationTo(const std::string& replicateDestination);


    void registerInputPV(PVBaseInImpl* pSender);
    void deregisterInputPV(PVBaseInImpl* pSender);
    void registerOutputPV(PVBaseOutImpl* pReceiver);
    void deregisterOutputPV(PVBaseOutImpl* pReceiver);

private:
    typedef std::list<std::string> fileNames_t;

    static fileNames_t listFiles(const fileNames_t& folders, const std::string& prefix, const std::string& suffix);

    static fileNames_t separateFoldersList(const char* foldersList);

    typedef std::map<std::string, std::shared_ptr<FactoryBaseImpl> > controlSystems_t;
    controlSystems_t m_controlSystems;
    std::mutex m_lockControlSystems;

    typedef std::map<std::string, std::pair<allocateDriver_t, deallocateDriver_t> > driverAllocDeallocMap_t;
    driverAllocDeallocMap_t m_driversAllocDealloc;
    std::mutex m_lockDrivers;

    typedef std::list<std::shared_ptr<DynamicModule> > modules_t;
    modules_t m_modules;

    typedef std::map<std::string, PVBaseInImpl*> registeredInputPVs_t;
    registeredInputPVs_t m_registeredInputPVs;

    typedef std::map<std::string, PVBaseOutImpl*> registeredOutputPVs_t;
    registeredOutputPVs_t m_registeredOutputPVs;

    std::recursive_mutex m_lockRegisteredPVs;
};

class DynamicModule
{
public:
    DynamicModule(const std::string& libraryName);
    ~DynamicModule();

    void* getAddress(const std::string& functionName);

public:
    void* m_moduleHandle;
};


class Directory
{
public:
    Directory(const std::string& directory);
    ~Directory();

    std::string getNextFileName();

private:
    DIR* m_pDirectory;
};

}
#endif // NDSFACTORYIMPL_H