DeploymentComponent.hpp

/***************************************************************************
  tag: Peter Soetens  Thu Jul 3 15:34:31 CEST 2008  DeploymentComponent.hpp

                        DeploymentComponent.hpp -  description
                           -------------------
    begin                : Thu July 03 2008
    copyright            : (C) 2008 Peter Soetens
    email                : peter.soetens@fmtc.be

 ***************************************************************************
 *   This library 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 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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 this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/


#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>
#include <rtt/marsh/PropertyDemarshaller.hpp>

// Suppress warnings in ocl/ComponentLoader.hpp
#ifndef OCL_STATIC
#define OCL_STATIC
#include <ocl/ComponentLoader.hpp>
#undef OCL_STATIC
#else
#include <ocl/ComponentLoader.hpp>
#endif

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;
        RTT::Property<std::string> target;

        struct ComponentData {
            ComponentData()
                : instance(0), act(0), loaded(false),
                  autostart(false), autoconf(false),
                  autoconnect(false),  autosave(false),
                  proxy(false), server(false),
                  use_naming(true),type(""),
                  configfile("")
            {}
            RTT::TaskContext* instance;
            ActivityInterface* act;
            bool loaded;
            bool autostart, autoconf, autoconnect, autosave;
            bool proxy, server, use_naming;
            std::string type, configfile;
        };

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

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

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

        class LoadedLib{
        public:
            LoadedLib(std::string n, void* h)
            {
                name = n;
                handle = h;
            }
            std::string name;
            void* handle;
            std::vector<std::string> components_type;
        };

        static std::vector< LoadedLib > loadedLibs;

        void* handle;
        std::string libname;

        bool configureHook();

        bool unloadComponentImpl( CompList::iterator cit );


        virtual bool componentLoaded(TaskContext* c);
    public:
        DeploymentComponent(std::string name = "Configurator");

        ~DeploymentComponent();

        TaskContext* myGetPeer(std::string name) {return comps[ name ].instance; }

        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 setMasterSlaveActivity(const std::string& comp_name,
                                    const std::string& master_name);

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

        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 kickOutComponent(const std::string& comp_name);

        void kickOut(const std::string& config_file);

        bool kickOutAll();


        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);

        FactoryMap& getFactories();

        bool stopComponent(RTT::TaskContext *instance);

        bool stopComponent(const std::string& comp_name)
        {
            return this->stopComponent(  this->getPeer(comp_name) );
        }

        bool cleanupComponent(RTT::TaskContext *instance);

        bool cleanupComponent(const std::string& comp_name)
        {
            return this->cleanupComponent( this->getPeer(comp_name) );
        }

    };


}
#endif

---