OpcUa/ServerClientInteraction

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------


#include <iostream>
#include <memory>
#include <locale>
#include <codecvt>
#include <thread>

#include <cvb/opcua/server.hpp>
#include <cvb/opcua/client.hpp>

#if defined _WIN32 && defined(UNICODE)
#define STDOUT std::wcout
#else
#define STDOUT std::cout
#endif

int main(int, char*[])
{
  try
  {
    // shared between server and client
    bool started = false;
    bool stopped = false;
    auto nodeName = CVB_LIT("TestFloatNode");
    std::thread th; // server thread

    // setup a server
    auto server = [&]()
    {
      try
      {
        // create actual server object
        auto server = Cvb::OpcUa::Server::Create(4840);

        // add a custom namespace (these are used for filtering/sorting data, but are optional, Namespace "0" always exists).
        auto nsIndex = server->AddNameSpace("My Custom Namespace");

        // create a nodeId to the "objects" folder, this folder exists/should exist in all server implementations.
        auto root = Cvb::OpcUa::NodeID::Create(Cvb::OpcUa::Namespace0NodeID::OBJECTSFOLDER);
        // create a nodeId of a "folder" type. This is needed to create a folder.
        auto type = Cvb::OpcUa::NodeID::Create(Cvb::OpcUa::Namespace0NodeID::FOLDERTYPE);
        // create a folder node with the previous namespace and nodeId.
        auto folder = Cvb::OpcUa::ObjectNode::CreateFromType(nsIndex, "My Custom Folder", *root, *type);
        // add the node
        server->AddNode(*folder);

        // create a "float" node.
        auto node = Cvb::OpcUa::FloatNode::Create(nsIndex, nodeName, *folder->NodeID(), 5.5);

        // add the float node.
        server->AddNode(*node);

        // register a callback to the float node.
        auto callbackCookieWrite = node->RegisterWriteCallback([&node]()
        {
          STDOUT << CVB_LIT("write to ") << node->DisplayName() << std::endl;
        });

        // start the server
        server->Start();

        // this simply tells the client thread that the server is ready and can be connected on.
        started = true;

        // wait until end of the test.
        while (!stopped)
          std::this_thread::sleep_for(std::chrono::milliseconds(100));

        // stop the server.
        server->Stop();

        // unregister the callback.
        node->UnregisterCallback(callbackCookieWrite);
      }
      catch (Cvb::OpcUa::OpcUaException e1)
      {
        started = true; // to ignore waiting
        stopped = true;
        std::cout << e1.what() << std::endl;
      }
      catch (const std::exception & ex)
      {
        started = true; // to ignore waiting
        stopped = true;
        std::cout << ex.what() << std::endl;
      }

    };
    // start server
    th = std::thread(server);

    // wait until server is ready
    while (!started)
      std::this_thread::sleep_for(std::chrono::milliseconds(3));

    if (stopped)
      throw std::runtime_error("server creation failed");

    try
    {
      // create and connect client (client stops/disconnects at the end of its livetime, hence the extra scope)
      auto client = Cvb::OpcUa::Client::Create(CVB_LIT("opc.tcp://127.0.0.1:4840"));

      // get server objectsfolder nodeid
      auto obj = client->Node(*Cvb::OpcUa::NodeID::Create(Cvb::OpcUa::Namespace0NodeID::OBJECTSFOLDER));

      // defining our browsefilter
      auto bf = Cvb::OpcUa::BrowseFilter::Create();
      // apply the browsefilter. the result is a vector of nodeIds.
      auto result = obj->Browse(*bf);

      // iterate results
      for (const auto & element : result)
      {
        // get generic node (and node properties)
        auto node = client->Node<Cvb::OpcUa::BaseNode>(*element);

        // print node displayname and expandedtext (nodeid/namespace)
        auto name = node->DisplayName();
        auto ns = node->NodeID()->ExpandedText();
        std::cout << ns << " " << name << std::endl;

        // read and write the value of all FloatNodes
        if (node->NodeClass() == Cvb::OpcUa::NodeClass::Variable)
        {
          // get the node again as a variable node (this way we can get a specific type extracted)
          auto vnode = client->Node<Cvb::OpcUa::VariableNode>(*element);
          if (vnode->DataType() == Cvb::OpcUa::DataType::Double || vnode->DataType() == Cvb::OpcUa::DataType::Float)
          {
            // now get the node a float
            auto fnode = client->Node<Cvb::OpcUa::FloatNode>(*element);

            // read -> write -> read
            auto tmp = fnode->Value();
            std::cout << "node value before change " << tmp << std::endl;
            fnode->SetValue(tmp + 1.1);
            std::cout << "node value after change" << fnode->Value() << std::endl;
          }
        }
      }
      // the end of the scope will disconnect the client from the server

      // stop the server
      stopped = true;
    }
    catch (Cvb::OpcUa::OpcUaException e1)
    {
      std::cout << "client: " << e1.what() << std::endl;
      stopped = true;
    }
    catch (const std::exception & ex)
    {
      std::cout << "client: " << ex.what() << std::endl;
      stopped = true;
    }
    th.join();
  }
  catch (Cvb::OpcUa::OpcUaException e1)
  {
    std::cout << e1.what() << std::endl;
    return e1.ErrorCode();
  }
  catch (const std::exception & ex)
  {
    std::cout << ex.what() << std::endl;
    return -1;
  }
  return 0;
}