opcua_options.cpp

Go to the documentation of this file.

#include "opcua_options.h"

#include <opc/ua/protocol/string_utils.h>

#include <boost/program_options/options_description.hpp>
#include <boost/program_options/parsers.hpp>
#include <boost/program_options/variables_map.hpp>
#include <iostream>

#ifndef CONFIG_PATH
#define CONFIG_PATH "/etc/opcua/client"
#endif

namespace
{
namespace po = boost::program_options;
using namespace OpcUa;

const char * OPTION_HELP = "help";
const char * OPTION_GET_ENDPOINTS = "get-endpoints";
const char * OPTION_BROWSE = "browse";
const char * OPTION_READ = "read";
const char * OPTION_WRITE = "write";
const char * OPTION_CREATE_SUBSCRIPTION = "create-subscription";
const char * OPTION_FIND_ServerS = "find-servers";
const char * OPTION_REGISTER_MODULE = "register-module";
const char * OPTION_UNREGISTER_MODULE = "unregister-module";

const char * OPTION_MODULE_Id = "id";
const char * OPTION_MODULE_PATH = "path";
const char * OPTION_CONFIG_DIR = "config-dir";

const char * OPTION_Server_URI = "uri";
const char * OPTION_ATTRIBUTE = "attribute";
const char * OPTION_NODE_Id = "node-id";


const char * OPTION_VALUE_BYTE  = "value-byte";
const char * OPTION_VALUE_SBYTE = "value-sbyte";
const char * OPTION_VALUE_UINT16 = "value-uint16";
const char * OPTION_VALUE_INT16 = "value-int16";
const char * OPTION_VALUE_UINT32 = "value-uint32";
const char * OPTION_VALUE_INT32 = "value-int32";
const char * OPTION_VALUE_UINT64 = "value-uint64";
const char * OPTION_VALUE_INT64 = "value-int64";
const char * OPTION_VALUE_FLOAT = "value-float";
const char * OPTION_VALUE_DOUBLE = "value-double";
const char * OPTION_VALUE_STRING = "value-string";

// codegen
#include "opcua_options_attribute_ids.h"

NodeId GetNodeIdOptionValue(const po::variables_map & vm)
{
  const std::string & value = vm[OPTION_NODE_Id].as<std::string>();
  return OpcUa::ToNodeId(value);
}

Variant GetOptionValue(const po::variables_map & vm)
{
  if (vm.count(OPTION_VALUE_BYTE))
    {
      return Variant(vm[OPTION_VALUE_BYTE].as<uint8_t>());
    }

  if (vm.count(OPTION_VALUE_SBYTE))
    {
      return Variant(vm[OPTION_VALUE_SBYTE].as<int8_t>());
    }

  if (vm.count(OPTION_VALUE_UINT16))
    {
      return Variant(vm[OPTION_VALUE_UINT16].as<uint16_t>());
    }

  if (vm.count(OPTION_VALUE_INT16))
    {
      return Variant(vm[OPTION_VALUE_INT16].as<int16_t>());
    }

  if (vm.count(OPTION_VALUE_UINT32))
    {
      return Variant(vm[OPTION_VALUE_UINT32].as<uint32_t>());
    }

  if (vm.count(OPTION_VALUE_INT32))
    {
      return Variant(vm[OPTION_VALUE_INT32].as<int32_t>());
    }

  if (vm.count(OPTION_VALUE_UINT64))
    {
      return Variant(vm[OPTION_VALUE_UINT64].as<uint64_t>());
    }

  if (vm.count(OPTION_VALUE_INT64))
    {
      return Variant(vm[OPTION_VALUE_INT64].as<int64_t>());
    }

  if (vm.count(OPTION_VALUE_FLOAT))
    {
      return Variant(vm[OPTION_VALUE_FLOAT].as<float>());
    }

  if (vm.count(OPTION_VALUE_DOUBLE))
    {
      return Variant(vm[OPTION_VALUE_DOUBLE].as<double>());
    }

  if (vm.count(OPTION_VALUE_STRING))
    {
      return Variant(vm[OPTION_VALUE_STRING].as<std::string>());
    }

  return Variant();
}

}


namespace OpcUa
{

CommandLine::CommandLine(int argc, char ** argv)
  : NamespaceIndex(0)
  , Attribute(AttributeId::Unknown)
  , IsHelp(false)
  , IsGetEndpoints(false)
  , IsBrowse(false)
  , IsRead(false)
  , IsWrite(false)
  , IsCreateSubscription(false)
  , IsFindServers(false)
  , IsAddModule(false)
  , IsRemoveModule(false)
{
  // Declare the supported options.
  po::options_description desc("Parameters");
  desc.add_options()
  (OPTION_HELP, "produce help message")
  (OPTION_GET_ENDPOINTS, "List endpoints endpoints.")
  (OPTION_BROWSE, "browse command.")
  (OPTION_READ, "read command.")
  (OPTION_WRITE, "write command.")
  (OPTION_CREATE_SUBSCRIPTION, "create subscription command.")
  (OPTION_FIND_ServerS, "find servers command.")
  (OPTION_REGISTER_MODULE, "Register new module.")
  (OPTION_UNREGISTER_MODULE, "Unregister module.")

  (OPTION_Server_URI, po::value<std::string>(), "Uri of the server.")
  (OPTION_ATTRIBUTE, po::value<std::string>(), "Name of attribute.")
  (OPTION_NODE_Id, po::value<std::string>(), "NodeId in the form 'nsu=uri;srv=1;ns=0;i=84.")
  (OPTION_VALUE_BYTE, po::value<uint8_t>(), "Byte value.")
  (OPTION_VALUE_SBYTE, po::value<int8_t>(), "Signed byte value.")
  (OPTION_VALUE_UINT16, po::value<uint16_t>(), "UInt16 value.")
  (OPTION_VALUE_INT16, po::value<int16_t>(), "Int16 value.")
  (OPTION_VALUE_UINT32, po::value<uint32_t>(), "UInt32 value.")
  (OPTION_VALUE_INT32, po::value<int32_t>(), "Int32 value.")
  (OPTION_VALUE_UINT64, po::value<uint64_t>(), "UInt64 value.")
  (OPTION_VALUE_INT64, po::value<int64_t>(), "Int64 value.")
  (OPTION_VALUE_FLOAT, po::value<float>(), "Float value.")
  (OPTION_VALUE_DOUBLE, po::value<double>(), "Double value.")
  (OPTION_VALUE_STRING, po::value<std::string>(), "String value.")
  (OPTION_MODULE_Id, po::value<std::string>(), "Id of the new module.")
  (OPTION_MODULE_PATH, po::value<std::string>(), "Path to the new module shared library.")
  (OPTION_CONFIG_DIR, po::value<std::string>(), "Path to the directory with modules configuration files. By default '" CONFIG_PATH "'.");


  po::variables_map vm;
  po::store(po::parse_command_line(argc, argv, desc), vm);
  po::notify(vm);

  if (vm.count(OPTION_HELP))
    {
      IsHelp = true;
      desc.print(std::cout);
      return;
    }

  if (vm.count(OPTION_Server_URI))
    {
      ServerURI = vm[OPTION_Server_URI].as<std::string>();
    }


  if (vm.count(OPTION_NODE_Id))
    {
      Node = GetNodeIdOptionValue(vm);
    }

  if (vm.count(OPTION_ATTRIBUTE))
    {
      Attribute = GetAttributeIdOptionValue(vm);
    }

  Value = GetOptionValue(vm);
  IsGetEndpoints = vm.count(OPTION_GET_ENDPOINTS) != 0;
  IsBrowse = vm.count(OPTION_BROWSE) != 0;
  IsRead = vm.count(OPTION_READ) != 0;
  IsWrite = vm.count(OPTION_WRITE) != 0;
  IsCreateSubscription = vm.count(OPTION_CREATE_SUBSCRIPTION) != 0;
  IsFindServers = vm.count(OPTION_FIND_ServerS) != 0;

  if (vm.count(OPTION_REGISTER_MODULE))
    {
      IsAddModule = true;
      ModulePath = vm[OPTION_MODULE_PATH].as<std::string>();
      ModuleId = vm[OPTION_MODULE_Id].as<std::string>();
    }

  if (vm.count(OPTION_UNREGISTER_MODULE))
    {
      IsRemoveModule = true;
      ModuleId = vm[OPTION_MODULE_Id].as<std::string>();
    }

  if (vm.count(OPTION_CONFIG_DIR))
    {
      ConfigDir = vm[OPTION_CONFIG_DIR].as<std::string>();
    }

  else
    {
      ConfigDir = CONFIG_PATH;
    }
}
}