/home/sspr/src/www/orocos-1.0/export/build/orocos-ocl-1.4.0/deployment/DeploymentComponent.hpp

#ifndef OCL_DEPLOYMENTCOMPONENT_HPP
#define OCL_DEPLOYMENTCOMPONENT_HPP

#include <rtt/RTT.hpp>
#include <rtt/TaskContext.hpp>
#include <rtt/Properties.hpp>
#include <rtt/Attribute.hpp>
#include <rtt/Ports.hpp>
#include <ocl/OCL.hpp>
#include <vector>
#include <map>

namespace OCL
{

    class OCL_API DeploymentComponent
        : public RTT::TaskContext
    {
    protected:
        RTT::PropertyBag root;
        RTT::Property<std::string> compPath;
        RTT::Property<bool> autoUnload;
        RTT::Attribute<bool> validConfig;
        RTT::Constant<int> sched_RT;
        RTT::Constant<int> sched_OTHER;
        RTT::Constant<int> lowest_Priority;
        RTT::Constant<int> highest_Priority;

        struct ComponentData {
            ComponentData() 
                : instance(0), act(0), loaded(false),
                  autostart(false), autoconf(false)
            {}
            RTT::TaskContext* instance;
            ActivityInterface* act;
            bool loaded;
            bool autostart, autoconf;
        };

        struct ConnectionData {
            typedef std::vector<RTT::PortInterface*> Ports;
            Ports ports;
        };

        typedef std::map<std::string, ConnectionData> ConMap;
        ConMap conmap;

        typedef std::map<std::string, ComponentData> CompList;
        CompList comps;

        static std::vector<std::pair<std::string,void*> > LoadedLibs;

        void* handle;
        std::string libname;
    public:
        DeploymentComponent(std::string name = "Configurator");
        
        ~DeploymentComponent();

        bool connectPeers(const std::string& one, const std::string& other);

        bool connectPorts(const std::string& one, const std::string& other);

        bool connectPorts(const std::string& one, const std::string& one_port,
                          const std::string& other, const std::string& other_port);

        bool addPeer(const std::string& from, const std::string& to);

        using TaskContext::addPeer;
        using TaskContext::connectPeers;

        bool import(const std::string& path);

        bool loadLibrary(const std::string& name);

        bool loadComponent(const std::string& name, const std::string& type);

        bool unloadComponent(const std::string& name);

        void displayComponentTypes() const;

        bool setPeriodicActivity(const std::string& comp_name, 
                                 double period, int priority,
                                 int scheduler);

        bool setNonPeriodicActivity(const std::string& comp_name, 
                                    int priority,
                                    int scheduler);

        bool setSlaveActivity(const std::string& comp_name, 
                              double period);

        bool setActivity(const std::string& comp_name, 
                         const std::string& act_type, 
                         double period, int priority,
                         int scheduler);

        bool loadComponents(const std::string& config_file);

        bool configureComponents();

        bool startComponents();

        void clearConfiguration();

      bool stopComponents();

      bool cleanupComponents();

      bool unloadComponents();

        bool kickStart(const std::string& file_name);

        bool kickOut();

        using TaskCore::configure;

        bool configure(const std::string& name);

        bool configureFromFile(const std::string& name, const std::string& filename);

        bool loadConfiguration(const std::string& config_file);

        bool loadConfigurationString(const std::string& config_text);

    };


}
#endif

---