Create unordered map between array datatype and attr datatype in pvxs converter

Author: jsouter

ADApp/ntndArrayConverterSrc/ntndArrayConverter.h

@@ -73,6 +73,9 @@ typedef std::tr1::shared_ptr<NTNDArrayConverter> NTNDArrayConverterPtr;
 #include <ntndArrayConverterAPI.h>
 #include <NDArray.h>
 #include <pvxs/data.h>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
 
 typedef struct NTNDArrayInfo
 {
@@ -101,6 +104,7 @@ class NTNDARRAYCONVERTER_API NTNDArrayConverter
 
 private:
     pvxs::Value m_value;
+    std::unordered_map<std::type_index, NDAttrDataType_t> m_typeMap;
     NDColorMode_t getColorMode (void);
 
     template <typename arrayType>
@@ -112,7 +116,7 @@ class NTNDARRAYCONVERTER_API NTNDArrayConverter
     void toDataTimeStamp (NDArray *dest);
 
     template <typename valueType>
-    void toAttribute (NDArray *dest, pvxs::Value attribute, NDAttrDataType_t dataType);
+    void toAttribute (NDArray *dest, pvxs::Value attribute);
     void toStringAttribute (NDArray *dest, pvxs::Value attribute);
     void toUndefinedAttribute (NDArray *dest, pvxs::Value attribute);
     void toAttributes (NDArray *dest);

ADApp/ntndArrayConverterSrc/ntndArrayConverter_pvxs.cpp

@@ -11,7 +11,20 @@ struct freeNDArray {
     void operator()(dataType *data) { array->release(); }
 };
 
-NTNDArrayConverter::NTNDArrayConverter (pvxs::Value value) : m_value(value) {}
+NTNDArrayConverter::NTNDArrayConverter (pvxs::Value value) : m_value(value) {
+    m_typeMap = {
+        {typeid(int8_t), NDAttrDataType_t::NDAttrInt8},
+        {typeid(uint8_t), NDAttrDataType_t::NDAttrUInt8},
+        {typeid(int16_t), NDAttrDataType_t::NDAttrInt16},
+        {typeid(uint16_t), NDAttrDataType_t::NDAttrUInt16},
+        {typeid(int32_t), NDAttrDataType_t::NDAttrInt32},
+        {typeid(uint32_t), NDAttrDataType_t::NDAttrUInt32},
+        {typeid(int64_t), NDAttrDataType_t::NDAttrInt64},
+        {typeid(uint64_t), NDAttrDataType_t::NDAttrUInt64},
+        {typeid(float_t), NDAttrDataType_t::NDAttrFloat32},
+        {typeid(double_t), NDAttrDataType_t::NDAttrFloat64}
+    };
+}
 
 NDColorMode_t NTNDArrayConverter::getColorMode (void)
 {
@@ -221,14 +234,14 @@ void NTNDArrayConverter::toDataTimeStamp (NDArray *dest)
 }
 
 template <typename valueType>
-void NTNDArrayConverter::toAttribute (NDArray *dest, pvxs::Value attribute, NDAttrDataType_t dataType)
+void NTNDArrayConverter::toAttribute (NDArray *dest, pvxs::Value attribute)
 {
-    // TODO, can we make dataType a template parameter?
     auto name = attribute["name"].as<std::string>();
     auto desc = attribute["descriptor"].as<std::string>();
     auto source = attribute["source"].as<std::string>();
     NDAttrSource_t sourceType = (NDAttrSource_t) attribute["sourceType"].as<int32_t>();
     valueType value = attribute["value"].as<valueType>();
+    NDAttrDataType_t dataType = m_typeMap[typeid(valueType)];
 
     NDAttribute *attr = new NDAttribute(name.c_str(), desc.c_str(), sourceType, source.c_str(), dataType, (void*)&value);
     dest->pAttributeList->add(attr);
@@ -264,16 +277,16 @@ void NTNDArrayConverter::toAttributes (NDArray *dest)
         pvxs::Value value = attributes[i]["value"];
         switch (attributes[i]["value->"].type().code) {
             // use indirection on Any container to get specified type
-            case pvxs::TypeCode::Int8:        toAttribute<int8_t>    (dest, attributes[i], NDAttrDataType_t::NDAttrInt8); break;
-            case pvxs::TypeCode::UInt8:       toAttribute<uint8_t>   (dest, attributes[i], NDAttrDataType_t::NDAttrUInt8); break;
-            case pvxs::TypeCode::Int16:       toAttribute<int16_t>   (dest, attributes[i], NDAttrDataType_t::NDAttrInt16); break;
-            case pvxs::TypeCode::UInt16:      toAttribute<uint16_t>  (dest, attributes[i], NDAttrDataType_t::NDAttrUInt16); break;
-            case pvxs::TypeCode::Int32:       toAttribute<int32_t>   (dest, attributes[i], NDAttrDataType_t::NDAttrInt32); break;
-            case pvxs::TypeCode::UInt32:      toAttribute<uint32_t>  (dest, attributes[i], NDAttrDataType_t::NDAttrUInt32); break;
-            case pvxs::TypeCode::Int64:       toAttribute<int64_t>   (dest, attributes[i], NDAttrDataType_t::NDAttrInt64); break;
-            case pvxs::TypeCode::UInt64:      toAttribute<uint64_t>  (dest, attributes[i], NDAttrDataType_t::NDAttrUInt64); break;
-            case pvxs::TypeCode::Float32:     toAttribute<float_t>   (dest, attributes[i], NDAttrDataType_t::NDAttrFloat32); break;
-            case pvxs::TypeCode::Float64:     toAttribute<double_t>  (dest, attributes[i], NDAttrDataType_t::NDAttrFloat64); break;
+            case pvxs::TypeCode::Int8:        toAttribute<int8_t>    (dest, attributes[i]); break;
+            case pvxs::TypeCode::UInt8:       toAttribute<uint8_t>   (dest, attributes[i]); break;
+            case pvxs::TypeCode::Int16:       toAttribute<int16_t>   (dest, attributes[i]); break;
+            case pvxs::TypeCode::UInt16:      toAttribute<uint16_t>  (dest, attributes[i]); break;
+            case pvxs::TypeCode::Int32:       toAttribute<int32_t>   (dest, attributes[i]); break;
+            case pvxs::TypeCode::UInt32:      toAttribute<uint32_t>  (dest, attributes[i]); break;
+            case pvxs::TypeCode::Int64:       toAttribute<int64_t>   (dest, attributes[i]); break;
+            case pvxs::TypeCode::UInt64:      toAttribute<uint64_t>  (dest, attributes[i]); break;
+            case pvxs::TypeCode::Float32:     toAttribute<float_t>   (dest, attributes[i]); break;
+            case pvxs::TypeCode::Float64:     toAttribute<double_t>  (dest, attributes[i]); break;
             case pvxs::TypeCode::String:      toStringAttribute      (dest, attributes[i]); break;
             case pvxs::TypeCode::Null:        toUndefinedAttribute   (dest, attributes[i]); break;
             default: throw std::runtime_error("invalid value data type");