Slots.h

Go to the documentation of this file.

/*  This file is part of Charon.

    Charon is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Charon is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with Charon.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _SLOTS_H
#define _SLOTS_H

#include "TypeDetector.h"
#include "AbstractData.hxx"
#include <set>
#include "DllEx.h"

class ParameteredObject;
class PluginManagerInterface;
class ParameterFile;

class charon_core_DLL_PUBLIC Slot {
private:
    Slot(const Slot&);

protected:
    virtual bool _addTarget(Slot* target) = 0;

    virtual bool _removeTarget(Slot* target) = 0;

    ParameteredObject* _parent;

    std::string _name;

    std::string _displayName;

    std::string _type;

    bool _optional;

    bool _multiSlot;

public:
    Slot();

    void init(ParameteredObject* parent, std::string name, std::string type);

    void init(ParameteredObject* parent, std::string name, std::string displayname, std::string type);


    virtual void prepare() = 0;


    virtual void finalize() = 0;

    virtual ~Slot();

    ParameteredObject& getParent();

    const ParameteredObject& getParent() const;

    virtual std::string getName() const;

    virtual std::string getDisplayName() const;

    void printInfo(const std::string& msg) const;

    void printWarning(const std::string& msg) const;

    void printError(const std::string& msg) const;

    void raise(const std::string& msg) const;

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

    bool getMulti() const;

    bool getOptional() const;

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

    virtual std::set<Slot*> getTargets() const = 0;

    bool connected() const;

    bool connected(Slot& target) const;


    bool connect(Slot& target);

    bool disconnect();

    bool disconnect(Slot& target);

    virtual void save(ParameterFile& pf) const;


    virtual void load(
            const ParameterFile& pf,
            const PluginManagerInterface* man) = 0;


    enum CacheType {
        CACHE_INVALID, 
        CACHE_MEM,     
        CACHE_MANAGED  
    };


    template<typename T>
    class DataManager {
    public:
        virtual ~DataManager() {}
        virtual void setData(const T& data ) = 0;
        virtual T getData() = 0;
        virtual std::string getConfig() const = 0;
    };


    template <typename T>
    class DataManagerFactory {
    public:

        static DataManager<T>* getManager(
            const Slot& slot, const std::string& config = "");
    };
};

template <typename T>
class charon_core_PUBLIC AbstractSlot : public Slot {
protected:
    std::set<AbstractSlot<T>*> _targets;


    virtual bool _addTarget(Slot* target);

    virtual bool _removeTarget(Slot* target);

public:
    AbstractSlot();
    virtual ~AbstractSlot();

    // overload Slot functions
    virtual std::string guessType() const;
    virtual std::set<Slot*> getTargets() const;
    virtual void save(ParameterFile& pf) const;
    virtual std::string getType() const;

    //  @{
    typename std::set<AbstractSlot<T>*>::const_iterator begin() const;
    typename std::set<AbstractSlot<T>*>::const_iterator end() const;
    //  @}
};

class charon_core_PUBLIC InputSlotIntf
{
public:


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

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

};

class charon_core_PUBLIC OutputSlotIntf;

template <typename T>
class charon_core_PUBLIC InputSlot :
        public AbstractSlot<T>, public AbstractROData<T>,
        public AbstractMultiROData<T>, public InputSlotIntf {
public:
    InputSlot(bool optional=false, bool multi=false);

    virtual ~InputSlot();

    // overload Slot functions
    virtual void load(
            const ParameterFile& pf, const PluginManagerInterface* man);
    virtual operator T() const;
    virtual const T& operator()() const;
    virtual const T& operator[](std::size_t pos) const;
    virtual std::size_t size() const;

    virtual void prepare();
    virtual void finalize();

    virtual std::string getName() const
    {
        return AbstractSlot<T>::getName();
    }

    virtual std::string getType() const
    {
        return AbstractSlot<T>::getType();
    }


    const T& getDataFromOutputSlot(const OutputSlotIntf* slot) const;


    const T& getDataFromOutputSlot(const Slot* slot) const;

private:
    std::map<std::string, T> _dataCache;
};


class charon_core_PUBLIC OutputSlotIntf
{
public:
    virtual void setConfig(std::string conf)=0;
    virtual const std::string& getConfig() const=0;

    virtual void setCacheType(Slot::CacheType type)=0;

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

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

    virtual Slot::CacheType getCacheType() const=0;


    virtual const OutputSlotIntf* getDataSlot() const=0;

};

template <typename T>
class charon_core_PUBLIC OutputSlot :
        public AbstractSlot<T>, public AbstractData<T>,public OutputSlotIntf {

private:
    const T _initVal;
    T* data; 
    void _check() const;
    void _prepare();
    Slot::CacheType _cacheType;
    std::string _managerConfig;

public:

    OutputSlot(const T& initval = T());
    virtual ~OutputSlot();

    virtual void load(
            const ParameterFile& pf, const PluginManagerInterface* man);

    void setCacheType(Slot::CacheType type);
    Slot::CacheType getCacheType() const {
        return _cacheType;
    }
    virtual const std::string& getConfig() const {
        return _managerConfig;
    }

    // overload Slot functions
    virtual operator T() const;
    virtual const T& operator()() const;
    virtual T& operator()();
    virtual T& operator= (const T& B);
    virtual void prepare();
    virtual void finalize();



    const OutputSlotIntf* getDataSlot() const
    {
        return this;
    }

    virtual std::string getName() const
    {
        return AbstractSlot<T>::getName();
    }

    virtual std::string getType() const
    {
        return AbstractSlot<T>::getType();
    }
    virtual void setConfig(std::string conf)
    {
        _managerConfig=conf;
    }


};



class  charon_core_DLL_PUBLIC VirtualSlot
    :public Slot
{
public:
    friend class VirtualInputSlot;
    friend class VirtualOutputSlot;
    VirtualSlot(std::string virtType,int num=0);
    virtual void load(
            const ParameterFile& pf, const PluginManagerInterface* man);
    virtual void save(ParameterFile& pf) const;

    bool _addTarget(Slot *target);

    bool _removeTarget(Slot *target);




    virtual void prepare();

    virtual void finalize();

    std::string guessType() const;

    std::string getName() const;

    std::string getType() const;

    virtual std::set<Slot*> getTargets() const;

    void setVirtualPartnerSlot(VirtualSlot* insl);
protected:
    virtual bool isValidPartner(VirtualSlot* insl)=0;
    virtual bool isValidTarget(Slot* target)=0;

    void setDisplayNameAndType(std::string name,std::string type);

    virtual void onLoad(const ParameterFile& pf, const PluginManagerInterface* man);

    virtual void onSave(ParameterFile& pf) const;
    virtual bool onAddTarget(Slot* target);
    virtual bool onRemoveTarget(Slot* target);

    VirtualSlot* _partner;
    std::set<Slot*> _target;





};
class VirtualInputSlot;
class charon_core_DLL_PUBLIC VirtualOutputSlot
    :public VirtualSlot,public OutputSlotIntf
{
public:
    friend class VirtualInputSlot;
    VirtualOutputSlot(int num=0);
    void setCacheType(Slot::CacheType type);

    Slot::CacheType getCacheType() const;

    std::string getType() const;

    std::string getName() const ;

    const std::string& getConfig() const;

    const OutputSlotIntf* getDataSlot() const;

    virtual void setConfig(std::string conf);

    void setLoopPartner(VirtualInputSlot* loopPartner);
    void setLoop(bool loop);
protected:
    virtual bool isValidPartner(VirtualSlot *insl);
    virtual bool isValidTarget(Slot *target);
    void onLoad(const ParameterFile &pf, const PluginManagerInterface *man);
    void onSave(ParameterFile &pf) const;
    virtual bool onAddTarget(Slot *target);
    virtual bool onRemoveTarget(Slot *target);

private:
    std::string _managerconfig;
    Slot::CacheType _cacheType;
    VirtualInputSlot* _loopPartner;
    bool _loop;


};



class charon_core_DLL_PUBLIC VirtualInputSlot
    :public VirtualSlot,public InputSlotIntf
{
public:
    friend class VirtualOutputSlot;
    VirtualInputSlot(int num=0);





    std::string getType() const;

    std::string getName() const ;

protected:
    virtual bool isValidPartner(VirtualSlot *insl);
    virtual bool onAddTarget(Slot *target);
    virtual bool onRemoveTarget(Slot *target);
    virtual bool isValidTarget(Slot *target);









};





#endif /* _SLOTS_H */