separate NDPluginPva and NDPluginPVXS and converters entirely

Author: jsouter

ADApp/Makefile

@@ -16,6 +16,10 @@ ifeq ($(WITH_PVA), YES)
   DIRS += ntndArrayConverterSrc
   ntndArrayConverterSrc_DEPEND_DIRS += ADSrc
   pluginSrc_DEPEND_DIRS += ntndArrayConverterSrc
+else ifeq ($(WITH_PVXS), YES)
+  DIRS += ntndArrayConverterSrc
+  ntndArrayConverterSrc_DEPEND_DIRS += ADSrc
+  pluginSrc_DEPEND_DIRS += ntndArrayConverterSrc
 endif
 
 DIRS += op

ADApp/commonDriverMakefile

@@ -23,11 +23,7 @@ ifeq ($(WITH_QSRV),YES)
   PROD_LIBS += qsrv
 endif
 
-ifeq ($(WITH_PVXS),YES)
-  $(DBD_NAME)_DBD += NDPluginPva.dbd
-  PROD_LIBS += pvxs
-  PROD_LIBS += ntndArrayConverter
-else ifeq ($(WITH_PVA),YES)
+ifeq ($(WITH_PVA),YES)
   $(DBD_NAME)_DBD += NDPluginPva.dbd
   $(DBD_NAME)_DBD += PVAServerRegister.dbd
   PROD_LIBS += ntndArrayConverter
@@ -41,6 +37,12 @@ else ifeq ($(WITH_PVA),YES)
   endif
 endif
 
+ifeq ($(WITH_PVXS),YES)
+  $(DBD_NAME)_DBD += NDPluginPvxs.dbd
+  PROD_LIBS += pvxs
+  PROD_LIBS += ntndArrayConverterPvxs
+endif
+
 ifeq ($(WITH_NETCDF),YES)
   $(DBD_NAME)_DBD += NDFileNetCDF.dbd
   ifeq ($(NETCDF_EXTERNAL),NO)

ADApp/commonLibraryMakefile

@@ -3,17 +3,19 @@
 LIB_LIBS += ADBase
 LIB_LIBS += asyn
 
-ifeq ($(WITH_PVXS),YES)
-  LIB_LIBS += pvxs
-  LIB_LIBS += ntndArrayConverter
-else ifeq ($(WITH_PVA),YES)
+ifeq ($(WITH_PVA),YES)
   LIB_LIBS += ntndArrayConverter
   LIB_LIBS += nt
   LIB_LIBS += pvDatabase
   LIB_LIBS += pvAccess
   LIB_LIBS += pvData
 endif
 
+ifeq ($(WITH_PVXS),YES)
+  LIB_LIBS += ntndArrayConverterPvxs
+  LIB_LIBS += pvxs
+endif
+
 ifeq ($(WITH_NETCDF),YES)
   ifeq ($(NETCDF_EXTERNAL),NO)
     LIB_LIBS += netCDF

ADApp/ntndArrayConverterSrc/Makefile

@@ -4,30 +4,26 @@ include $(TOP)/configure/CONFIG
 #  ADD MACRO DEFINITIONS AFTER THIS LINE
 #=============================
 
-LIBRARY_IOC += ntndArrayConverter
-INC += ntndArrayConverterAPI.h
+ifeq ($(WITH_PVA), YES)
+	LIBRARY_IOC += ntndArrayConverter
+	INC += ntndArrayConverter.h
+	LIB_SRCS += ntndArrayConverter.cpp
+	LIB_LIBS += pvData
+	LIB_LIBS += nt
+endif
+
 ifeq ($(WITH_PVXS), YES)
-INC += ntndArrayConverter.h
-LIB_SRCS += ntndArrayConverter_pvxs.cpp
-USR_CPPFLAGS += -DHAVE_PVXS
-else
-INC += ntndArrayConverter.h
-LIB_SRCS += ntndArrayConverter.cpp
+	LIBRARY_IOC += ntndArrayConverterPvxs
+	INC += ntndArrayConverterPvxs.h
+	LIB_SRCS += ntndArrayConverterPvxs.cpp
+	LIB_LIBS += pvxs
 endif
 
+INC += ntndArrayConverterAPI.h
 USR_CPPFLAGS += -DBUILDING_ntndArrayConverter_API
-
 LIB_LIBS              += ADBase
-
-ifeq ($(WITH_PVXS),YES)
-	LIB_LIBS 			  += pvxs
-else
-	LIB_LIBS              += pvData
-	LIB_LIBS              += nt
-endif
 LIB_LIBS              += asyn
 LIB_LIBS              += $(EPICS_BASE_IOC_LIBS)
-
 #=============================
 
 include $(TOP)/configure/RULES

ADApp/ntndArrayConverterSrc/ntndArrayConverter.h

@@ -1,4 +1,3 @@
-#ifndef HAVE_PVXS
 #include <math.h>
 
 #include <ntndArrayConverterAPI.h>
@@ -67,76 +66,3 @@ class NTNDARRAYCONVERTER_API NTNDArrayConverter
 };
 
 typedef std::tr1::shared_ptr<NTNDArrayConverter> NTNDArrayConverterPtr;
-#else
-#include <math.h>
-
-#include <ntndArrayConverterAPI.h>
-#include <NDArray.h>
-#include <pvxs/data.h>
-#include <typeindex>
-#include <typeinfo>
-#include <unordered_map>
-
-typedef struct NTNDArrayInfo
-{
-    int ndims;
-    size_t dims[ND_ARRAY_MAX_DIMS];
-    size_t nElements, totalBytes;
-    int bytesPerElement;
-    NDColorMode_t colorMode;
-    NDDataType_t dataType;
-    std::string codec;
-
-    struct
-    {
-        int dim;
-        size_t size, stride;
-    }x, y, color;
-}NTNDArrayInfo_t;
-
-class NTNDARRAYCONVERTER_API NTNDArrayConverter
-{
-public:
-    NTNDArrayConverter(pvxs::Value value);
-    NTNDArrayInfo_t getInfo (void);
-    void toArray (NDArray *dest);
-    void fromArray (NDArray *src);
-
-private:
-    pvxs::Value m_value;
-    std::unordered_map<std::type_index, NDAttrDataType_t> m_typeMap;
-    std::unordered_map<std::type_index, std::string> m_fieldNameMap;
-    std::unordered_map<std::type_index, pvxs::ArrayType> m_arrayTypeMap;
-    NDColorMode_t getColorMode (void);
-
-    template <typename arrayType>
-    void toValue (NDArray *dest);
-    void toValue (NDArray *dest);
-
-    void toDimensions (NDArray *dest);
-    void toTimeStamp (NDArray *dest);
-    void toDataTimeStamp (NDArray *dest);
-
-    template <typename valueType>
-    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);
-
-    template <typename arrayType>
-    void fromValue (NDArray *src);
-    void fromValue (NDArray *src);
-    
-    void fromDimensions (NDArray *src);
-    void fromTimeStamp (NDArray *src);
-    void fromDataTimeStamp (NDArray *src);
-
-    template <typename valueType>
-    void fromAttribute (pvxs::Value destValue, NDAttribute *src);
-    void fromStringAttribute (pvxs::Value destValue, NDAttribute *src);
-    void fromAttributes (NDArray *src);
-};
-
-typedef std::shared_ptr<NTNDArrayConverter> NTNDArrayConverterPtr;
-
-#endif

ADApp/ntndArrayConverterSrc/ntndArrayConverterPvxs.cpp

@@ -1,10 +1,10 @@
-#include "ntndArrayConverter.h"
+#include "ntndArrayConverterPvxs.h"
 #include <stdio.h>
 #include <string.h>
 #include <iostream>
 using namespace std;
 
-NTNDArrayConverter::NTNDArrayConverter (pvxs::Value value) : m_value(value) {
+NTNDArrayConverterPvxs::NTNDArrayConverterPvxs (pvxs::Value value) : m_value(value) {
     m_typeMap = {
         {typeid(int8_t), NDAttrDataType_t::NDAttrInt8},
         {typeid(uint8_t), NDAttrDataType_t::NDAttrUInt8},
@@ -45,7 +45,7 @@ NTNDArrayConverter::NTNDArrayConverter (pvxs::Value value) : m_value(value) {
 
 }
 
-NDColorMode_t NTNDArrayConverter::getColorMode (void)
+NDColorMode_t NTNDArrayConverterPvxs::getColorMode (void)
 {
     auto attributes = m_value["attribute"].as<pvxs::shared_array<const pvxs::Value>>();
     NDColorMode_t colorMode = NDColorMode_t::NDColorModeMono;
@@ -58,7 +58,7 @@ NDColorMode_t NTNDArrayConverter::getColorMode (void)
     return colorMode;
 }
 
-NTNDArrayInfo_t NTNDArrayConverter::getInfo (void)
+NTNDArrayInfo_t NTNDArrayConverterPvxs::getInfo (void)
 {
     NTNDArrayInfo_t info = {0};
 
@@ -174,7 +174,7 @@ NTNDArrayInfo_t NTNDArrayConverter::getInfo (void)
     return info;
 }
 
-void NTNDArrayConverter::toArray (NDArray *dest)
+void NTNDArrayConverterPvxs::toArray (NDArray *dest)
 {
     toValue(dest);
     toDimensions(dest);
@@ -185,7 +185,7 @@ void NTNDArrayConverter::toArray (NDArray *dest)
     dest->uniqueId = m_value["uniqueId"].as<int32_t>();
 }
 
-void NTNDArrayConverter::fromArray (NDArray *src)
+void NTNDArrayConverterPvxs::fromArray (NDArray *src)
 {
     fromValue(src);
     fromDimensions(src);
@@ -197,7 +197,7 @@ void NTNDArrayConverter::fromArray (NDArray *src)
 }
 
 template <typename arrayType>
-void NTNDArrayConverter::toValue (NDArray *dest)
+void NTNDArrayConverterPvxs::toValue (NDArray *dest)
 {
     NTNDArrayInfo_t info = getInfo();
     dest->codec.name = info.codec;
@@ -213,7 +213,7 @@ void NTNDArrayConverter::toValue (NDArray *dest)
         dest->compressedSize = info.totalBytes;
 }
 
-void NTNDArrayConverter::toValue (NDArray *dest)
+void NTNDArrayConverterPvxs::toValue (NDArray *dest)
 {
     switch (m_value["value->"].type().code) {
     case pvxs::TypeCode::Int8A:     {toValue<int8_t>(dest); break;}
@@ -230,7 +230,7 @@ void NTNDArrayConverter::toValue (NDArray *dest)
     }
 }
 
-void NTNDArrayConverter::toDimensions (NDArray *dest)
+void NTNDArrayConverterPvxs::toDimensions (NDArray *dest)
 {
     auto dims = m_value["dimension"].as<pvxs::shared_array<const pvxs::Value>>();
     dest->ndims = (int)dims.size();
@@ -245,7 +245,7 @@ void NTNDArrayConverter::toDimensions (NDArray *dest)
     }
 }
 
-void NTNDArrayConverter::toTimeStamp (NDArray *dest)
+void NTNDArrayConverterPvxs::toTimeStamp (NDArray *dest)
 {
     // NDArray uses EPICS time, pvAccess uses Posix time, need to convert
     dest->epicsTS.secPastEpoch = (epicsUInt32)
@@ -254,7 +254,7 @@ void NTNDArrayConverter::toTimeStamp (NDArray *dest)
         m_value["timeStamp.nanoseconds"].as<uint32_t>();
 }
 
-void NTNDArrayConverter::toDataTimeStamp (NDArray *dest)
+void NTNDArrayConverterPvxs::toDataTimeStamp (NDArray *dest)
 {
     // NDArray uses EPICS time, pvAccess uses Posix time, need to convert
     dest->timeStamp = (epicsFloat64) 
@@ -264,7 +264,7 @@ void NTNDArrayConverter::toDataTimeStamp (NDArray *dest)
 }
 
 template <typename valueType>
-void NTNDArrayConverter::toAttribute (NDArray *dest, pvxs::Value attribute)
+void NTNDArrayConverterPvxs::toAttribute (NDArray *dest, pvxs::Value attribute)
 {
     auto name = attribute["name"].as<std::string>();
     auto desc = attribute["descriptor"].as<std::string>();
@@ -277,7 +277,7 @@ void NTNDArrayConverter::toAttribute (NDArray *dest, pvxs::Value attribute)
     dest->pAttributeList->add(attr);
 }
 
-void NTNDArrayConverter::toStringAttribute (NDArray *dest, pvxs::Value attribute)
+void NTNDArrayConverterPvxs::toStringAttribute (NDArray *dest, pvxs::Value attribute)
 {
     auto name = attribute["name"].as<std::string>();
     auto desc = attribute["descriptor"].as<std::string>();
@@ -289,7 +289,7 @@ void NTNDArrayConverter::toStringAttribute (NDArray *dest, pvxs::Value attribute
     dest->pAttributeList->add(attr);
 }
 
-void NTNDArrayConverter::toUndefinedAttribute (NDArray *dest, pvxs::Value attribute)
+void NTNDArrayConverterPvxs::toUndefinedAttribute (NDArray *dest, pvxs::Value attribute)
 {
     auto name = attribute["name"].as<std::string>();
     auto desc = attribute["descriptor"].as<std::string>();
@@ -300,7 +300,7 @@ void NTNDArrayConverter::toUndefinedAttribute (NDArray *dest, pvxs::Value attrib
     dest->pAttributeList->add(attr);
 }
 
-void NTNDArrayConverter::toAttributes (NDArray *dest)
+void NTNDArrayConverterPvxs::toAttributes (NDArray *dest)
 {
     auto attributes = m_value["attribute"].as<pvxs::shared_array<const pvxs::Value>>();
     for (int i=0; i<attributes.size(); i++) {
@@ -325,7 +325,7 @@ void NTNDArrayConverter::toAttributes (NDArray *dest)
 }
 
 template <typename dataType>
-void NTNDArrayConverter::fromValue(NDArray *src) {
+void NTNDArrayConverterPvxs::fromValue(NDArray *src) {
     NDArrayInfo_t arrayInfo;
     src->getInfo(&arrayInfo);
 
@@ -344,7 +344,7 @@ void NTNDArrayConverter::fromValue(NDArray *src) {
     m_value["codec.parameters"] = (int32_t) src->dataType;
 }
 
-void NTNDArrayConverter::fromValue (NDArray *src) {
+void NTNDArrayConverterPvxs::fromValue (NDArray *src) {
     switch(src->dataType) {
         case NDInt8:      {fromValue<int8_t>(src); break;};
         case NDUInt8:     {fromValue<uint8_t>(src); break;};
@@ -362,7 +362,7 @@ void NTNDArrayConverter::fromValue (NDArray *src) {
     }
 }
 
-void NTNDArrayConverter::fromDimensions (NDArray *src) {
+void NTNDArrayConverterPvxs::fromDimensions (NDArray *src) {
     pvxs::shared_array<pvxs::Value> dims;
     dims.resize(src->ndims);
 
@@ -377,7 +377,7 @@ void NTNDArrayConverter::fromDimensions (NDArray *src) {
     m_value["dimension"] = dims.freeze();
 }
 
-void NTNDArrayConverter::fromDataTimeStamp (NDArray *src) {
+void NTNDArrayConverterPvxs::fromDataTimeStamp (NDArray *src) {
     double seconds = floor(src->timeStamp);
     double nanoseconds = (src->timeStamp - seconds)*1e9;
     // pvAccess uses Posix time, NDArray uses EPICS time, need to convert
@@ -386,28 +386,28 @@ void NTNDArrayConverter::fromDataTimeStamp (NDArray *src) {
     m_value["dataTimeStamp.nanoseconds"] = nanoseconds;
 }
 
-void NTNDArrayConverter::fromTimeStamp (NDArray *src) {
+void NTNDArrayConverterPvxs::fromTimeStamp (NDArray *src) {
     // pvAccess uses Posix time, NDArray uses EPICS time, need to convert
     m_value["timeStamp.secondsPastEpoch"] = src->epicsTS.secPastEpoch + POSIX_TIME_AT_EPICS_EPOCH;
     m_value["timeStamp.nanoseconds"] = src->epicsTS.nsec;
 }
 
 template <typename valueType>
-void NTNDArrayConverter::fromAttribute (pvxs::Value destValue, NDAttribute *src)
+void NTNDArrayConverterPvxs::fromAttribute (pvxs::Value destValue, NDAttribute *src)
 {
     valueType value;
     src->getValue(src->getDataType(), (void*)&value);
     destValue["value"] = value;
 }
 
-void NTNDArrayConverter::fromStringAttribute (pvxs::Value destValue, NDAttribute *src)
+void NTNDArrayConverterPvxs::fromStringAttribute (pvxs::Value destValue, NDAttribute *src)
 {
     const char *value;
     src->getValue(src->getDataType(), (void*)&value);
     destValue["value"] = std::string(value);
 }
 
-void NTNDArrayConverter::fromAttributes (NDArray *src)
+void NTNDArrayConverterPvxs::fromAttributes (NDArray *src)
 {
     NDAttributeList *srcList = src->pAttributeList;
     NDAttribute *attr = NULL;