EnumValueType support

[CarlottaPat]

I would like to suggest a possible addition to the QOpcUa code.
In fact, the current version seems to lack the management of user-defined enum data types on the OPC UA server.
In my local code version I have inserted my two new files qopcuaenumvaluetype.cpp and qopcuaenumvaluetype.h in the folder qtopcua\src\opcua\client.

• qopcuaenumvaluetype.h

#ifndef QOpcUaEnumValueType_H
#define QOpcUaEnumValueType_H

#include <QtOpcUa/qopcuaglobal.h>

#include <QtCore/qshareddata.h>
#include <QtCore/qvariant.h>

QT_BEGIN_NAMESPACE

class QOpcUaLocalizedText;
class QOpcUaEnumValueTypeData;

class Q_OPCUA_EXPORT QOpcUaEnumValueType
{
public:
    QOpcUaEnumValueType();
    QOpcUaEnumValueType(const QOpcUaEnumValueType&);
    QOpcUaEnumValueType(qint32 value, const QOpcUaLocalizedText& displayName, const QOpcUaLocalizedText& description);
    QOpcUaEnumValueType& operator=(const QOpcUaEnumValueType&);
    bool operator==(const QOpcUaEnumValueType& rhs) const;
    operator QVariant() const;
    ~QOpcUaEnumValueType();

    qint64 value() const;
    void setValue(qint64 value);

    QOpcUaLocalizedText displayName() const;
    void setDisplayName(const QOpcUaLocalizedText& displayName);

    QOpcUaLocalizedText description() const;
    void setDescription(const QOpcUaLocalizedText& description);

private:
    QSharedDataPointer<QOpcUaEnumValueTypeData> data;
};

QT_END_NAMESPACE

Q_DECLARE_METATYPE(QOpcUaEnumValueType)

#endif // QOpcUaEnumValueType_H

• qopcuaenumvaluetype.cpp

#include "qopcuaenumvaluetype.h"
#include "qopcualocalizedtext.h"

QT_BEGIN_NAMESPACE

/*!
    \class QOpcUaEnumValueType
    \inmodule QtOpcUa
    \brief The OPC UA EnumValueType.

    This is the Qt OPC UA representation for the OPC UA XVType type defined in OPC-UA part 8, 5.6.8.
    This type is used to position values of float precision on an axis with double precision.
*/

class QOpcUaEnumValueTypeData : public QSharedData
{
public:
    qint64 value;
    QOpcUaLocalizedText displayName;
    QOpcUaLocalizedText description;
};

QOpcUaEnumValueType::QOpcUaEnumValueType()
    : data(new QOpcUaEnumValueTypeData)
{
}

/*!
    Constructs an XValue from \a rhs.
*/
QOpcUaEnumValueType::QOpcUaEnumValueType(const QOpcUaEnumValueType& rhs)
    : data(rhs.data)
{
}

/*!
    Constructs an XValue with position \a x and value \a value.
*/
QOpcUaEnumValueType::QOpcUaEnumValueType(qint32 value, const QOpcUaLocalizedText& displayName, const QOpcUaLocalizedText& description)
    : data(new QOpcUaEnumValueTypeData)
{
    data->value = value;
    data->displayName = displayName;
    data->description = description;
}

/*!
    Sets the values from \a rhs in this enum value type.
*/
QOpcUaEnumValueType& QOpcUaEnumValueType::operator=(const QOpcUaEnumValueType& rhs)
{
    if (this != &rhs)
        data.operator=(rhs.data);
    return *this;
}

/*!
    Returns \c true if this enum value type has the same value as \a rhs.
*/
bool QOpcUaEnumValueType::operator==(const QOpcUaEnumValueType& rhs) const
{
    return data->value == rhs.value() &&
        data->displayName == rhs.displayName() &&
        data->description == rhs.description();
}

/*!
    Converts this XValue to \l QVariant.
*/
QOpcUaEnumValueType::operator QVariant() const
{
    return QVariant::fromValue(*this);
}

QOpcUaEnumValueType::~QOpcUaEnumValueType()
{
}

/*!
    Returns the value.
*/
qint64 QOpcUaEnumValueType::value() const
{
    return data->value;
}

/*!
    Sets the value.
*/
void QOpcUaEnumValueType::setValue(qint64 value)
{
    data->value = value;
}

/*!
    Returns the display name.
*/
QOpcUaLocalizedText QOpcUaEnumValueType::displayName() const
{
    return data->displayName;
}

/*!
    Sets the display name.
*/
void QOpcUaEnumValueType::setDisplayName(const QOpcUaLocalizedText& displayName)
{
    data->displayName = displayName;
}

/*!
    Returns the description.
*/
QOpcUaLocalizedText QOpcUaEnumValueType::description() const
{
    return data->description;
}

/*!
    Sets the description.
*/
void QOpcUaEnumValueType::setDescription(const QOpcUaLocalizedText& description)
{
    data->description = description;
}

QT_END_NAMESPACE

In addition, I have also modified the following files:

• I added my .h file include and the QOpcUaBinaryDataEncoding::decode method in qtopcua\src\opcua\client\qopcuabinarydataencoding.h

    #include <QtOpcUa/qopcuaenumvaluetype.h>
    . . . . . . . . .
    . . . . . . . . .
    template <>
    inline QOpcUaEnumValueType QOpcUaBinaryDataEncoding::decode<QOpcUaEnumValueType>(bool& success)
    {
        QOpcUaEnumValueType temp;
    
        temp.setValue(decode<qint64>(success));
        if (!success)
            return QOpcUaEnumValueType();
    
        temp.setDisplayName(decode<QOpcUaLocalizedText>(success));
        if (!success)
            return QOpcUaEnumValueType();
    
        temp.setDescription(decode<QOpcUaLocalizedText>(success));
        if (!success)
            return QOpcUaEnumValueType();
    
        return temp;
    }
  

• I added my .h file include in qtopcua\src\opcua\core\qopcuaprovider.cpp
  #include <QtOpcUa/qopcuaenumvaluetype.h>

• I had to modify the existing toQVariant method in qtopcua\src\plugins\opcua\open62541\qopen62541valueconverter.cpp (I added the case UA_TYPES_ENUMVALUETYPE statement):

   QVariant toQVariant(const UA_Variant &value)
   {
      if (value.type == nullptr) {
            return QVariant();
      }
      switch (value.type->typeIndex) {
      case UA_TYPES_BOOLEAN:
          return arrayToQVariant<bool, UA_Boolean>(value, QMetaType::Bool);
      case UA_TYPES_SBYTE:
          return arrayToQVariant<signed char, UA_SByte>(value, QMetaType::SChar);
          . . . . . . . . .
          . . . . . . . . .
      case UA_TYPES_DOUBLECOMPLEXNUMBERTYPE:
          return arrayToQVariant<QOpcUaDoubleComplexNumber, UA_DoubleComplexNumberType>(value);
      case UA_TYPES_XVTYPE:
          return arrayToQVariant<QOpcUaXValue, UA_XVType>(value);
      case UA_TYPES_ENUMVALUETYPE:
          return arrayToQVariant<QOpcUaEnumValueType, UA_EnumValueType>(value);
      default:
          qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Variant conversion from Open62541 for typeName" << value.type->typeName << " not implemented";
          return QVariant();
      }
  }

I have added the scalarToQt<QOpcUaEnumValueType, UA_EnumValueType> method:

template<>
QOpcUaEnumValueType scalarToQt<QOpcUaEnumValueType, UA_EnumValueType>(const UA_EnumValueType* data)
 {
     return QOpcUaEnumValueType(data->value,
         scalarToQt<QOpcUaLocalizedText, UA_LocalizedText>(&data->displayName),
         scalarToQt<QOpcUaLocalizedText, UA_LocalizedText>(&data->description));
 }

I have modified the scalarToQt<QVariant, UA_ExtensionObject> method:

  template <>
  QVariant scalarToQt<QVariant, UA_ExtensionObject>(const UA_ExtensionObject *data)
  {
      // OPC-UA part 6, Table 13 states that an extension object can have no body, a ByteString encoded body
      // or an XML encoded body.
  
      // Handle extension object without body
      if (data->encoding == UA_EXTENSIONOBJECT_ENCODED_NOBODY) {
          QOpcUaExtensionObject obj;
          obj.setEncoding(QOpcUaExtensionObject::Encoding::NoBody);
          return QVariant::fromValue(obj);
      }
      . . . . . . . . .
      . . . . . . . . .
        if (data->content.decoded.type == &UA_TYPES[UA_TYPES_XVTYPE] && data->content.decoded.data) {
            return scalarToQt<QOpcUaXValue, UA_XVType>
                    (reinterpret_cast<UA_XVType *>(data->content.decoded.data));
        }

        if (data->content.decoded.type == &UA_TYPES[UA_TYPES_ENUMVALUETYPE] && data->content.decoded.data) {
            return scalarToQt<QOpcUaEnumValueType, UA_EnumValueType>
                (reinterpret_cast<UA_EnumValueType*>(data->content.decoded.data));
        }

        qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Unsupported decoded extension object type, unable to convert" << data->content.decoded.type->typeName;
        return QVariant();
    }

• Finally, in qtopcua\src\opcua\CMakeLists.txt also put my two added files:

   qt_internal_add_module(OpcUa
   PLUGIN_TYPES opcua
   SOURCES
   . . . . . . . . .
   client/qopcuaenumvaluetype.cpp client/qopcuaenumvaluetype.h
  

After these code additions and changes I successfully rebuilt the QOpcUa project and could access my custom enum types from my client (with the open62541 backend).
Would it be possible to contribute to the QOpcUa project with the above modifications?

[cla-assistant]

Thank you for your submission! We really appreciate it. Like many open source projects, we ask that you all sign our Contributor License Agreement before we can accept your contribution.
0 out of 6 committers have signed the CLA.

❌ Qt Submodule Update Bot
❌ kkoehne
❌ ShyamQt
❌ FriedemannKleint
❌ basyskom-meerkoetter
❌ semlanik

---

Qt Submodule Update Bot seems not to be a GitHub user. You need a GitHub account to be able to sign the CLA. If you have already a GitHub account, please add the email address used for this commit to your account.
_{You have signed the CLA already but the status is still pending? Let us recheck it.}