demo version

demo/camera_client/dependencies/libvisiontransfer/visiontransfer/deviceparameters.cpp

@@ -0,0 +1,261 @@
+/*******************************************************************************
+ * Copyright (c) 2021 Nerian Vision GmbH
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *******************************************************************************/
+
+#include "visiontransfer/deviceparameters.h"
+#include "visiontransfer/parametertransfer.h"
+#include "visiontransfer/exceptions.h"
+#include "visiontransfer/common.h"
+
+using namespace visiontransfer;
+using namespace visiontransfer::internal;
+
+namespace visiontransfer {
+
+/*************** Pimpl class containing all private members ***********/
+
+class DeviceParameters::Pimpl {
+public:
+    Pimpl(const DeviceInfo& device);
+    Pimpl(const char* address, const char* service);
+
+    int readIntParameter(int id);
+    double readDoubleParameter(int id);
+    bool readBoolParameter(int id);
+
+    void writeIntParameter(int id, int value);
+    void writeDoubleParameter(int id, double value);
+    void writeBoolParameter(int id, bool value);
+
+    std::map<std::string, ParameterInfo> getAllParameters();
+    
+    // this template is selected for non-floating point arguments (i.e. int and bool).
+    template<typename T>
+    void setParameter_impl(StandardParameterIDs::ParameterID id, ParameterInfo::ParameterType type, T value, ...)
+    {
+        int cid = static_cast<int>(id);
+        switch (type) {
+            case ParameterInfo::TYPE_INT: {
+                    writeIntParameter(cid, static_cast<int>(value));
+                    break;
+                }
+            case ParameterInfo::TYPE_BOOL: {
+                    writeBoolParameter(cid, value != 0);
+                    break;
+                }
+            case ParameterInfo::TYPE_DOUBLE: {
+                    writeDoubleParameter(cid, static_cast<double>(value));
+                    break;
+                }
+        }
+    }
+
+    // this template is selected for floating point arguments
+    template<typename T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
+    void setParameter_impl(StandardParameterIDs::ParameterID id, ParameterInfo::ParameterType type, T value, double)
+    {
+        int cid = static_cast<int>(id);
+        switch (type) {
+            case ParameterInfo::TYPE_DOUBLE: {
+                    writeDoubleParameter(cid, value);
+                    break;
+                }
+            case ParameterInfo::TYPE_INT: {
+                    writeIntParameter(cid, static_cast<int>(value));
+                    break;
+                }
+            case ParameterInfo::TYPE_BOOL: {
+                    writeBoolParameter(cid, value != 0);
+                    break;
+                }
+        }
+    }
+
+    template <typename T>
+    void setParameter(StandardParameterIDs::ParameterID id, ParameterInfo::ParameterType type, T t) {
+        setParameter_impl<T>(id, type, t, double{});
+    }
+
+    ParameterInfo getParameter(const std::string& name);
+
+    void lookupIDAndType(const std::string& name, internal::StandardParameterIDs::ParameterID& id, ParameterInfo::ParameterType& type);
+
+private:
+    std::map<std::string, ParameterInfo> serverSideEnumeration;
+
+    std::map<std::string, ParameterInfo> getAllParametersInternal();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+    template<typename T>
+    void setNamedParameterInternal(const std::string& name, T value);
+#endif
+
+    ParameterTransfer paramTrans;
+};
+
+/******************** Stubs for all public members ********************/
+
+DeviceParameters::DeviceParameters(const DeviceInfo& device):
+    pimpl(new Pimpl(device)) {
+    // All initialization in the pimpl class
+}
+
+DeviceParameters::DeviceParameters(const char* address, const char* service):
+    pimpl(new Pimpl(address, service)) {
+    // All initialization in the pimpl class
+}
+
+DeviceParameters::~DeviceParameters() {
+    delete pimpl;
+}
+
+int DeviceParameters::readIntParameter(int id) {
+    return pimpl->readIntParameter(id);
+}
+
+double DeviceParameters::readDoubleParameter(int id) {
+    return pimpl->readDoubleParameter(id);
+}
+
+bool DeviceParameters::readBoolParameter(int id) {
+    return pimpl->readBoolParameter(id);
+}
+
+void DeviceParameters::writeIntParameter(int id, int value) {
+    pimpl->writeIntParameter(id, value);
+}
+
+void DeviceParameters::writeDoubleParameter(int id, double value) {
+    pimpl->writeDoubleParameter(id, value);
+}
+
+void DeviceParameters::writeBoolParameter(int id, bool value) {
+    pimpl->writeBoolParameter(id, value);
+}
+
+void DeviceParameters::Pimpl::lookupIDAndType(const std::string& name, StandardParameterIDs::ParameterID& id, ParameterInfo::ParameterType& type) {
+    if (serverSideEnumeration.size() == 0) {
+        // get the server-side parameter list first (which reports the types as well)
+        (void) getAllParameters();
+    }
+    id = StandardParameterIDs::getParameterIDForName(name);
+    if (id == StandardParameterIDs::ParameterID::UNDEFINED) {
+        ParameterException ex("Cannot access parameter with unknown name: " + name);
+        throw ex;
+    }
+    auto it = serverSideEnumeration.find(name);
+    if (it == serverSideEnumeration.end()) {
+        ParameterException ex("Server did not report the parameter in the supported list: " + name);
+        throw ex;
+    }
+    type = it->second.getType();
+}
+
+std::map<std::string, ParameterInfo> DeviceParameters::getAllParameters()
+{
+    return pimpl->getAllParameters();
+}
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template<>
+void VT_EXPORT DeviceParameters::setNamedParameter(const std::string& name, double value) {
+    StandardParameterIDs::ParameterID id;
+    ParameterInfo::ParameterType type;
+    pimpl->lookupIDAndType(name, id, type);
+    pimpl->setParameter<double>(id, type, value);
+}
+template<>
+void VT_EXPORT DeviceParameters::setNamedParameter(const std::string& name, int value) {
+    StandardParameterIDs::ParameterID id;
+    ParameterInfo::ParameterType type;
+    pimpl->lookupIDAndType(name, id, type);
+    pimpl->setParameter<int>(id, type, value);
+}
+template<>
+void VT_EXPORT DeviceParameters::setNamedParameter(const std::string& name, bool value) {
+    StandardParameterIDs::ParameterID id;
+    ParameterInfo::ParameterType type;
+    pimpl->lookupIDAndType(name, id, type);
+    pimpl->setParameter<bool>(id, type, value);
+}
+
+template<>
+int VT_EXPORT DeviceParameters::getNamedParameter(const std::string& name) {
+    StandardParameterIDs::ParameterID id;
+    ParameterInfo::ParameterType type;
+    pimpl->lookupIDAndType(name, id, type);
+    return pimpl->getParameter(name).getValue<int>();
+}
+template<>
+double VT_EXPORT DeviceParameters::getNamedParameter(const std::string& name) {
+    StandardParameterIDs::ParameterID id;
+    ParameterInfo::ParameterType type;
+    pimpl->lookupIDAndType(name, id, type);
+    return pimpl->getParameter(name).getValue<double>();
+}
+template<>
+bool VT_EXPORT DeviceParameters::getNamedParameter(const std::string& name) {
+    StandardParameterIDs::ParameterID id;
+    ParameterInfo::ParameterType type;
+    pimpl->lookupIDAndType(name, id, type);
+    return pimpl->getParameter(name).getValue<bool>();
+}
+#endif
+
+/******************** Implementation in pimpl class *******************/
+
+DeviceParameters::Pimpl::Pimpl(const char* address, const char* service)
+    : paramTrans(address, service) {
+}
+
+DeviceParameters::Pimpl::Pimpl(const DeviceInfo& device)
+    : paramTrans(device.getIpAddress().c_str(), "7683") {
+}
+
+int DeviceParameters::Pimpl::readIntParameter(int id) {
+    return paramTrans.readIntParameter(id);
+}
+
+double DeviceParameters::Pimpl::readDoubleParameter(int id) {
+    return paramTrans.readDoubleParameter(id);
+}
+
+bool DeviceParameters::Pimpl::readBoolParameter(int id) {
+    return paramTrans.readBoolParameter(id);
+}
+
+void DeviceParameters::Pimpl::writeIntParameter(int id, int value) {
+    paramTrans.writeIntParameter(id, value);
+}
+
+void DeviceParameters::Pimpl::writeDoubleParameter(int id, double value) {
+    paramTrans.writeDoubleParameter(id, value);
+}
+
+void DeviceParameters::Pimpl::writeBoolParameter(int id, bool value) {
+    paramTrans.writeBoolParameter(id, value);
+}
+
+std::map<std::string, ParameterInfo> DeviceParameters::Pimpl::getAllParameters() {
+    serverSideEnumeration = paramTrans.getAllParameters();
+    return serverSideEnumeration;
+}
+
+
+ParameterInfo DeviceParameters::Pimpl::getParameter(const std::string& name)
+{
+    return serverSideEnumeration[name];
+}
+
+} // namespace
+