ParameteredObject.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 _ParameteredObject_H
#define _ParameteredObject_H

#include <set>
#include "ParameterFile.h"
#include "Parameter.h"
#include "Slots.h"
#include "DllEx.h"

class PluginManagerInterface;


class charon_core_DLL_PUBLIC ParameteredObject {
private:
    bool _createMetadata;


    ParameterFile _metadata;

    std::string _className;

    std::string _instanceName;

    std::map<std::string, AbstractParameter*> _parameters;

    std::map<std::string, Slot*> _inputs;

    std::map<std::string, Slot*> _outputs;

    bool _initialized;

    bool _executed;


    ParameteredObject(const ParameteredObject&) {}

    ParameteredObject();

protected:
    void _setDynamic(bool v);

    void _removeInputSlot(std::string name);

    void _removeOutputSlot(std::string name);

    bool _removeSomething(const std::string &extension, const std::string &name);


    bool _addSomething(
            const std::string& extension, const std::string& name,
            const std::string& doc, const std::string& type,
            const std::string& defaultValue = "");


    void _addParameter(AbstractParameter& param, const std::string& name,
        const std::string& doc, const std::string& type = "");


    template<class T>
    void _addParameter(
            Parameter<T>& param, const std::string& name,
            const std::string& doc, const T& defVal,
            const std::string& type = "");


    //  \{

    void _addInputSlot(Slot& slot, const std::string& name,
        const std::string& doc, const std::string& type = "");


    void _addOutputSlot(Slot& slot, const std::string& name,
        const std::string& doc, const std::string& type = "");
    //  \}


    void _addInputSlot(Slot& slot, const std::string& name, const std::string& displayname,
        const std::string& doc, const std::string& type);


    void _addOutputSlot(Slot& slot, const std::string& name, const std::string& displayname,
        const std::string& doc, const std::string& type);


    void _setTags(const std::string& tags) ;


    #define _addFunction(x)\
        if (!this && &x) {\
            throw 42;\
        }


    #define _addConstructor(x)\
        if (!this && new x) {\
            throw 42;\
        }


    ParameteredObject(const std::string& className,
        const std::string& name = "", const std::string& doc = "");



    std::set<ParameteredObject*> _getTargetNodes();


    virtual void execute();


    virtual void finalize();

    void runPreceeding() const;


    void runPreceeding(const Slot& slot) const;

    void _prepareSlots();

    void _commitSlots();

public:
    enum template_type {
        TYPE_DOUBLE = 0, 
        TYPE_FLOAT = 1,  
        TYPE_INT = 2     
    };

    enum build_type {
        UNDEFINED_BUILD = 0,
        DEBUG_BUILD = 1,     
        RELEASE_BUILD = 2    
    };


    virtual ~ParameteredObject();


    void save(ParameterFile& pf) const;

    const ParameterFile& getMetadata();


    void clearMetadata();

    std::string fixCase(const std::string& parOrSlotName) const;


    virtual void run();


    virtual void initialize();


    virtual void setExecuted(bool value) {
        _executed = value;

    }

    bool executed() const {
        return _executed;
    }


    Parameter < bool > _active;


#define PARAMETEREDOBJECT_AVOID_REEXECUTION \
        sout << "(WW) using deprecated AVOID_REEXECUTION macro" << std::endl;


    virtual void resetExecuted(bool propagate = true);


    virtual void prepareDynamicInterface(const ParameterFile& file);

    //\{

    inline const std::string& getClassName() const {
        return _className;
    }

    inline const std::string& getName() const {
        return _instanceName;
    }


    virtual const std::string getTemplateType() const;


    Slot* getSlot(const std::string& slotName) const;




    const std::map<std::string, Slot*>& getInputSlots() const;



    const std::map<std::string, Slot*>& getOutputSlots() const;


    const std::map<std::string, AbstractParameter*>& getParameters() const;
    //\}


    virtual void saveParameters(ParameterFile& pf) const;


    virtual void loadParameters(const ParameterFile& pf);


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



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


    virtual void onSave(ParameterFile& pf) const;

    //  \{


    std::set<std::string> getNeighbours() const;


    std::set<std::string> getNeighbours(const ParameterFile& pf) const;


    virtual bool connected() const;


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

    AbstractParameter& getParameter(const std::string & name) const;
    template <typename T>
    void setParameter(std::string name, T value);

    bool isDynamic();
    //  \}
};

charon_DEPRECATED typedef ParameteredObject::template_type template_type;


template <typename T>
class charon_core_PUBLIC TemplatedParameteredObject :
            public ParameteredObject {
public:

    TemplatedParameteredObject(const std::string& className,
        const std::string& name = "", const std::string& doc = "");

    virtual const std::string getTemplateType() const;

    virtual ~TemplatedParameteredObject();
};


#endif // _ParameteredObject_H