cosmetic improvements

src/server/ua_services_attribute.c

@@ -91,9 +91,8 @@ compatibleDataType(UA_Server *server, const UA_NodeId *dataType,
 
     /* Enum allows Int32 (only) */
     UA_NodeId enumNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ENUMERATION);
-    if (isNodeInTree(server->nodestore, constraintDataType, &enumNodeId, &subtypeId, 1)) {
+    if(isNodeInTree(server->nodestore, constraintDataType, &enumNodeId, &subtypeId, 1))
         return UA_NodeId_equal(dataType, &UA_TYPES[UA_TYPES_INT32].typeId);
-    }
 
     return isNodeInTree(server->nodestore, dataType, constraintDataType, &subtypeId, 1);
 }
@@ -158,7 +157,7 @@ compatibleValueRanks(UA_Int32 valueRank, UA_Int32 constraintValueRank) {
 static UA_StatusCode
 compatibleValueRankValue(UA_Int32 valueRank, const UA_Variant *value) {
     /* empty arrays (-1) always match */
-    if(value->data == NULL)
+    if(!value->data)
         return UA_STATUSCODE_GOOD;
 
     size_t arrayDims = value->arrayDimensionsSize;
@@ -193,7 +192,8 @@ compatibleArrayDimensions(size_t constraintArrayDimensionsSize,
    the description */
 static const UA_Variant *
 convertToMatchingValue(UA_Server *server, const UA_Variant *value,
-                       const UA_NodeId *targetDataTypeId, UA_Variant *editableValue) {
+                       const UA_NodeId *targetDataTypeId,
+                       UA_Variant *editableValue) {
     const UA_DataType *targetDataType = UA_findDataType(targetDataTypeId);
     if(!targetDataType)
         return NULL;
@@ -298,7 +298,8 @@ readArrayDimensionsAttribute(const UA_VariableNode *vn, UA_DataValue *v) {
 
 static UA_StatusCode
 writeArrayDimensionsAttribute(UA_Server *server, UA_VariableNode *node,
-                              size_t arrayDimensionsSize, UA_UInt32 *arrayDimensions) {
+                              size_t arrayDimensionsSize,
+                              UA_UInt32 *arrayDimensions) {
     /* If this is a variabletype, there must be no instances or subtypes of it
      * when we do the change */
     if(node->nodeClass == UA_NODECLASS_VARIABLETYPE &&
@@ -306,7 +307,8 @@ writeArrayDimensionsAttribute(UA_Server *server, UA_VariableNode *node,
         return UA_STATUSCODE_BADINTERNALERROR;
 
     /* Check that the array dimensions match with the valuerank */
-    UA_StatusCode retval = compatibleValueRankArrayDimensions(node->valueRank, arrayDimensionsSize);
+    UA_StatusCode retval =
+        compatibleValueRankArrayDimensions(node->valueRank, arrayDimensionsSize);
     if(retval != UA_STATUSCODE_GOOD) {
         UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SERVER,
                      "The current value rank does not match the new array dimensions");
@@ -351,7 +353,8 @@ writeArrayDimensionsAttribute(UA_Server *server, UA_VariableNode *node,
     /* Ok, apply */
     UA_UInt32 *oldArrayDimensions = node->arrayDimensions;
     retval = UA_Array_copy(arrayDimensions, arrayDimensionsSize,
-                           (void**)&node->arrayDimensions, &UA_TYPES[UA_TYPES_UINT32]);
+                           (void**)&node->arrayDimensions,
+                           &UA_TYPES[UA_TYPES_UINT32]);
     if(retval != UA_STATUSCODE_GOOD)
         return retval;
     UA_free(oldArrayDimensions);
@@ -373,8 +376,8 @@ writeValueRankAttributeWithVT(UA_Server *server, UA_VariableNode *node,
 }
 
 UA_StatusCode
-writeValueRankAttribute(UA_Server *server, UA_VariableNode *node, UA_Int32 valueRank,
-                        UA_Int32 constraintValueRank) {
+writeValueRankAttribute(UA_Server *server, UA_VariableNode *node,
+                        UA_Int32 valueRank, UA_Int32 constraintValueRank) {
     /* If this is a variabletype, there must be no instances or subtypes of it
        when we do the change */
     if(node->nodeClass == UA_NODECLASS_VARIABLETYPE &&
@@ -421,7 +424,8 @@ writeValueRankAttribute(UA_Server *server, UA_VariableNode *node, UA_Int32 value
 
 static UA_StatusCode
 writeDataTypeAttribute(UA_Server *server, UA_VariableNode *node,
-                       const UA_NodeId *dataType, const UA_NodeId *constraintDataType) {
+                       const UA_NodeId *dataType,
+                       const UA_NodeId *constraintDataType) {
     /* If this is a variabletype, there must be no instances or subtypes of it
        when we do the change */
     if(node->nodeClass == UA_NODECLASS_VARIABLETYPE &&
@@ -475,8 +479,8 @@ writeDataTypeAttributeWithVT(UA_Server *server, UA_VariableNode *node,
 /*******************/
 
 static UA_StatusCode
-readValueAttributeFromNode(UA_Server *server, const UA_VariableNode *vn, UA_DataValue *v,
-                           UA_NumericRange *rangeptr) {
+readValueAttributeFromNode(UA_Server *server, const UA_VariableNode *vn,
+                           UA_DataValue *v, UA_NumericRange *rangeptr) {
     if(vn->value.data.callback.onRead) {
         UA_RCU_UNLOCK();
         vn->value.data.callback.onRead(vn->value.data.callback.handle,
@@ -512,7 +516,8 @@ readValueAttributeFromDataSource(const UA_VariableNode *vn, UA_DataValue *v,
 
 static UA_StatusCode
 readValueAttributeComplete(UA_Server *server, const UA_VariableNode *vn,
-                           UA_TimestampsToReturn timestamps, const UA_String *indexRange,
+                           UA_TimestampsToReturn timestamps,
+                           const UA_String *indexRange,
                            UA_DataValue *v) {
     /* Compute the index range */
     UA_NumericRange range;
@@ -538,8 +543,10 @@ readValueAttributeComplete(UA_Server *server, const UA_VariableNode *vn,
 }
 
 UA_StatusCode
-readValueAttribute(UA_Server *server, const UA_VariableNode *vn, UA_DataValue *v) {
-    return readValueAttributeComplete(server, vn, UA_TIMESTAMPSTORETURN_NEITHER, NULL, v);
+readValueAttribute(UA_Server *server, const UA_VariableNode *vn,
+                   UA_DataValue *v) {
+    return readValueAttributeComplete(server, vn, UA_TIMESTAMPSTORETURN_NEITHER,
+                                      NULL, v);
 }
 
 static UA_StatusCode
@@ -635,22 +642,22 @@ writeValueAttribute(UA_Server *server, UA_VariableNode *node,
             const UA_VariableNode *writtenNode;
 #ifdef UA_ENABLE_MULTITHREADING
             /* Reopen the node to see the changes (multithreading only) */
-            writtenNode = (const UA_VariableNode*)UA_NodeStore_get(server->nodestore, &node->nodeId);
+            writtenNode = (const UA_VariableNode*)
+                UA_NodeStore_get(server->nodestore, &node->nodeId);
 #else
             writtenNode = node; /* The node is written in-situ (TODO: this might
                                    change with the nodestore plugin approach) */
 #endif
             UA_RCU_UNLOCK();
             writtenNode->value.data.callback.onWrite(writtenNode->value.data.callback.handle,
-                                                     writtenNode->nodeId,
-                                                     &writtenNode->value.data.value.value, rangeptr);
+                          writtenNode->nodeId, &writtenNode->value.data.value.value, rangeptr);
             UA_RCU_LOCK();
         }
     } else {
         if(node->value.dataSource.write) {
             UA_RCU_UNLOCK();
             retval = node->value.dataSource.write(node->value.dataSource.handle,
-                                                  node->nodeId, &editableValue.value, rangeptr);
+                                      node->nodeId, &editableValue.value, rangeptr);
             UA_RCU_LOCK();
         } else {
             retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
@@ -806,7 +813,8 @@ Operation_Read(UA_Server *server, UA_Session *session,
         break;
     case UA_ATTRIBUTEID_VALUE: {
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
-        UA_Byte userAccessLevel = getUserAccessLevel(server, session, (const UA_VariableNode*)node);
+        UA_Byte userAccessLevel = getUserAccessLevel(server, session,
+                                                     (const UA_VariableNode*)node);
         if(!(userAccessLevel & (UA_ACCESSLEVELMASK_READ))) {
             retval = UA_STATUSCODE_BADUSERACCESSDENIED;
             break;
@@ -836,7 +844,8 @@ Operation_Read(UA_Server *server, UA_Session *session,
         break;
     case UA_ATTRIBUTEID_USERACCESSLEVEL: {
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
-        UA_Byte userAccessLevel = getUserAccessLevel(server, session, (const UA_VariableNode*)node);
+        UA_Byte userAccessLevel = getUserAccessLevel(server, session,
+                                                     (const UA_VariableNode*)node);
         UA_Variant_setScalarCopy(&v->value, &userAccessLevel, &UA_TYPES[UA_TYPES_BYTE]);
         break; }
     case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
@@ -856,7 +865,8 @@ Operation_Read(UA_Server *server, UA_Session *session,
         break;
     case UA_ATTRIBUTEID_USEREXECUTABLE: {
         CHECK_NODECLASS(UA_NODECLASS_METHOD);
-        UA_Boolean userExecutable = getUserExecutable(server, session, (const UA_MethodNode*)node);
+        UA_Boolean userExecutable = getUserExecutable(server, session,
+                                                      (const UA_MethodNode*)node);
         UA_Variant_setScalarCopy(&v->value, &userExecutable, &UA_TYPES[UA_TYPES_BOOLEAN]);
         break; }
     default:
@@ -920,7 +930,7 @@ void Service_Read(UA_Server *server, UA_Session *session,
     /* Add an expiry header for caching */
     if(session->sessionId.namespaceIndex == 0 &&
        session->sessionId.identifierType == UA_NODEIDTYPE_NUMERIC &&
-       session->sessionId.identifier.numeric == 0){
+       session->sessionId.identifier.numeric == 0) {
         UA_ExtensionObject additionalHeader;
         UA_ExtensionObject_init(&additionalHeader);
         additionalHeader.encoding = UA_EXTENSIONOBJECT_ENCODED_BYTESTRING;
@@ -1115,7 +1125,8 @@ copyAttributeIntoNode(UA_Server *server, UA_Session *session,
         CHECK_USERWRITEMASK(UA_WRITEMASK_INVERSENAME);
         CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT);
         UA_LocalizedText_deleteMembers(&((UA_ReferenceTypeNode*)node)->inverseName);
-        UA_LocalizedText_copy((const UA_LocalizedText *)value, &((UA_ReferenceTypeNode*)node)->inverseName);
+        UA_LocalizedText_copy((const UA_LocalizedText *)value,
+                              &((UA_ReferenceTypeNode*)node)->inverseName);
         break;
     case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
         CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW);
@@ -1133,7 +1144,8 @@ copyAttributeIntoNode(UA_Server *server, UA_Session *session,
         CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
         if(node->nodeClass == UA_NODECLASS_VARIABLE) {
             /* The access to a value variable is granted via the AccessLevel Byte */
-            UA_Byte userAccessLevel = getUserAccessLevel(server, session, (const UA_VariableNode*)node);
+            UA_Byte userAccessLevel = getUserAccessLevel(server, session,
+                                                         (const UA_VariableNode*)node);
             if(!(userAccessLevel & (UA_ACCESSLEVELMASK_WRITE))) {
                 retval = UA_STATUSCODE_BADUSERACCESSDENIED;
                 break;
@@ -1148,13 +1160,15 @@ copyAttributeIntoNode(UA_Server *server, UA_Session *session,
         CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
         CHECK_USERWRITEMASK(UA_WRITEMASK_DATATYPE);
         CHECK_DATATYPE_SCALAR(NODEID);
-        retval = writeDataTypeAttributeWithVT(server, (UA_VariableNode*)node, (const UA_NodeId*)value);
+        retval = writeDataTypeAttributeWithVT(server, (UA_VariableNode*)node,
+                                              (const UA_NodeId*)value);
         break;
     case UA_ATTRIBUTEID_VALUERANK:
         CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
         CHECK_USERWRITEMASK(UA_WRITEMASK_VALUERANK);
         CHECK_DATATYPE_SCALAR(INT32);
-        retval = writeValueRankAttributeWithVT(server, (UA_VariableNode*)node, *(const UA_Int32*)value);
+        retval = writeValueRankAttributeWithVT(server, (UA_VariableNode*)node,
+                                               *(const UA_Int32*)value);
         break;
     case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
         CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
@@ -1203,12 +1217,13 @@ static void
 Operation_Write(UA_Server *server, UA_Session *session,
                 UA_WriteValue *wv, UA_StatusCode *result) {
     *result = UA_Server_editNode(server, session, &wv->nodeId,
-                                  (UA_EditNodeCallback)copyAttributeIntoNode, wv);
+                        (UA_EditNodeCallback)copyAttributeIntoNode, wv);
 }
 
 void
 Service_Write(UA_Server *server, UA_Session *session,
-              const UA_WriteRequest *request, UA_WriteResponse *response) {
+              const UA_WriteRequest *request,
+              UA_WriteResponse *response) {
     UA_LOG_DEBUG_SESSION(server->config.logger, session,
                          "Processing WriteRequest", NULL);
 
@@ -1223,7 +1238,7 @@ UA_StatusCode
 UA_Server_write(UA_Server *server, const UA_WriteValue *value) {
     UA_StatusCode retval =
         UA_Server_editNode(server, &adminSession, &value->nodeId,
-                           (UA_EditNodeCallback)copyAttributeIntoNode, value);
+                  (UA_EditNodeCallback)copyAttributeIntoNode, value);
     return retval;
 }
 
@@ -1240,7 +1255,8 @@ __UA_Server_write(UA_Server *server, const UA_NodeId *nodeId,
     wvalue.value.hasValue = true;
     if(attr_type != &UA_TYPES[UA_TYPES_VARIANT]) {
         /* hacked cast. the target WriteValue is used as const anyway */
-        UA_Variant_setScalar(&wvalue.value.value, (void*)(uintptr_t)attr, attr_type);
+        UA_Variant_setScalar(&wvalue.value.value,
+                             (void*)(uintptr_t)attr, attr_type);
     } else {
         wvalue.value.value = *(const UA_Variant*)attr;
     }