Merge pull request #58 from ifm/develop

Version 1.0.9

nexxT/include/nexxT/Logger.hpp

@@ -14,8 +14,8 @@
 #ifndef NEXXT_LOGGER_HPP
 #define NEXXT_LOGGER_HPP
 
-#include "nexxT/Services.hpp"
 #include "nexxT/NexxTLinkage.hpp"
+#include "SharedPointerTypes.hpp"
 #include <QtCore/QMetaObject>
 
 //! @cond Doxygen_Suppress
@@ -71,9 +71,13 @@ namespace nexxT
     class DLLEXPORT Logging
     {
         static unsigned int loglevel;
+        static SharedQObjectPtr loggingService;
         static void _log(unsigned int level, const QString &message, const QString &file, unsigned int line);
     public:
         static void setLogLevel(unsigned int level);
+        /* this function is introduced to avoid having to call getService(...) for every log call. getService(...)
+           acquires a mutex and therefore all functions using logging would be required to allow threads */
+        static void setLoggingService(const SharedQObjectPtr &loggingService);
         static inline void log(unsigned int level, const QString &message, const QString &file, unsigned int line)
         {
             if( level >= loglevel )

nexxT/include/nexxT/Services.hpp

@@ -17,20 +17,12 @@
 #include <QtCore/QSharedPointer>
 
 #include "nexxT/NexxTLinkage.hpp"
+#include "nexxT/SharedPointerTypes.hpp"
 
 namespace nexxT
 {
     struct ServicesD;
 
-    /*!
-        A typedef for a QObject handled by a shared pointer.
-
-        In principle it is not really necessary to use a shared pointer to handle QObjects, because of the parent/child
-        ownership principle. However for consistency, the design decision has been made to also wrap the services in a
-        smart pointer just like datasamples, filters and ports.
-    */
-    typedef QSharedPointer<QObject> SharedQObjectPtr;
-
     /*!
         This class is the C++ variant of \verbatim embed:rst:inline :py:class:`nexxT.interface.Services.Services`
         \endverbatim

nexxT/include/nexxT/SharedPointerTypes.hpp

@@ -3,6 +3,8 @@
 
 #include <QtCore/QSharedPointer>
 
+class QObject;
+
 namespace nexxT
 {
     class Port;
@@ -34,6 +36,15 @@ namespace nexxT
         A typedef for a list of ports.
     */
     typedef QList<QSharedPointer<Port> > PortList;
+
+    /*!
+        A typedef for a QObject handled by a shared pointer.
+
+        In principle it is not really necessary to use a shared pointer to handle QObjects, because of the parent/child
+        ownership principle. However for consistency, the design decision has been made to also wrap the services in a
+        smart pointer just like datasamples, filters and ports.
+    */
+    typedef QSharedPointer<QObject> SharedQObjectPtr;
 }
 
 #endif

nexxT/interface/DataSamples.py

@@ -49,6 +49,10 @@ def getContent(self):
         Get the contents of this sample as a QByteArray. Note that this is an efficient operation due to the copy on
         write semantics of QByteArray. It also asserts that the original contents cannot be modified.
 
+        In C++, make sure to keep an instance of the QByteArray until done with processing. Moreover, consider to use
+        `QByteArray::constData()` for a pointer-to-memory access rather than `QByteArray::data()`, since the latter
+        will eventually make an unnecessary deep copy of the encapsulated data.
+
         :return: QByteArray instance copy
         """
         return QByteArray(self._content)

nexxT/src/Logger.cpp

@@ -12,15 +12,21 @@ using namespace nexxT;
 namespace nexxT
 {
     unsigned int Logging::loglevel;
+    SharedQObjectPtr Logging::loggingService;
 
     void Logging::setLogLevel(unsigned int level)
     {
         loglevel = level;
     }
 
+    void Logging::setLoggingService(const SharedQObjectPtr &service)
+    {
+        loggingService = service;
+    }
+
     void Logging::_log(unsigned int level, const QString &message, const QString &file, unsigned int line)
     { 
-        SharedQObjectPtr logger = Services::getService("Logging");
+        SharedQObjectPtr logger = loggingService;
         if( !logger.isNull() )
         {
             bool res = QMetaObject::invokeMethod(logger.get(), "log", Qt::DirectConnection, Q_ARG(int, level), Q_ARG(const QString &, message), Q_ARG(const QString &, file), Q_ARG(int, line));

nexxT/src/Services.cpp

@@ -68,6 +68,10 @@ void Services::_addService(const QString &name, const SharedQObjectPtr &service)
     {
         NEXXT_LOG_INFO(QString("adding service %1").arg(name));
         d->map[name] = service;
+        if( name == "Logging" )
+        {
+            Logging::setLoggingService(service);
+        }
     }
 }
 
@@ -85,6 +89,10 @@ void Services::_removeService(const QString &name)
             QMetaObject::invokeMethod(d->map[name].data(), "detach", Qt::DirectConnection);
         }
         d->map.remove(name);
+        if( name == "Logging" )
+        {
+            Logging::setLoggingService(SharedQObjectPtr());
+        }
     }
 }
 
@@ -96,6 +104,7 @@ void Services::_removeAll()
     {
         _removeService(key);
     }
+    Logging::setLoggingService(SharedQObjectPtr());
 }
 
 Services *Services::singleton()

nexxT/src/cnexxT.xml

@@ -42,7 +42,7 @@
         <object-type name="InterThreadConnection" allow-thread="true">
         </object-type>
 
-        <object-type name="Services">
+        <object-type name="Services" allow-thread="true">
             <modify-function signature="addService(const QString &amp;,QObject*)">
                 <modify-argument index="2">
                     <define-ownership owner="c++"/>