[DynamicJSONRPCErrorMessage] add to examples (#845)

* [DynamicJSONRPCErrorMessage] add to examples

* [examples] improved dynamic jsonrpc errormessage example

* [examples] show use of errorcode for dynamic jsonrpc errormessages

examples/CMakeLists.txt

@@ -36,6 +36,7 @@ option(EXAMPLE_MESSAGECONTROL_UDP_CLIENT "Include UDP output client for message
 option(EXAMPLE_DYNAMICLOADING "Include dynamic loading examples" OFF)
 option(EXAMPLE_SIMPLECOMRPC_TEST "Include Simple COMRPC test client" OFF)
 option(EXAMPLE_PLUGINSMARTINTERFACETYPE_EXAMPLE "Include PluginSmartInterfaceType examples" OFF)
+option(EXAMPLE_DYNAMICJSONRPCERRORMESSAGE_EXAMPLE "Include DynamicJSONRPCErrorMessage example" OFF)
 
 if(EXAMPLE_COMRPCCLIENT)
     add_subdirectory(COMRPCClient)
@@ -87,3 +88,8 @@ if (EXAMPLE_SIMPLECOMRPC_TEST)
     add_subdirectory(SimpleCOMRPC/PluginServer)
     add_subdirectory(SimpleCOMRPC/Client)
 endif()
+
+if (EXAMPLE_DYNAMICJSONRPCERRORMESSAGE_EXAMPLE)
+    add_subdirectory(DynamicJSONRPCErrorMessage)
+endif()
+

examples/DynamicJSONRPCErrorMessage/CMakeLists.txt

@@ -0,0 +1,56 @@
+# If not stated otherwise in this file or this component's LICENSE file the
+# following copyright and licenses apply:
+#
+# Copyright 2022 Metrological
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+project(DynamicJSONRPCErrorMessage)
+
+cmake_minimum_required(VERSION 3.15)
+
+find_package(Thunder)
+
+project_version(1.0.0)
+
+set(MODULE_NAME ${NAMESPACE}${PROJECT_NAME})
+
+message("Setup ${MODULE_NAME} v${PROJECT_VERSION}")
+
+find_package(${NAMESPACE}Core REQUIRED)
+find_package(${NAMESPACE}Plugins REQUIRED)
+find_package(${NAMESPACE}Definitions REQUIRED)
+find_package(${NAMESPACE}Messaging REQUIRED)
+find_package(CompileSettingsDebug REQUIRED)
+
+add_library(${MODULE_NAME} SHARED
+    DynamicJSONRPCErrorMessage.cpp
+    Module.cpp)
+
+set_target_properties(${MODULE_NAME} PROPERTIES
+    CXX_STANDARD 11
+    CXX_STANDARD_REQUIRED YES)
+
+target_link_libraries(${MODULE_NAME}
+    PRIVATE
+        ${NAMESPACE}Core::${NAMESPACE}Core
+        ${NAMESPACE}Plugins::${NAMESPACE}Plugins
+        ${NAMESPACE}Definitions::${NAMESPACE}Definitions
+        ${NAMESPACE}Messaging::${NAMESPACE}Messaging
+        CompileSettingsDebug::CompileSettingsDebug
+        ${PLUGIN_YIN_DEFINITIONS})
+
+install(TARGETS ${MODULE_NAME} 
+DESTINATION ${CMAKE_INSTALL_LIBDIR}/${STORAGE_DIRECTORY}/plugins COMPONENT ${NAMESPACE}_Runtime)
+
+write_config()

examples/DynamicJSONRPCErrorMessage/DynamicJSONRPCErrorMessage.conf.in

@@ -0,0 +1,3 @@
+startmode = "Activated"
+
+

examples/DynamicJSONRPCErrorMessage/DynamicJSONRPCErrorMessage.cpp

@@ -0,0 +1,87 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2022 Metrological
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Module.h"
+
+#include "DynamicJSONRPCErrorMessage.h"
+#include <interfaces/json/JMath.h>
+
+#include <sstream>
+
+namespace Thunder {
+
+namespace Plugin {
+
+    namespace {
+        static Metadata<DynamicJSONRPCErrorMessage> metadata(
+            // Version
+            1, 0, 0,
+            // Preconditions
+            { },
+            // Terminations
+            { },
+            // Controls
+            { }
+        );
+    }
+
+    const string DynamicJSONRPCErrorMessage::Initialize(PluginHost::IShell*)
+    {
+        string message{};
+
+        Exchange::JMath::Register(*this, this);
+
+        return (message);
+    }
+
+    void DynamicJSONRPCErrorMessage::Deinitialize(PluginHost::IShell* service VARIABLE_IS_NOT_USED)
+    {
+        Exchange::JMath::Unregister(*this);
+    }
+
+    string DynamicJSONRPCErrorMessage::Information() const
+    {
+        return {};
+    }
+
+    uint32_t DynamicJSONRPCErrorMessage::OnJSONRPCError(const Core::JSONRPC::Context&, const string& method, const string& parameters, const uint32_t errorcode, string& errormessage) {
+        if((method == _T("add")) && (errorcode == Core::ERROR_GENERAL) ) {
+            JsonData::Math::AddParamsInfo addparams;
+            addparams.FromString(parameters);
+            std::stringstream message;
+            message <<_T("Error handling add method failed for general reason, values: ") << addparams.A << _T(" and ") << addparams.B;
+            errormessage = message.str();
+        } 
+        return errorcode; // one could change/override the errorcode returned by COMRPC but that would not be advised as might be obvious
+    }
+
+    uint32_t DynamicJSONRPCErrorMessage::OnJSONRPCErrorMethod(const Core::JSONRPC::Context&, const string& method, const string& parameters, const uint32_t errorcode, string& errormessage) {
+        if((method == _T("add")) && (errorcode == Core::ERROR_GENERAL) ) {
+            JsonData::Math::AddParamsInfo addparams;
+            addparams.FromString(parameters);
+            std::stringstream message;
+            message <<_T("Error handling (method version) add method failed for general reason, values: ") << addparams.A << _T(" and ") << addparams.B;
+            errormessage = message.str();
+        } 
+        return errorcode; // one could change/override the errorcode returned by COMRPC but that would not be advised as might be obvious
+    }
+
+} // namespace Plugin
+
+}

examples/DynamicJSONRPCErrorMessage/DynamicJSONRPCErrorMessage.h

@@ -0,0 +1,96 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2022 Metrological
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "Module.h"
+
+#include <interfaces/IMath.h>
+
+namespace Thunder {
+
+namespace Plugin {
+
+
+// some examples:
+// use 2nd line to call a simple (static) funtion
+// use 3rd line to call a more complex function (lamda, bind())
+// use 4th line to have the normal errorhandling
+// of course enable the correct accompanying line/part in the c'tor
+
+    class DynamicJSONRPCErrorMessage : public PluginHost::IPlugin
+                                     , public PluginHost::JSONRPCErrorAssessor<PluginHost::JSONRPCErrorAssessorTypes::FunctionCallbackType>
+//                                     , public PluginHost::JSONRPCErrorAssessor<PluginHost::JSONRPCErrorAssessorTypes::StdFunctionCallbackType>
+//                                     , public PluginHost::JSONRPC
+                                     , public Exchange::IMath {
+
+    public:
+        DynamicJSONRPCErrorMessage() 
+            : PluginHost::IPlugin()
+            , PluginHost::JSONRPCErrorAssessor<PluginHost::JSONRPCErrorAssessorTypes::FunctionCallbackType>(DynamicJSONRPCErrorMessage::OnJSONRPCError)
+/*            , PluginHost::JSONRPCErrorAssessor<PluginHost::JSONRPCErrorAssessorTypes::StdFunctionCallbackType>([this](const Core::JSONRPC::Context& context, const string& method, const string& params, const uint32_t errorcode, string& result) -> uint32_t
+            {
+                return OnJSONRPCErrorMethod(context, method, params, errorcode, result);
+            }) */
+//            , PluginHost::JSONRPC()
+            , Exchange::IMath() 
+        {
+        }
+        ~DynamicJSONRPCErrorMessage() override = default;
+
+        DynamicJSONRPCErrorMessage(const DynamicJSONRPCErrorMessage&) = delete;
+        DynamicJSONRPCErrorMessage &operator=(const DynamicJSONRPCErrorMessage&) = delete;
+        DynamicJSONRPCErrorMessage(DynamicJSONRPCErrorMessage&&) = delete;
+        DynamicJSONRPCErrorMessage &operator=(DynamicJSONRPCErrorMessage&&) = delete;
+
+    public:
+        // PluginHost::IPlugin overrides
+        const string Initialize(PluginHost::IShell *service) override;
+        void Deinitialize(PluginHost::IShell *service) override;
+        string Information() const override;
+
+        // IMath overrides
+        uint32_t Add(const uint16_t a, const uint16_t b , uint16_t&) const override {
+            uint32_t result = Core::ERROR_NOT_SUPPORTED;
+            if( a + b == 4 ) {
+                result = Core::ERROR_GENERAL;
+            }
+            return result;
+        };
+
+        uint32_t Sub(const uint16_t a, const uint16_t b, uint16_t& result) const override {
+            result = a - b;
+            return Core::ERROR_NONE;
+        }
+
+        uint32_t OnJSONRPCErrorMethod(const Core::JSONRPC::Context& context, const string& method, const string& parameters, const uint32_t errorcode, string& errormessage);
+        static uint32_t OnJSONRPCError(const Core::JSONRPC::Context& context, const string& method, const string& parameters, const uint32_t errorcode, string& errormessage);
+
+    public:
+        BEGIN_INTERFACE_MAP(DynamicJSONRPCErrorMessage)
+            INTERFACE_ENTRY(PluginHost::IPlugin)
+            INTERFACE_ENTRY(PluginHost::IDispatcher)
+            INTERFACE_ENTRY(Exchange::IMath)
+        END_INTERFACE_MAP
+
+    }; // class DynamicJSONRPCErrorMessage
+
+} // namespace Plugin
+
+}

examples/DynamicJSONRPCErrorMessage/DynamicJSONRPCErrorMessagePlugin.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "plugin.schema.json",
+  "info": {
+    "title": "DynamicJSONRPCErrorMessage Plugin",
+    "callsign": "DynamicJSONRPCErrorMessage",
+    "locator": "libThunderDynamicJSONRPCErrorMessage.so",
+    "status": "alpha",
+    "version": "1.0"
+  },
+  "interface": {
+    "$ref": "{cppinterfacedir}/IMath.h"
+  }
+}

examples/DynamicJSONRPCErrorMessage/Module.cpp

@@ -0,0 +1,22 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2022 Metrological
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Module.h"
+
+MODULE_NAME_DECLARATION(BUILD_REFERENCE)

examples/DynamicJSONRPCErrorMessage/Module.h

@@ -0,0 +1,30 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2022 Metrological
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#ifndef MODULE_NAME
+#define MODULE_NAME Plugin_DynamicJSONRPCErrorMessage
+#endif
+
+#include <core/core.h>
+#include <plugins/plugins.h>
+
+#undef EXTERNAL
+#define EXTERNAL