Merge remote-tracking branch 'origin/master'

Author: DanielsCreation

share/covise/demo/demos.json

@@ -549,7 +549,7 @@
       "description": "",
       "headline": "Magnetgetriebe",
       "id": 74,
-      "image": "",
+      "image": "Magnetgetriebe.png",
       "launch": [
         {
           "args": [
@@ -560,7 +560,7 @@
         }
       ],
       "tags": [
-        "broken"
+        "electromagnetics"
       ]
     },
     {

src/OpenCOVER/CMakeLists.txt

@@ -126,6 +126,7 @@ if (COVISE_USE_VIRVO)
 endif()
 ADD_SUBDIRECTORY(OpenVRUI)
 ADD_SUBDIRECTORY(PluginUtil)
+ADD_SUBDIRECTORY(DataClient)
 ADD_SUBDIRECTORY(OpcUaClient)
 ADD_SUBDIRECTORY(HTTPClient)
 ADD_SUBDIRECTORY(cover)

src/OpenCOVER/DataClient/CMakeLists.txt

@@ -0,0 +1,17 @@
+
+SET(HEADERS
+  DataClient.h
+  MultiDimensionalArray.h
+  ObserverHandle.h
+)
+
+SET(SOURCES
+  DataClient.cpp
+  MultiDimensionalArray.cpp
+  ObserverHandle.cpp
+)
+
+ADD_COVISE_LIBRARY(coDataClient)
+target_link_libraries(coDataClient coOpenCOVER)
+COVISE_INSTALL_TARGET(coDataClient)
+COVISE_INSTALL_HEADERS(coDataClient ${HEADERS})

src/OpenCOVER/DataClient/DataClient.cpp

@@ -0,0 +1,72 @@
+#include "DataClient.h"
+#include <cover/coVRMSController.h>
+
+using namespace opencover::dataclient;
+
+const char *opencover::dataclient::NoNodeName = "None";
+
+void Client::queueUnregisterNode(size_t id)
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_nodesToUnregister.push_back(id);
+}
+
+bool isNumerical(std::type_index t)
+{
+    return t == typeid(int8_t) || t == typeid(uint8_t) || t == typeid(int16_t) || t == typeid(uint16_t) || t == typeid(int32_t) || t == typeid(uint32_t) || t == typeid(double);
+}
+
+std::vector<std::string> Client::allAvailableScalars() const
+{
+    return getNodesWith(false, true);
+}
+
+std::vector<std::string> Client::availableNumericalScalars() const
+{
+    return getNodesWith(true, true);
+}
+
+std::vector<std::string> Client::allAvailableArrays() const
+{
+    return getNodesWith(false, false);
+}
+
+std::vector<std::string> Client::availableNumericalArrays() const
+{
+    return getNodesWith(true, false);
+}
+
+auto msController = opencover::coVRMSController::instance();
+
+Client::StatusChange Client::statusChanged(void* caller)
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    StatusChange retval = Unchanged;
+    if(msController->isMaster())
+    {
+        auto obs = m_statusObservers.find(caller);
+        if(obs == m_statusObservers.end())
+        {
+            obs = m_statusObservers.insert(obs, std::make_pair(caller, false));
+        }
+        if(!obs->second)
+        {
+            obs->second = true;
+            retval = isConnected() ? Connected : Disconnected;
+        }
+    } 
+    msController->syncData(&retval, sizeof(StatusChange));
+    return retval;
+}
+
+void Client::statusChanged()
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    for(auto &obs : m_statusObservers)
+        obs.second = false;
+}
+
+Client** Client::getClientReference(const ObserverHandle &handle)
+{
+    return &handle.m_deleter->m_client;
+}

src/OpenCOVER/DataClient/DataClient.h

@@ -0,0 +1,89 @@
+#ifndef OPENCOVER_DATACLIENT_H
+#define OPENCOVER_DATACLIENT_H
+
+#include "export.h"
+#include "MultiDimensionalArray.h"
+#include "ObserverHandle.h"
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <typeindex>
+#include <typeinfo>
+#include <vector>
+#include <mutex>
+
+namespace opencover { namespace dataclient {
+
+extern DATACLIENTEXPORT const char *NoNodeName;
+
+class DATACLIENTEXPORT Client {
+public:
+    virtual ~Client() = default;
+
+    // Connection lifecycle
+    virtual void connect() = 0;
+    virtual void disconnect() = 0;
+    virtual bool isConnected() const = 0;
+    enum StatusChange{ Unchanged, Connected, Disconnected};
+    StatusChange statusChanged(void* caller);
+
+
+    //get the available data nodes from the server
+    std::vector<std::string> allAvailableScalars() const;
+    std::vector<std::string> availableNumericalScalars() const;
+    template<typename T>
+    std::vector<std::string> availableScalars() const
+    {
+        return getNodesWith(std::type_index(typeid(T)), true);
+    }
+    std::vector<std::string> allAvailableArrays() const;
+    std::vector<std::string> availableNumericalArrays() const;
+    template<typename T>
+    std::vector<std::string> availableArrays() const
+    {
+        return getNodesWith(std::type_index(typeid(T)), false);
+    }
+
+
+    //register nodes to get updates pushed by the server
+    //keep the ObserverHandle as long as you want to observe
+    virtual [[nodiscard]] ObserverHandle observeNode(const std::string &name) = 0;
+
+    // Pull-style access
+    virtual double getNumericScalar(const std::string &name, double *timestep = nullptr) = 0;
+    virtual double getNumericScalar(const ObserverHandle &handle, double *timestep = nullptr) = 0;
+
+    virtual size_t numNodeUpdates(const std::string &name) = 0;
+    template<typename T>
+    MultiDimensionalArray<T> getArray(const std::string &name)
+    {
+        auto p = getArrayImpl(std::type_index(typeid(T)), name);
+        if (!p) return MultiDimensionalArray<T>{};
+        if (auto casted = dynamic_cast<MultiDimensionalArray<T>*>(p.get())) {
+            return *casted; // copies the MultiDimensionalArray<T> contents
+        }
+        return MultiDimensionalArray<T>{};
+    }
+
+    //called by ObserverHandle
+    void queueUnregisterNode(size_t id);
+
+protected:
+    void statusChanged();
+    Client** getClientReference(const ObserverHandle &handle);
+private:
+
+    virtual std::unique_ptr<detail::MultiDimensionalArrayBase> getArrayImpl(std::type_index type, const std::string &name) = 0;
+    virtual std::vector<std::string> getNodesWith(std::type_index type, bool isScalar) const = 0;
+    virtual std::vector<std::string> getNodesWith(bool isArithmetic, bool isScalar) const = 0;
+    std::mutex m_mutex;
+    std::vector<size_t> m_nodesToUnregister;
+    std::map<void*, bool> m_statusObservers; //stores which objects received a changed status
+    bool m_connected = false;
+};
+
+}} // namespace
+
+#endif // OPENCOVER_DATACLIENT_H

src/OpenCOVER/DataClient/MultiDimensionalArray.cpp

@@ -0,0 +1,8 @@
+#include "MultiDimensionalArray.h"
+
+using namespace opencover::dataclient;
+
+bool detail::MultiDimensionalArrayBase::isScalar() const {return dimensions.size() == 1 && dimensions[0] == 1;}
+size_t detail::MultiDimensionalArrayBase::numEntries() const { return std::accumulate(dimensions.begin(), dimensions.end(), size_t(1), std::multiplies<size_t>());}
+bool detail::MultiDimensionalArrayBase::isValid() const {return dimensions.size() > 0;}
+

src/OpenCOVER/DataClient/MultiDimensionalArray.h

@@ -0,0 +1,35 @@
+#ifndef COVER_DATACLIENT_MULTIDIMENSIONALARRAY_H
+#define COVER_DATACLIENT_MULTIDIMENSIONALARRAY_H
+
+#include "export.h"
+#include <numeric>
+#include <cstring>
+#include <vector>
+#include <array>
+
+namespace opencover{namespace dataclient{
+
+namespace detail{
+class DATACLIENTEXPORT MultiDimensionalArrayBase{
+public:
+    virtual ~MultiDimensionalArrayBase() = default;    
+    bool isScalar() const;
+    size_t numEntries() const;
+    bool isValid() const;
+
+    std::vector<size_t> dimensions;
+    double timestamp = 0;
+
+};
+}
+
+template<typename T>
+struct MultiDimensionalArray : public detail::MultiDimensionalArrayBase
+{
+    std::vector<T> data;
+};
+
+
+}}
+
+#endif // COVER_DATACLIENT_MULTIDIMENSIONALARRAY_H

…OpenCOVER/OpcUaClient/observerHandle.cpp …/OpenCOVER/DataClient/ObserverHandle.cppsrc/OpenCOVER/OpcUaClient/observerHandle.cpp renamed to src/OpenCOVER/DataClient/ObserverHandle.cpp src/OpenCOVER/OpcUaClient/observerHandle.cpp renamed to src/OpenCOVER/DataClient/ObserverHandle.cpp

@@ -1,6 +1,7 @@
-#include "observerHandle.h"
-#include "opcuaClient.h"
-using namespace opencover::opcua;
+#include "ObserverHandle.h"
+#include "DataClient.h"
+
+using namespace opencover::dataclient;
 
 ObserverHandle::ObserverHandle(size_t id,  Client *client) : m_deleter(std::make_shared<Deleter>()){
     m_deleter->m_id = id;

…c/OpenCOVER/OpcUaClient/observerHandle.h src/OpenCOVER/DataClient/ObserverHandle.hsrc/OpenCOVER/OpcUaClient/observerHandle.h renamed to src/OpenCOVER/DataClient/ObserverHandle.h src/OpenCOVER/OpcUaClient/observerHandle.h renamed to src/OpenCOVER/DataClient/ObserverHandle.h

@@ -1,15 +1,23 @@
-#ifndef COVER_OPCUA_REGISTER_ID_H
-#define COVER_OPCUA_REGISTER_ID_H
+#ifndef COVER_DATACLIENT_OBSERVERHANDLE_H
+#define COVER_DATACLIENT_OBSERVERHANDLE_H
 
+#include "export.h"
+
+#include <algorithm>
+#include <deque>
+#include <map>
 #include <memory>
+#include <set>
+#include <string>
+#include <vector>
 
-namespace opencover{namespace opcua{
+namespace opencover{namespace dataclient{
 
 class Client;
-class ClientNode;
+
 
 //automativally unobserves the node on deletion
-class ObserverHandle{
+class DATACLIENTEXPORT ObserverHandle{
     public:
         friend class Client;
         ObserverHandle() = default;
@@ -24,9 +32,9 @@ class ObserverHandle{
             Client *m_client = nullptr;
         };
         std::shared_ptr<Deleter> m_deleter;
-        opencover::opcua::ClientNode *m_node = nullptr; 
+        // ClientNode *m_node = nullptr; 
     };
 
 }}
 
-#endif // COVER_OPCUA_REGISTER_ID_H
+#endif // COVER_DATACLIENT_OBSERVERHANDLE_H

src/OpenCOVER/DataClient/export.h

@@ -0,0 +1,12 @@
+#ifndef COVER_DATACLIENT_EXPORT_H
+#define COVER_DATACLIENT_EXPORT_H
+
+#include <util/coExport.h>
+
+#if defined(coDataClient_EXPORTS)
+#define DATACLIENTEXPORT COEXPORT
+#else
+#define DATACLIENTEXPORT COIMPORT
+#endif
+
+#endif // COVER_DATACLIENT_EXPORT_H