Add Task.hpp and Task.cpp, which are generated from the specification

Author: 2maz

tasks/Task.cpp

@@ -0,0 +1,55 @@
+/* Generated from orogen/lib/orogen/templates/tasks/Task.cpp */
+
+#include "Task.hpp"
+
+using namespace message_consumer;
+
+Task::Task(std::string const& name, TaskCore::TaskState initial_state)
+    : TaskBase(name, initial_state)
+{
+}
+
+Task::Task(std::string const& name, RTT::ExecutionEngine* engine, TaskCore::TaskState initial_state)
+    : TaskBase(name, engine, initial_state)
+{
+}
+
+Task::~Task()
+{
+}
+
+
+
+/// The following lines are template definitions for the various state machine
+// hooks defined by Orocos::RTT. See Task.hpp for more detailed
+// documentation about them.
+
+// bool Task::configureHook()
+// {
+//     if (! TaskBase::configureHook())
+//         return false;
+//     return true;
+// }
+// bool Task::startHook()
+// {
+//     if (! TaskBase::startHook())
+//         return false;
+//     return true;
+// }
+// void Task::updateHook()
+// {
+//     TaskBase::updateHook();
+// }
+// void Task::errorHook()
+// {
+//     TaskBase::errorHook();
+// }
+// void Task::stopHook()
+// {
+//     TaskBase::stopHook();
+// }
+// void Task::cleanupHook()
+// {
+//     TaskBase::cleanupHook();
+// }
+

tasks/Task.hpp

@@ -0,0 +1,82 @@
+/* Generated from orogen/lib/orogen/templates/tasks/Task.hpp */
+
+#ifndef MESSAGE_CONSUMER_TASK_TASK_HPP
+#define MESSAGE_CONSUMER_TASK_TASK_HPP
+
+#include "message_consumer/TaskBase.hpp"
+
+namespace message_consumer {
+    class Task : public TaskBase
+    {
+	friend class TaskBase;
+    protected:
+
+
+
+    public:
+        Task(std::string const& name = "message_consumer::Task", TaskCore::TaskState initial_state = Stopped);
+        Task(std::string const& name, RTT::ExecutionEngine* engine, TaskCore::TaskState initial_state = Stopped);
+
+	~Task();
+
+        /** This hook is called by Orocos when the state machine transitions
+         * from PreOperational to Stopped. If it returns false, then the
+         * component will stay in PreOperational. Otherwise, it goes into
+         * Stopped.
+         *
+         * It is meaningful only if the #needs_configuration has been specified
+         * in the task context definition with (for example):
+         *
+         *   task_context "TaskName" do
+         *     needs_configuration
+         *     ...
+         *   end
+         */
+        // bool configureHook();
+
+        /** This hook is called by Orocos when the state machine transitions
+         * from Stopped to Running. If it returns false, then the component will
+         * stay in Stopped. Otherwise, it goes into Running and updateHook()
+         * will be called.
+         */
+        // bool startHook();
+
+        /** This hook is called by Orocos when the component is in the Running
+         * state, at each activity step. Here, the activity gives the "ticks"
+         * when the hook should be called.
+         *
+         * The error(), exception() and fatal() calls, when called in this hook,
+         * allow to get into the associated RunTimeError, Exception and
+         * FatalError states. 
+         *
+         * In the first case, updateHook() is still called, and recover() allows
+         * you to go back into the Running state.  In the second case, the
+         * errorHook() will be called instead of updateHook(). In Exception, the
+         * component is stopped and recover() needs to be called before starting
+         * it again. Finally, FatalError cannot be recovered.
+         */
+        // void updateHook();
+
+        /** This hook is called by Orocos when the component is in the
+         * RunTimeError state, at each activity step. See the discussion in
+         * updateHook() about triggering options.
+         *
+         * Call recover() to go back in the Runtime state.
+         */
+        // void errorHook();
+
+        /** This hook is called by Orocos when the state machine transitions
+         * from Running to Stopped after stop() has been called.
+         */
+        // void stopHook();
+
+        /** This hook is called by Orocos when the state machine transitions
+         * from Stopped to PreOperational, requiring the call to configureHook()
+         * before calling start() again.
+         */
+        // void cleanupHook();
+    };
+}
+
+#endif
+