add namespace prefix for public types and functions (#161)

Author: matkonnerth

CMakeLists.txt

@@ -96,7 +96,7 @@ add_library(NodesetLoader
     src/nodes/DataTypeNode.c
     src/nodes/NodeContainer.c
     src/nodes/InstanceNode.c
-    src/TNodeId.c
+    src/NodeId.c
     src/PrintfLogger.c
     src/Value.c
     src/InternalRefService.c
@@ -138,7 +138,7 @@ endif()
 if(NOT ${CALC_COVERAGE})
     set(NODESETLOADER_PUBLIC_HEADER 
         ${PROJECT_SOURCE_DIR}/include/NodesetLoader/NodesetLoader.h
-        ${PROJECT_SOURCE_DIR}/include/NodesetLoader/TNodeId.h
+        ${PROJECT_SOURCE_DIR}/include/NodesetLoader/NodeId.h
         ${PROJECT_SOURCE_DIR}/include/NodesetLoader/Logger.h
         ${PROJECT_SOURCE_DIR}/include/NodesetLoader/arch.h
         ${PROJECT_SOURCE_DIR}/include/NodesetLoader/ReferenceService.h

backends/open62541/src/DataTypeImporter.c

@@ -17,19 +17,19 @@
 struct DataTypeImporter
 {
     UA_DataTypeArray *types;
-    const TDataTypeNode **nodes;
+    const NL_DataTypeNode **nodes;
     size_t nodesSize;
     size_t firstNewDataType;
 };
 
-static UA_NodeId getBinaryEncodingId(const TDataTypeNode *node)
+static UA_NodeId getBinaryEncodingId(const NL_DataTypeNode *node)
 {
-    TNodeId encodingRefType = {0, "i=38"};
+    NL_NodeId encodingRefType = {0, "i=38"};
 
-    Reference *ref = node->nonHierachicalRefs;
+    NL_Reference *ref = node->nonHierachicalRefs;
     while (ref)
     {
-        if (!TNodeId_cmp(&encodingRefType, &ref->refType))
+        if (!NodesetLoader_NodeId_cmp(&encodingRefType, &ref->refType))
         {
             UA_NodeId id = getNodeIdFromChars(ref->target);
             return id;
@@ -239,9 +239,9 @@ static UA_UInt16 getTypeIndex(const DataTypeImporter *importer,
     }
 }
 
-static TNodeId getParentNode(const TDataTypeNode *node)
+static NL_NodeId getParentNode(const NL_DataTypeNode *node)
 {
-    Reference *ref = node->hierachicalRefs;
+    NL_Reference *ref = node->hierachicalRefs;
     while (ref)
     {
         if (!ref->isForward)
@@ -250,13 +250,13 @@ static TNodeId getParentNode(const TDataTypeNode *node)
         }
         ref=ref->next;
     }
-    TNodeId nullId = {0, NULL};
+    NL_NodeId nullId = {0, NULL};
     return nullId;
 }
 
 static void setDataTypeMembersTypeIndex(DataTypeImporter *importer,
                                         UA_DataType *type,
-                                        const TDataTypeNode *node)
+                                        const NL_DataTypeNode *node)
 {
     // member of supertype have to be added, if there is one
     UA_NodeId parent = getNodeIdFromChars(getParentNode(node));
@@ -318,7 +318,7 @@ static void setDataTypeMembersTypeIndex(DataTypeImporter *importer,
 }
 
 static void addDataTypeMembers(const UA_DataType *customTypes,
-                               UA_DataType *type, const TDataTypeNode *node)
+                               UA_DataType *type, const NL_DataTypeNode *node)
 {
 
     if (!node->definition)
@@ -354,7 +354,7 @@ static void addDataTypeMembers(const UA_DataType *customTypes,
 }
 
 static void StructureDataType_init(const DataTypeImporter *importer,
-                                   UA_DataType *type, const TDataTypeNode *node, bool isOptionSet)
+                                   UA_DataType *type, const NL_DataTypeNode *node, bool isOptionSet)
 {
     if (node->definition && node->definition->isUnion)
     {
@@ -375,7 +375,7 @@ static void StructureDataType_init(const DataTypeImporter *importer,
 }
 
 static void EnumDataType_init(const DataTypeImporter *importer,
-                              UA_DataType *enumType, const TDataTypeNode *node)
+                              UA_DataType *enumType, const NL_DataTypeNode *node)
 {
     enumType->typeIndex = (UA_UInt16)importer->types->typesSize;
     enumType->typeKind = UA_DATATYPEKIND_ENUM;
@@ -388,7 +388,7 @@ static void EnumDataType_init(const DataTypeImporter *importer,
 }
 
 static void SubtypeOfBase_init(const DataTypeImporter *importer,
-                               UA_DataType *type, const TDataTypeNode *node,
+                               UA_DataType *type, const NL_DataTypeNode *node,
                                const UA_NodeId parent)
 {
     const UA_DataType* parentType = UA_findDataType(&parent);
@@ -482,7 +482,7 @@ void DataTypeImporter_initMembers(DataTypeImporter *importer)
 }
 
 void DataTypeImporter_addCustomDataType(DataTypeImporter *importer,
-                                        const TDataTypeNode *node,
+                                        const NL_DataTypeNode *node,
                                         const UA_NodeId parent)
 {
     // there is an open issue for that
@@ -528,7 +528,7 @@ void DataTypeImporter_addCustomDataType(DataTypeImporter *importer,
         SubtypeOfBase_init(importer, type, node, parent);
     }
 
-    importer->nodes = (const TDataTypeNode **)realloc(
+    importer->nodes = (const NL_DataTypeNode **)realloc(
         (void*)importer->nodes, (importer->nodesSize + 1) * sizeof(void *));
     importer->nodes[importer->nodesSize] = node;
     importer->nodesSize++;

backends/open62541/src/DataTypeImporter.h

@@ -18,7 +18,7 @@ struct UA_DataType;
 
 DataTypeImporter *DataTypeImporter_new(struct UA_Server *server);
 void DataTypeImporter_addCustomDataType(DataTypeImporter *importer,
-                                        const TDataTypeNode *node, const UA_NodeId parentId);
+                                        const NL_DataTypeNode *node, const UA_NodeId parentId);
 // has to be called after all dependent types where added
 void DataTypeImporter_initMembers(DataTypeImporter *importer);
 void DataTypeImporter_delete(DataTypeImporter *importer);

backends/open62541/src/RefServiceImpl.c

@@ -7,15 +7,15 @@
 
 #include "RefServiceImpl.h"
 #include <NodesetLoader/NodesetLoader.h>
-#include <NodesetLoader/TNodeId.h>
+#include <NodesetLoader/NodeId.h>
 #include <assert.h>
 #include <open62541/server.h>
 #include <stdlib.h>
 
 struct RefContainer
 {
     size_t size;
-    TNodeId *ids;
+    NL_NodeId *ids;
 };
 typedef struct RefContainer RefContainer;
 
@@ -28,7 +28,7 @@ struct RefServiceImpl
 
 static void RefContainer_clear(RefContainer *c)
 {
-    for (TNodeId *id = c->ids; id != c->ids + c->size; id++)
+    for (NL_NodeId *id = c->ids; id != c->ids + c->size; id++)
     {
         free(id->id);
     }
@@ -64,11 +64,11 @@ static void iterate(UA_Server *server, const UA_NodeId *startId, browseFnc fnc,
     UA_BrowseResult_clear(&br);
 }
 
-static void addTNodeIdToRefs(RefContainer *refs, const TNodeId id)
+static void addTNodeIdToRefs(RefContainer *refs, const NL_NodeId id)
 {
     refs->ids =
-        (TNodeId *)realloc(refs->ids, sizeof(TNodeId) * (refs->size + 1));
-    TNodeId *newId = refs->ids + refs->size;
+        (NL_NodeId *)realloc(refs->ids, sizeof(NL_NodeId) * (refs->size + 1));
+    NL_NodeId *newId = refs->ids + refs->size;
     newId->nsIdx = id.nsIdx;
     size_t len = strlen(id.id);
     newId->id = (char *)calloc(len + 1, sizeof(char));
@@ -79,8 +79,8 @@ static void addTNodeIdToRefs(RefContainer *refs, const TNodeId id)
 static void addToRefs(RefContainer *refs, const UA_NodeId id)
 {
     refs->ids =
-        (TNodeId *)realloc(refs->ids, sizeof(TNodeId) * (refs->size + 1));
-    TNodeId *newId = refs->ids + refs->size;
+        (NL_NodeId *)realloc(refs->ids, sizeof(NL_NodeId) * (refs->size + 1));
+    NL_NodeId *newId = refs->ids + refs->size;
     newId->nsIdx = id.namespaceIndex;
     if (id.identifierType == UA_NODEIDTYPE_NUMERIC)
     {
@@ -124,11 +124,11 @@ static void getRefs(UA_Server *server, RefServiceImpl *impl,
     iterate(server, &startId, fn, impl);
 }
 
-static bool isInContainer(const RefContainer c, const Reference *ref)
+static bool isInContainer(const RefContainer c, const NL_Reference *ref)
 {
-    for (const TNodeId *id = c.ids; id != c.ids + c.size; id++)
+    for (const NL_NodeId *id = c.ids; id != c.ids + c.size; id++)
     {
-        if (!TNodeId_cmp(&ref->refType, id))
+        if (!NodesetLoader_NodeId_cmp(&ref->refType, id))
         {
             return true;
         }
@@ -137,33 +137,33 @@ static bool isInContainer(const RefContainer c, const Reference *ref)
 }
 
 static bool isNonHierachicalRef(const RefServiceImpl *service,
-                                const Reference *ref)
+                                const NL_Reference *ref)
 {
     return isInContainer(service->nonHierachicalRefs, ref);
 }
 
 static bool isHierachicalReference(const RefServiceImpl *service,
-                                   const Reference *ref)
+                                   const NL_Reference *ref)
 {
     return isInContainer(service->hierachicalRefs, ref);
 }
 
-static bool isTypeDefRef(const RefServiceImpl *service, const Reference *ref)
+static bool isTypeDefRef(const RefServiceImpl *service, const NL_Reference *ref)
 {
     return isInContainer(service->hasTypeDefRefs, ref);
 }
 
-static void addnewRefType(RefServiceImpl *service, TReferenceTypeNode *node)
+static void addnewRefType(RefServiceImpl *service, NL_ReferenceTypeNode *node)
 {
-    Reference *ref = node->hierachicalRefs;
+    NL_Reference *ref = node->hierachicalRefs;
     bool isHierachical = false;
     while (ref)
     {
         if (!ref->isForward)
         {
             for (size_t i = 0; i < service->hierachicalRefs.size; i++)
             {
-                if (!TNodeId_cmp(&service->hierachicalRefs.ids[i],
+                if (!NodesetLoader_NodeId_cmp(&service->hierachicalRefs.ids[i],
                                  &ref->target))
                 {
                     addTNodeIdToRefs(&service->hierachicalRefs, node->id);
@@ -172,7 +172,7 @@ static void addnewRefType(RefServiceImpl *service, TReferenceTypeNode *node)
             }
             for (size_t i = 0; i < service->hasTypeDefRefs.size; i++)
             {
-                if (!TNodeId_cmp(&service->hasTypeDefRefs.ids[i], &ref->target))
+                if (!NodesetLoader_NodeId_cmp(&service->hasTypeDefRefs.ids[i], &ref->target))
                 {
                     addTNodeIdToRefs(&service->hasTypeDefRefs, node->id);
                 }
@@ -186,7 +186,7 @@ static void addnewRefType(RefServiceImpl *service, TReferenceTypeNode *node)
     }
 }
 
-RefService *RefServiceImpl_new(struct UA_Server *server)
+NL_ReferenceService *RefServiceImpl_new(struct UA_Server *server)
 {
     RefServiceImpl *impl = (RefServiceImpl *)calloc(1, sizeof(RefServiceImpl));
     if (!impl)
@@ -205,7 +205,7 @@ RefService *RefServiceImpl_new(struct UA_Server *server)
     getRefs(server, impl, nonHierachicalRoot, addToNonHierachicalRefs);
     getRefs(server, impl, hasTypeDefRoot, addToHasTypeDefRefs);
 
-    RefService *refService = (RefService *)calloc(1, sizeof(RefService));
+    NL_ReferenceService *refService = (NL_ReferenceService *)calloc(1, sizeof(NL_ReferenceService));
     if (!refService)
     {
         RefContainer_clear(&impl->hierachicalRefs);
@@ -225,7 +225,7 @@ RefService *RefServiceImpl_new(struct UA_Server *server)
     return refService;
 }
 
-void RefServiceImpl_delete(RefService *service)
+void RefServiceImpl_delete(NL_ReferenceService *service)
 {
     RefServiceImpl *impl = (RefServiceImpl *)service->context;
     RefContainer_clear(&impl->hierachicalRefs);

backends/open62541/src/RefServiceImpl.h

@@ -10,6 +10,6 @@
 #include <NodesetLoader/ReferenceService.h>
 
 struct UA_Server;
-RefService *RefServiceImpl_new(struct UA_Server *server);
-void RefServiceImpl_delete(RefService *service);
+NL_ReferenceService *RefServiceImpl_new(struct UA_Server *server);
+void RefServiceImpl_delete(NL_ReferenceService *service);
 #endif