variantConverter.hpp

Go to the documentation of this file.

 
#ifndef ESO_UATOOLS_PROTOCOL_OPEN62541_VARIANT_CONVERTER_H_
#define ESO_UATOOLS_PROTOCOL_OPEN62541_VARIANT_CONVERTER_H_
 
#include <string>
#include <thread>
#include <atomic>
#include <chrono>
#include <iostream>
 
#include <boost/variant.hpp>
 
#ifdef UA_ENABLE_AMALGAMATION
# include <open62541.h>
#else
# include <open62541/types.h>
#endif
 
#include "eso/uatools/protocol/base/iComm.hpp"
#include "eso/uatools/protocol/base/utils.hpp"
 
 
namespace eso::uatools::protocol::opcua {
 
template<typename>
inline constexpr bool always_false_v = false;
 
// ---------- Scalar Mapping ----------
template<typename T>
struct UaScalarTraits;
 
template<> struct UaScalarTraits<bool>          { using UaT = UA_Boolean; static constexpr auto Type = UA_TYPES_BOOLEAN; };
template<> struct UaScalarTraits<int>           { using UaT = UA_Int32;   static constexpr auto Type = UA_TYPES_INT32;   };
template<> struct UaScalarTraits<unsigned int>  { using UaT = UA_UInt32;  static constexpr auto Type = UA_TYPES_UINT32;  };
template<> struct UaScalarTraits<short>         { using UaT = UA_Int16;   static constexpr auto Type = UA_TYPES_INT16;   };
template<> struct UaScalarTraits<double>        { using UaT = UA_Double;  static constexpr auto Type = UA_TYPES_DOUBLE;  };
template<> struct UaScalarTraits<std::string>   { using UaT = UA_String;  static constexpr auto Type = UA_TYPES_STRING;  };
template<> struct UaScalarTraits<uint16_t>      { using UaT = UA_UInt16;  static constexpr auto Type = UA_TYPES_UINT16;  };
template<> struct UaScalarTraits<float>         { using UaT = UA_Float;   static constexpr auto Type = UA_TYPES_FLOAT;   };
template<> struct UaScalarTraits<int8_t>        { using UaT = UA_SByte;   static constexpr auto Type = UA_TYPES_SBYTE;   };
template<> struct UaScalarTraits<uint8_t>       { using UaT = UA_Byte;    static constexpr auto Type = UA_TYPES_BYTE;    };
 
// ---------- Vector Trait Detection ----------
template<typename T>
struct is_std_vector : std::false_type {};
 
template<typename T, typename A>
struct is_std_vector<std::vector<T, A>> : std::true_type {};
 
template<typename T>
inline constexpr bool is_std_vector_v = is_std_vector<T>::value;


template<typename CType, typename UaType, const int TypeIndex>
class VariantScalarConverter {
public:
    static void ToUaVariant(const protocol::base::Variant src, UA_Variant& dst) {
        UaType value = std::get<CType>(src);
        UA_Variant_setScalarCopy(&dst, &value,
                                 &UA_TYPES[TypeIndex]);
    }
 
    static void FromUaVariant(const UA_Variant src, protocol::base::Variant& dst) {
        if (src.type == &UA_TYPES[TypeIndex]) {
            UaType value = *reinterpret_cast<const UaType*>(src.data);
            dst = CType(value);   // construct CType from UaType
        }
    }
};
 
// Template specialization for converting strings
template<>
class VariantScalarConverter<std::string,UA_String,UA_TYPES_STRING>   {
public:
 
    static void ToUaVariant(const protocol::base::Variant& src, UA_Variant& dst)
    {
        const std::string& s = std::get<std::string>(src);
        UA_String value = UA_STRING_ALLOC(s.c_str());
        UA_Variant_setScalarCopy(&dst, &value, &UA_TYPES[UA_TYPES_STRING]);
    }
 
    static void FromUaVariant(const UA_Variant& src, protocol::base::Variant& dst)
    {
        if (src.type == &UA_TYPES[UA_TYPES_STRING]) {
            const UA_String& ua = *reinterpret_cast<const UA_String*>(src.data);
            dst = std::string(reinterpret_cast<const char*>(ua.data), ua.length);
        }
    }
};

template<typename CType, typename UaType, const int TypeIndex>
class VariantArrayConverter {
public:
    static void ToUaVariant(const protocol::base::Variant& src, UA_Variant& dst)
    {
        const auto& vec = std::get<std::vector<CType>>(src);
 
        UA_Variant_setArrayCopy(
            &dst,
            vec.data(),
            static_cast<UA_Int32>(vec.size()),
            &UA_TYPES[TypeIndex]
        );
    }
 
    static void FromUaVariant(const UA_Variant& src, protocol::base::Variant& dst)
    {
        if (src.type == &UA_TYPES[TypeIndex] && src.arrayLength > 0) {
            const UaType* data = reinterpret_cast<const UaType*>(src.data);
 
            std::vector<CType> vec;
            vec.reserve(src.arrayLength);
 
            for (size_t i = 0; i < src.arrayLength; ++i) {
                vec.emplace_back(static_cast<CType>(data[i]));
            }
 
            dst = std::move(vec);
        }
    }
};

template<int TypeIndex>
class VariantArrayConverter<bool, UA_Boolean, TypeIndex> {
public:
    static void ToUaVariant(const protocol::base::Variant& src, UA_Variant& dst) {
        const auto& vec = std::get<std::vector<bool>>(src);
 
        // ✅ FORCE REAL BYTE STORAGE (never vector<bool>)
        std::vector<uint8_t> tmp(vec.size());
        for (size_t i = 0; i < vec.size(); ++i) {
            tmp[i] = static_cast<uint8_t>(vec[i]);
        }
 
        UA_Variant_setArrayCopy(
            &dst,
            tmp.data(),                        // ✅ REAL contiguous memory
            tmp.size(),
            &UA_TYPES[TypeIndex]
        );
    }
 
    static void FromUaVariant(const UA_Variant& src,
                              protocol::base::Variant& dst) {
        if (src.type == &UA_TYPES[TypeIndex] && src.arrayLength > 0) {
 
            const uint8_t* data =
                static_cast<const uint8_t*>(src.data);
 
            std::vector<bool> vec(src.arrayLength);
            for (size_t i = 0; i < src.arrayLength; ++i) {
                vec[i] = data[i] != 0;
            }
 
            dst = std::move(vec);
        }
    }
};
 
 

template<>
class VariantArrayConverter<std::string, UA_String, UA_TYPES_STRING> {
public:
    static void ToUaVariant(const protocol::base::Variant& src, UA_Variant& dst)
    {
        const auto& vec = std::get<std::vector<std::string>>(src);
 
        std::vector<UA_String> uaVec;
        uaVec.reserve(vec.size());
 
        for (const auto& s : vec) {
            uaVec.emplace_back(UA_STRING_ALLOC(s.c_str()));
        }
 
        UA_Variant_setArrayCopy(
            &dst,
            uaVec.data(),
            static_cast<UA_Int32>(uaVec.size()),
            &UA_TYPES[UA_TYPES_STRING]
        );
 
        // Clean up temporary UA_String allocations
        for (auto& s : uaVec) {
            UA_String_clear(&s);
        }
    }
 
    static void FromUaVariant(const UA_Variant& src, protocol::base::Variant& dst)
    {
        if (src.type == &UA_TYPES[UA_TYPES_STRING] && src.arrayLength > 0) {
            const UA_String* data = reinterpret_cast<const UA_String*>(src.data);
 
            std::vector<std::string> vec;
            vec.reserve(src.arrayLength);
 
            for (size_t i = 0; i < src.arrayLength; ++i) {
                vec.emplace_back(
                    reinterpret_cast<const char*>(data[i].data),
                    data[i].length
                );
            }
 
            dst = std::move(vec);
        }
    }
};
 
 
 
}  // namespace
 
#endif  // ESO_UATOOLS_PROTOCOL_OPEN62541_VARIANT_CONVERTER_H_