Changeset 269 in pacpusframework

Timestamp:

03/13/14 10:41:25 (10 years ago)

Author:

Marek Kurdej

Message:

Major: InputOutputInterface callback method with 1 or 2 arguments: 1st can be const or non-const, second (PacpusEvent) can be optional.

Location:

trunk/include/Pacpus/kernel

Files:

• InputOutputInterface.h (modified) (13 diffs)
• PacpusEvent.h (modified) (3 diffs)

trunk/include/Pacpus/kernel/InputOutputInterface.h

@@ -18 +18 @@
     typedef T data_type;
     typedef C component_type;
-    typedef void (C::*process_data_function_type)(const T &);
-
-    InputInterface(QString name, C * component, process_data_function_type processMethod)
-        : InputInterfaceBase(name, component, component)
-        , method(processMethod)
-    {
+    typedef void (C::*process_data_function_type_with_event)(T&, PacpusEvent);
+    typedef void (C::*process_data_function_type)(T&);
+    typedef void (C::*process_const_data_function_type_with_event)(T const&, PacpusEvent);
+    typedef void (C::*process_const_data_function_type)(T const&);
+
+    InputInterface(QString name, C* component, process_data_function_type_with_event processingMethod)
+        : InputInterfaceBase(name, component, component)
+    {
+        mProcessingMethod.fe = processingMethod;
+    }
+    
+    InputInterface(QString name, C* component, process_data_function_type processingMethod)
+        : InputInterfaceBase(name, component, component)
+    {
+        mProcessingMethod.f = processingMethod;
+    }
+    
+    InputInterface(QString name, C* component, process_const_data_function_type_with_event processingMethod)
+        : InputInterfaceBase(name, component, component)
+    {
+        mProcessingMethod.cfe = processingMethod;
+    }
+    
+    InputInterface(QString name, C* component, process_const_data_function_type processingMethod)
+        : InputInterfaceBase(name, component, component)
+    {
+        mProcessingMethod.cf = processingMethod;
     }
 
@@ -35 +56 @@
     }
 
-    const std::type_info & getDataType() const
+    std::type_info const& getDataType() const
     {
         return typeid(T);
@@ -47 +68 @@
 
     // FIXME: what's the purpose of this function?
-    void customEvent(QEvent * event)
-    {
+    void customEvent(QEvent* event)
+    {
+        static road_timerange_t const kMaximumBoundedTimeRange = 500;
+
+        if (!event) {
+            LOG_WARN("null event");
+            return;
+        }
+        
         // check that component has been started
         if ((NULL == getComponent()) || (!getComponent()->isActive())) {
@@ -57 +85 @@
         LOG_TRACE("Receiver: " << getSignature());
 
-        //PacpusTypedEvent<T> * typedEvent = dynamic_cast<PacpusTypedEvent<T> *>(event);
-        PacpusEvent * pacpusEvent = dynamic_cast<PacpusEvent *>(event);
+        //PacpusTypedEvent<T>* typedEvent = dynamic_cast<PacpusTypedEvent<T> *>(event);
+        PacpusEvent* pacpusEvent = dynamic_cast<PacpusEvent*>(event);
         if (!pacpusEvent) {
             LOG_WARN("dynamic_cast failed: not a PacpusEvent");
             return;
         }
-        PacpusTypedEvent<T> * typedEvent = dynamic_cast<PacpusTypedEvent<T> *>(pacpusEvent);
+        PacpusTypedEvent<T>* typedEvent = dynamic_cast<PacpusTypedEvent<T>*>(pacpusEvent);
         if (!typedEvent) {
             LOG_WARN("dynamic_cast failed: incompatible event types");
@@ -71 +99 @@
         switch (event->type()) {
         case TYPED_EVENT:
-            if (TimeBounded == readingMode() && typedEvent->timerange() < 500) {
-                LOG_WARN("Incorrect TimeRange (0), switch to NeverSkip");
+            if (TimeBounded == readingMode() && typedEvent->timerange() < kMaximumBoundedTimeRange) {
+                LOG_WARN("Incorrect TimeRange (< " << kMaximumBoundedTimeRange << "), switching to NeverSkip mode");
                 readingMode() = NeverSkip;
             }
@@ -83 +111 @@
                 }
 
-                (dynamic_cast<C*>(component())->*method)(typedEvent->data());
+                mProcessingMethod.invoke(component(), typedEvent->data(), *typedEvent);
                 break;
 
             case GetLast:
-                (dynamic_cast<C*>(component())->*method)(typedEvent->data());
+                mProcessingMethod.invoke(component(), typedEvent->data(), *typedEvent);
+
                 // delete all remaining events
                 QCoreApplication::removePostedEvents(this, TYPED_EVENT);
@@ -93 +122 @@
 
             case NeverSkip:
-                (dynamic_cast<C*>(component())->*method)(typedEvent->data());
+                mProcessingMethod.invoke(component(), typedEvent->data(), *typedEvent);
                 break;
 
@@ -111 +140 @@
     }
 
-    // TODO for Pulling mode (not yet implemented !!!)
-    T & getData()
+    // TODO: pull mode (NOT YET IMPLEMENTED!!!)
+    T& getData()
     {
         T data;
-        // TODO ask output data;
+        // TODO: ask the  output data;
         return data;
     }
 
 protected:
-    process_data_function_type method;
+    struct ProcessingMethod
+    {
+        ProcessingMethod()
+        {
+            fe = NULL;
+            f = NULL;
+            cfe = NULL;
+            cf = NULL;
+        }
+
+        void invoke(ComponentBase* component, T& data, PacpusEvent event)
+        {
+            C* comp = dynamic_cast<C*>(component);
+            if (NULL == comp) {
+                LOG_WARN("NULL component");
+                return;
+            }
+            if (fe) {
+                (comp->*fe)(data, event);
+            } else if (f) {
+                (comp->*f)(data);
+            } else if (cfe) {
+                (comp->*cfe)(data, event);
+            } else if (cf) {
+                (comp->*cf)(data);
+            } else {
+                LOG_WARN("no method to invoke");
+            }
+        }
+            
+        process_data_function_type_with_event fe;
+        process_data_function_type f;
+        process_const_data_function_type_with_event cfe;
+        process_const_data_function_type cf;
+    };
+
+    ProcessingMethod mProcessingMethod;
 };
 
@@ -131 +196 @@
     typedef C component_type;
 
-    OutputInterface(QString name, C * component)
+    OutputInterface(QString name, C* component)
         : OutputInterfaceBase(name, component, component)
     {}
@@ -139 +204 @@
 
     /// Send data through a typed output
-    void send(const T & data, road_time_t t = road_time(), road_timerange_t tr = 0);
+    void send(T const& data, road_time_t t = road_time(), road_timerange_t tr = 0);
     
     std::size_t getDataSize() const
@@ -146 +211 @@
     }
 
-    const std::type_info & getDataType() const
+    std::type_info const& getDataType() const
     {
         return typeid(T);
@@ -153 +218 @@
 
 template <typename T, class C>
-void OutputInterface<T, C>::send(const T & data, road_time_t t, road_timerange_t tr)
-{
-    // FIXME Data Shared
+void OutputInterface<T, C>::send(T const& data, road_time_t t, road_timerange_t tr)
+{
+    // FIXME: use shared data
     //QSharedPointer<T> sharedPointer = new T(data);
 
     for (QList<ConnectionBase>::iterator it = connections().begin(), itend = connections().end(); it != itend; ++it) {
-        // Qt documentatino:
+        // Qt documentation:
         //  The event must be allocated on the heap since the post event queue will take ownership of the event and delete it once it has been posted.
         //  It is not safe to access the event after it has been posted.    
-        QEvent * newEvent = new PacpusTypedEvent<T>(TYPED_EVENT, data, t, tr);
+        QEvent* pacpusEvent = new PacpusTypedEvent<T>(TYPED_EVENT, data, t, tr);
         QCoreApplication::postEvent(
             it->getInterface(), 
-            newEvent, 
+            pacpusEvent, 
             it->getPriority()
         );
@@ -173 +238 @@
 
 template <typename T1, typename T2, class C>
-bool checkedSend(OutputInterface<T1, C> * sender, const T2 & data, road_time_t t = road_time(), road_timerange_t tr = 0);
+bool checkedSend(OutputInterface<T1, C>* sender, T2 const& data, road_time_t t = road_time(), road_timerange_t tr = 0);
 
 template <typename T1, typename T2, class C>
-bool checkedSend(OutputInterface<T1, C> * sender, const T2 & data, road_time_t t, road_timerange_t tr)
+bool checkedSend(OutputInterface<T1, C>* sender, T2 const& data, road_time_t t, road_timerange_t tr)
 {
     if (sender && sender->hasConnection()) {

trunk/include/Pacpus/kernel/PacpusEvent.h

@@ -49 +49 @@
     }
 
-    road_time_t & time()
+    road_time_t& time()
     {
         return m_time;
     }
 
-    const road_time_t & time() const
+    road_time_t const& time() const
     {
         return m_time;
     }
 
-    road_timerange_t & timerange()
+    road_timerange_t& timerange()
     {
         return m_timerange;
     }
 
-    const road_timerange_t & timerange() const
+    road_timerange_t const& timerange() const
     {
         return m_timerange;
     }
+
 protected:
     road_time_t m_time;
@@ -121 +122 @@
     /// when T is convertible to S
     template <typename S>
-    PacpusTypedEvent(const PacpusTypedEvent<S> & other)
+    PacpusTypedEvent(PacpusTypedEvent<S> const& other)
         : PacpusEvent(static_cast<PacpusEventType>(other.type()), other.time(), other.timerange())
         , TypedData<T>(other.data())
@@ -146 +147 @@
 {
 public:
-    GenericData(const char * data, size_t size)
+    GenericData(char const* data, size_t size)
         : m_data(NULL)
         , m_dataSize(size)