Style fixes for /common

1 files changed, 953 insertions, 790 deletions

diff --git a/common/collection/collection.c b/common/collection/collection.c
index 4a5b50443..79e4421ff 100644
--- a/common/collection/collection.c
+++ b/common/collection/collection.c
@@ -89,27 +89,27 @@ typedef int (*internal_item_fn)(struct collection_item *head,
                                 void *custom_data,
                                 int *stop);
 
-/******************** SUPPLIMENTARY FUNCTIONS ****************************/
+/******************** SUPPLEMENTARY FUNCTIONS ****************************/
 
 
 /* BASIC OPERATIONS */
 /* Function that checks if property can be added */
 static int validate_property(char *property)
 {
-    TRACE_FLOW_STRING("validate_property","Entry point.");
+    TRACE_FLOW_STRING("validate_property", "Entry point.");
     /* Only alpha numeric characters are allowed in names of the properties */
     int invalid = 0;
     char *check;
 
     check = property;
-    while(*check != '\0') {
-        if((!isalnum((int)(*check))) && (!ispunct((int)(*check)))) {
+    while (*check != '\0') {
+        if ((!isalnum(*check)) && (!ispunct(*check))) {
             invalid = 1;
             break;
         }
         check++;
     }
-    TRACE_FLOW_NUMBER("validate_property. Returning ",invalid);
+    TRACE_FLOW_NUMBER("validate_property. Returning ", invalid);
     return invalid;
 }
 
@@ -120,10 +120,10 @@ static void delete_item(struct collection_item *item)
 {
     TRACE_FLOW_STRING("delete_item","Entry point.");
 
-    if(item == (struct collection_item *)NULL) return;
+    if (item == NULL) return;
 
-    if(item->property != NULL) free(item->property);
-    if(item->data != NULL) free(item->data);
+    if (item->property != NULL) free(item->property);
+    if (item->data != NULL) free(item->data);
 
     free(item);
 
@@ -131,42 +131,43 @@ static void delete_item(struct collection_item *item)
 }
 
 /* A generic function to allocate a property item */
-static int allocate_item(struct collection_item **ci,char *property,void *item_data,int length, int type)
+static int allocate_item(struct collection_item **ci, char *property,
+                         void *item_data,int length, int type)
 {
     struct collection_item *item = NULL;
     int error = 0;
     errno = 0;
 
-    TRACE_FLOW_STRING("allocate_item","Entry point.");
-    TRACE_INFO_NUMBER("Will be using type:",type);
+    TRACE_FLOW_STRING("allocate_item", "Entry point.");
+    TRACE_INFO_NUMBER("Will be using type:", type);
 
     /* Check the length */
-    if(length >= COL_MAX_DATA) {
-        TRACE_ERROR_STRING("allocate_item","Data to long.");
+    if (length >= COL_MAX_DATA) {
+        TRACE_ERROR_STRING("allocate_item", "Data to long.");
         return EMSGSIZE;
     }
 
-    if(validate_property(property)) {
-        TRACE_ERROR_STRING("Invalid chracters in the property name",property);
+    if (validate_property(property)) {
+        TRACE_ERROR_STRING("Invalid chracters in the property name", property);
         return EINVAL;
     }
 
     /* Allocate memory for the structure */
-    item = (struct collection_item *)(malloc(sizeof(struct collection_item)));
-    if(item == (struct collection_item *)(NULL))  {
+    item = (struct collection_item *)malloc(sizeof(struct collection_item));
+    if (item == NULL)  {
         error = errno;
-        TRACE_ERROR_STRING("allocate_item","Malloc failed.");
+        TRACE_ERROR_STRING("allocate_item", "Malloc failed.");
         return error;
     }
 
     /* After we initialize "next" we can use delete_item() in case of error */
-    item->next = (struct collection_item *)(NULL);
+    item->next = NULL;
 
     /* Copy property */
     item->property = strdup(property);
-    if(item->property == NULL) {
+    if (item->property == NULL) {
         error = errno;
-        TRACE_ERROR_STRING("allocate_item","Failed to dup property.");
+        TRACE_ERROR_STRING("allocate_item", "Failed to dup property.");
         delete_item(item);
         return error;
     }
@@ -175,71 +176,74 @@ static int allocate_item(struct collection_item **ci,char *property,void *item_d
 
     /* Deal with data */
     item->data = malloc(length);
-    if(item->data == NULL) {
-        TRACE_ERROR_STRING("allocate_item","Failed to dup data.");
+    if (item->data == NULL) {
+        TRACE_ERROR_STRING("allocate_item", "Failed to dup data.");
         delete_item(item);
         return errno;
     }
-    memcpy(item->data,item_data,length);
+    memcpy(item->data, item_data, length);
 
     /* Deal with other properties of the item */
-    TRACE_INFO_NUMBER("About to set type to:",type);
+    TRACE_INFO_NUMBER("About to set type to:", type);
     item->type = type;
     item->length = length;
 
     /* Make sure that data is NULL terminated in case of string */
-    if(type == COL_TYPE_STRING) *(((char *)(item->data))+length-1) = '\0';
+    if (type == COL_TYPE_STRING) ((char *)(item->data))[length-1] = '\0';
 
     *ci = item;
 
-    TRACE_INFO_STRING("Item property",item->property);
-    TRACE_INFO_NUMBER("Item property type",item->type);
-    TRACE_INFO_NUMBER("Item data length",item->length);
-    TRACE_FLOW_STRING("allocate_item","Success exit.");
+    TRACE_INFO_STRING("Item property", item->property);
+    TRACE_INFO_NUMBER("Item property type", item->type);
+    TRACE_INFO_NUMBER("Item data length", item->length);
+    TRACE_FLOW_STRING("allocate_item", "Success exit.");
     return 0;
 }
 
 /* Add item to the end of collection */
 /* Can add itself to itself - nice...*/
-static int add_item_to_collection(struct collection_item *collection,struct collection_item *item)
+static int add_item_to_collection(struct collection_item *collection,
+                                  struct collection_item *item)
 {
     struct collection_header *header;
 
-    TRACE_FLOW_STRING("add_item_to_collection","Entry point.");
+    TRACE_FLOW_STRING("add_item_to_collection", "Entry point.");
 
-    if(collection == (struct collection_item *)(NULL)) {
-        TRACE_INFO_STRING("add_item_to_collection","Collection accepting is NULL");
-        if((item != (struct collection_item *)(NULL)) &&
-           (item->type == COL_TYPE_COLLECTION)) {
+    if (collection == NULL) {
+        TRACE_INFO_STRING("add_item_to_collection",
+                          "Collection accepting is NULL");
+        if ((item != NULL) && (item->type == COL_TYPE_COLLECTION)) {
             /* This is a special case of self creation */
-            TRACE_INFO_STRING("add_item_to_collection","Adding header item to new collection.");
+            TRACE_INFO_STRING("add_item_to_collection",
+                              "Adding header item to new collection.");
             collection = item;
         }
     }
 
     /* We can add items only to collections */
-    if(collection->type != COL_TYPE_COLLECTION) {
-        TRACE_ERROR_STRING("add_item_to_collection","Attempt to add item to non collection.");
-        TRACE_ERROR_STRING("Collection name:",collection->property);
-        TRACE_ERROR_NUMBER("Collection type:",collection->type);
+    if (collection->type != COL_TYPE_COLLECTION) {
+        TRACE_ERROR_STRING("add_item_to_collection",
+                           "Attempt to add item to non collection.");
+        TRACE_ERROR_STRING("Collection name:", collection->property);
+        TRACE_ERROR_NUMBER("Collection type:", collection->type);
         return EINVAL;
     }
 
-    header = (struct collection_header *)(collection->data);
+    header = (struct collection_header *)collection->data;
 
     /* Link new item to the last item in the list if there any */
-    if(header->last != (struct collection_item *)(NULL)) (header->last)->next = item;
+    if (header->last != NULL) header->last->next = item;
 
     /* Make sure we save a new last element */
     header->last = item;
     header->count++;
 
-    TRACE_INFO_STRING("Collection:",collection->property);
-    TRACE_INFO_STRING("Just added item is:",item->property);
-    TRACE_INFO_NUMBER("Item type.",item->type);
-    TRACE_INFO_NUMBER("Number of items in collection now is.",header->count);
+    TRACE_INFO_STRING("Collection:", collection->property);
+    TRACE_INFO_STRING("Just added item is:", item->property);
+    TRACE_INFO_NUMBER("Item type.", item->type);
+    TRACE_INFO_NUMBER("Number of items in collection now is.", header->count);
 
-    TRACE_FLOW_STRING("add_item_to_collection","Success exit.");
+    TRACE_FLOW_STRING("add_item_to_collection", "Success exit.");
     return EOK;
 }
 
@@ -255,15 +259,15 @@ inline static int is_in_item_handler(char *property,
                                      void *found,
                                      int *dummy)
 {
-    TRACE_FLOW_STRING("is_in_item_handler","Entry.");
-    TRACE_INFO_STRING("Property:",property);
-    TRACE_INFO_NUMBER("Property length:",property_len);
-    TRACE_INFO_NUMBER("Type:",type);
-    TRACE_INFO_NUMBER("Length:",length);
+    TRACE_FLOW_STRING("is_in_item_handler", "Entry.");
+    TRACE_INFO_STRING("Property:", property);
+    TRACE_INFO_NUMBER("Property length:", property_len);
+    TRACE_INFO_NUMBER("Type:", type);
+    TRACE_INFO_NUMBER("Length:", length);
 
     *((int *)(found)) = COL_MATCH;
 
-    TRACE_FLOW_STRING("is_in_item_handler","Success Exit.");
+    TRACE_FLOW_STRING("is_in_item_handler", "Success Exit.");
 
     return EOK;
 }
@@ -277,11 +281,11 @@ inline static int get_subcollection(char *property,
                                     void *found,
                                     int *dummy)
 {
-    TRACE_FLOW_STRING("get_subcollection","Entry.");
-    TRACE_INFO_STRING("Property:",property);
-    TRACE_INFO_NUMBER("Property length:",property_len);
-    TRACE_INFO_NUMBER("Type:",type);
-    TRACE_INFO_NUMBER("Length:",length);
+    TRACE_FLOW_STRING("get_subcollection", "Entry.");
+    TRACE_INFO_STRING("Property:", property);
+    TRACE_INFO_NUMBER("Property length:", property_len);
+    TRACE_INFO_NUMBER("Type:", type);
+    TRACE_INFO_NUMBER("Length:", length);
 
     *((struct collection_item **)(found)) = *((struct collection_item **)(data));
 
@@ -294,7 +298,8 @@ inline static int get_subcollection(char *property,
 
 /* ADD PROPERTY */
 
-/* Add a single property to a collection. Returns a pointer to a newly allocated property */
+/* Add a single property to a collection.
+ * Returns a pointer to a newly allocated property */
 static struct collection_item *add_property(struct collection_item *collection,
                                             char *subcollection,
                                             char *property,
@@ -303,63 +308,68 @@ static struct collection_item *add_property(struct collection_item *collection,
                                             int type,
                                             int *error)
 {
-    struct collection_item *item = (struct collection_item *) NULL;
-    struct collection_item *acceptor = (struct collection_item *)(NULL);
+    struct collection_item *item = NULL;
+    struct collection_item *acceptor = NULL;
 
-    TRACE_FLOW_STRING("add_property","Entry.");
+    TRACE_FLOW_STRING("add_property", "Entry.");
     /* Allocate item */
 
-    TRACE_INFO_NUMBER("Property type to add",type);
-    *error = allocate_item(&item,property,item_data,length, type);
-    if(*error) return (struct collection_item *)(NULL);
+    TRACE_INFO_NUMBER("Property type to add", type);
+    *error = allocate_item(&item, property, item_data, length, type);
+    if (*error) return NULL;
 
-    TRACE_INFO_STRING("Created item:",item->property);
-    TRACE_INFO_NUMBER("Item has type:",item->type);
+    TRACE_INFO_STRING("Created item:", item->property);
+    TRACE_INFO_NUMBER("Item has type:", item->type);
 
     /* Add item to collection */
-    if(subcollection == NULL) acceptor = collection;
+    if (subcollection == NULL) {
+        acceptor = collection;
+    }
     else {
-        TRACE_INFO_STRING("Subcollection id not null, searching",subcollection);
-        *error = find_item_and_do(collection, subcollection, COL_TYPE_COLLECTIONREF,
+        TRACE_INFO_STRING("Subcollection id not null, searching", subcollection);
+        *error = find_item_and_do(collection, subcollection,
+                                  COL_TYPE_COLLECTIONREF,
                                   COL_TRAVERSE_DEFAULT,
-                                  get_subcollection,(void *)(&acceptor),COLLECTION_ACTION_FIND);
-        if(*error) {
-            TRACE_ERROR_NUMBER("Search for subcollection returned error:",*error);
+                                  get_subcollection, (void *)(&acceptor),
+                                  COLLECTION_ACTION_FIND);
+        if (*error) {
+            TRACE_ERROR_NUMBER("Search for subcollection returned error:", *error);
             delete_item(item);
-            return (struct collection_item *)(NULL);
+            return NULL;
         }
 
-        if(acceptor == (struct collection_item *)(NULL)) {
-            TRACE_ERROR_STRING("Search for subcollection returned NULL pointer","");
+        if (acceptor == NULL) {
+            TRACE_ERROR_STRING("Search for subcollection returned NULL pointer", "");
             delete_item(item);
-            *error=ENOENT;
-            return (struct collection_item *)(NULL);
+            *error = ENOENT;
+            return NULL;
         }
 
     }
-    *error = add_item_to_collection(acceptor,item);
-    if(*error) {
-        TRACE_ERROR_NUMBER("Failed to add item to collection error:",*error);
+    *error = add_item_to_collection(acceptor, item);
+    if (*error) {
+        TRACE_ERROR_NUMBER("Failed to add item to collection error:", *error);
         delete_item(item);
-        return (struct collection_item *)(NULL);
+        return NULL;
     }
 
-    TRACE_FLOW_STRING("add_property","Success Exit.");
+    TRACE_FLOW_STRING("add_property", "Success Exit.");
     return item;
 }
 
 /* CLEANUP */
 
 /* Cleans the collection tree including current item. */
-/* After the execution passed in variable should not be used - memory is gone!!! */
+/* The passed in variable should not be used after the call
+ * as memory is freed!!! */
 static void delete_collection(struct collection_item *ci)
 {
     struct collection_item *other_collection;
 
-    TRACE_FLOW_STRING("delete_collection","Entry.");
+    TRACE_FLOW_STRING("delete_collection", "Entry.");
 
-    if(ci == (struct collection_item *)(NULL)) {
-        TRACE_FLOW_STRING("delete_collection","Nothing to do Exit.");
+    if (ci == NULL) {
+        TRACE_FLOW_STRING("delete_collection", "Nothing to do Exit.");
         return;
     }
 
@@ -369,14 +379,15 @@ static void delete_collection(struct collection_item *ci)
 
     /* Handle external or embedded collection */
     if(ci->type == COL_TYPE_COLLECTIONREF)  {
-        /* Our data is a pointer to a whole external collection so dereference it or delete */
+        /* Our data is a pointer to a whole external collection so dereference
+         * it or delete */
         other_collection = *((struct collection_item **)(ci->data));
         destroy_collection(other_collection);
     }
 
     /* Delete this item */
     delete_item(ci);
-    TRACE_FLOW_STRING("delete_collection","Exit.");
+    TRACE_FLOW_STRING("delete_collection", "Exit.");
 }
 
 
@@ -408,21 +419,21 @@ static int create_path_data(struct path_data **name_path,
     int error = EOK;
     struct path_data *new_name_path;
 
-    TRACE_FLOW_STRING("create_path_data","Entry.");
+    TRACE_FLOW_STRING("create_path_data", "Entry.");
 
-    TRACE_INFO_STRING("Constructing path from name:",name);
-    TRACE_INFO_STRING("Constructing path from property:",property);
+    TRACE_INFO_STRING("Constructing path from name:", name);
+    TRACE_INFO_STRING("Constructing path from property:", property);
 
     /* Allocate structure */
     errno = 0;
-    new_name_path = (struct path_data *)(malloc(sizeof(struct path_data)));
-    if(new_name_path == (struct path_data *)(NULL)) return errno;
+    new_name_path = (struct path_data *)malloc(sizeof(struct path_data));
+    if (new_name_path == NULL) return errno;
 
-    new_name_path->name=malloc(length+property_len+2);
-    if(new_name_path->name == NULL) {
+    new_name_path->name = malloc(length + property_len + 2);
+    if (new_name_path->name == NULL) {
         error = errno;
-        TRACE_ERROR_NUMBER("Failed to allocate memory for new path name. Errno",error);
-        free((void *)(new_name_path));
+        TRACE_ERROR_NUMBER("Failed to allocate memory for new path name. Errno", error);
+        free(new_name_path);
         return error;
     }
 
@@ -430,26 +441,26 @@ static int create_path_data(struct path_data **name_path,
     new_name_path->length = 0;
 
     if(length > 0) {
-        memcpy(new_name_path->name,name,length);
+        memcpy(new_name_path->name, name, length);
         new_name_path->length = length;
-        *(new_name_path->name+new_name_path->length) = '.';
+        new_name_path->name[new_name_path->length] = '.';
         new_name_path->length++;
-        *(new_name_path->name+new_name_path->length) = '\0';
-        TRACE_INFO_STRING("Name so far:",new_name_path->name);
-        TRACE_INFO_NUMBER("Len so far:",new_name_path->length);
+        new_name_path->name[new_name_path->length] = '\0';
+        TRACE_INFO_STRING("Name so far:", new_name_path->name);
+        TRACE_INFO_NUMBER("Len so far:", new_name_path->length);
     }
-    memcpy(new_name_path->name+new_name_path->length,property,property_len);
+    memcpy(&new_name_path->name[new_name_path->length], property, property_len);
     new_name_path->length += property_len;
-    *(new_name_path->name + new_name_path->length) = '\0';
+    new_name_path->name[new_name_path->length] = '\0';
 
     /* Link to the chain */
     new_name_path->previous_path = *name_path;
     *name_path = new_name_path;
 
-    TRACE_INFO_STRING("Constructed path",new_name_path->name);
+    TRACE_INFO_STRING("Constructed path", new_name_path->name);
 
 
-    TRACE_FLOW_NUMBER("create_path_data. Returning:",error);
+    TRACE_FLOW_NUMBER("create_path_data. Returning:", error);
     return error;
 }
 
@@ -462,13 +473,14 @@ static int match_item(struct collection_item *current,
     char *start;
     char *data_str;
 
-    TRACE_FLOW_STRING("match_item","Entry");
+    TRACE_FLOW_STRING("match_item", "Entry");
 
-    if(traverse_data->type_to_match & current->type) {
+    if (traverse_data->type_to_match & current->type) {
         /* Check if there is any value to match */
-        if((traverse_data->name_to_find == NULL) ||
-           (*(traverse_data->name_to_find) == '\0')) {
-            TRACE_INFO_STRING("match_item","Returning MATCH because there is no search criteria!");
+        if ((traverse_data->name_to_find == NULL) ||
+            (*(traverse_data->name_to_find) == '\0')) {
+            TRACE_INFO_STRING("match_item",
+                              "Returning MATCH because there is no search criteria!");
             return COL_MATCH;
         }
 
@@ -477,26 +489,27 @@ static int match_item(struct collection_item *current,
         start = current->property;
         data_str = start + current->property_len;
 
-        TRACE_INFO_STRING("Searching for:",traverse_data->name_to_find);
-        TRACE_INFO_STRING("Item name:",current->property);
-        TRACE_INFO_STRING("Current path:",traverse_data->current_path->name);
-        TRACE_INFO_NUMBER("Searching:",toupper(*find_str));
-        TRACE_INFO_NUMBER("Have:",toupper(*data_str));
+        TRACE_INFO_STRING("Searching for:", traverse_data->name_to_find);
+        TRACE_INFO_STRING("Item name:", current->property);
+        TRACE_INFO_STRING("Current path:", traverse_data->current_path->name);
+        TRACE_INFO_NUMBER("Searching:", toupper(*find_str));
+        TRACE_INFO_NUMBER("Have:", toupper(*data_str));
 
         /* We start pointing to 0 so the loop will be executed at least once */
-        while(toupper(*data_str) == toupper(*find_str)) {
+        while (toupper(*data_str) == toupper(*find_str)) {
 
             TRACE_INFO_STRING("Loop iteration:","");
 
-            if(data_str == start) {
-                if(find_str > traverse_data->name_to_find) {
-                    if(*(find_str-1) == '.') {
-                        /* We matched the property but the search string is longer */
-                        /* so we need to continue matching */
-                        TRACE_INFO_STRING("match_item","Need to continue matching");
+            if (data_str == start) {
+                if (find_str > traverse_data->name_to_find) {
+                    if (*(find_str-1) == '.') {
+                        /* We matched the property but the search string is
+                         * longer so we need to continue matching */
+                        TRACE_INFO_STRING("match_item",
+                                          "Need to continue matching");
                         start = traverse_data->current_path->name;
-                        data_str = start + traverse_data->current_path->length - 1;
-                        find_str-=2;
+                        data_str = &start[traverse_data->current_path->length - 1];
+                        find_str -= 2;
                         continue;
                     }
                     else {
@@ -509,13 +522,13 @@ static int match_item(struct collection_item *current,
                     return COL_MATCH;
                 }
             }
-            else if((find_str == traverse_data->name_to_find) &&
-                    (*(data_str-1) == '.')) return COL_MATCH;
+            else if ((find_str == traverse_data->name_to_find) &&
+                     (*(data_str-1) == '.')) return COL_MATCH;
 
             data_str--;
             find_str--;
-             TRACE_INFO_NUMBER("Searching:",toupper(*find_str));
-            TRACE_INFO_NUMBER("Have:",toupper(*data_str));
+             TRACE_INFO_NUMBER("Searching:", toupper(*find_str));
+            TRACE_INFO_NUMBER("Have:", toupper(*data_str));
 
         }
     }
@@ -530,20 +543,21 @@ static void delete_path_data(struct path_data *path)
 {
     TRACE_FLOW_STRING("delete_path_data","Entry.");
 
-    if(path!= (struct path_data *)(NULL)) {
-        TRACE_INFO_STRING("delete_path_data","Item to delete exits.");
-        if(path->previous_path != (struct path_data *)(NULL)) {
-            TRACE_INFO_STRING("delete_path_data","But previous item to delete exits to. Nesting.");
+    if (path != NULL) {
+        TRACE_INFO_STRING("delete_path_data", "Item to delete exits.");
+        if (path->previous_path != NULL) {
+            TRACE_INFO_STRING("delete_path_data",
+                              "But previous item to delete exits to. Nesting.");
             delete_path_data(path->previous_path);
         }
-        if(path->name != NULL) {
-            TRACE_INFO_STRING("delete_path_data Deleting path:",path->name);
+        if (path->name != NULL) {
+            TRACE_INFO_STRING("delete_path_data Deleting path:", path->name);
             free(path->name);
         }
-        TRACE_INFO_STRING("delete_path_data","Deleting path element");
-        free((void *)(path));
+        TRACE_INFO_STRING("delete_path_data", "Deleting path element");
+        free(path);
     }
-    TRACE_FLOW_STRING("delete_path_data","Exit");
+    TRACE_FLOW_STRING("delete_path_data", "Exit");
 }
 
 
@@ -567,71 +581,75 @@ static int walk_items(struct collection_item *ci,
     int stop = 0;
     int error = EOK;
 
-    TRACE_FLOW_STRING("walk_items","Entry.");
-    TRACE_INFO_NUMBER("Mode flags:",mode_flags);
+    TRACE_FLOW_STRING("walk_items", "Entry.");
+    TRACE_INFO_NUMBER("Mode flags:", mode_flags);
 
     current = ci;
 
-    while(current != (struct collection_item *)(NULL)) {
+    while (current) {
 
-        TRACE_INFO_STRING("Processing item:",current->property);
-        TRACE_INFO_NUMBER("Item type:",current->type);
+        TRACE_INFO_STRING("Processing item:", current->property);
+        TRACE_INFO_NUMBER("Item type:", current->type);
 
-        if(current->type == COL_TYPE_COLLECTIONREF) {
+        if (current->type == COL_TYPE_COLLECTIONREF) {
 
-            TRACE_INFO_STRING("Subcollection:",current->property);
+            TRACE_INFO_STRING("Subcollection:", current->property);
 
-            if((mode_flags & COL_TRAVERSE_IGNORE) == 0) {
+            if ((mode_flags & COL_TRAVERSE_IGNORE) == 0) {
 
-                TRACE_INFO_STRING("Subcollection is not ignored.","");
+                TRACE_INFO_STRING("Subcollection is not ignored.", "");
 
                 /* We are not ignoring sub collections */
-                error = traverse_handler(ci,parent,current,traverse_data,user_item_handler,custom_data,&stop);
-                if(stop != 0) {
-                    TRACE_INFO_STRING("Traverse handler returned STOP.","");
+                error = traverse_handler(ci, parent, current, traverse_data,
+                                         user_item_handler, custom_data, &stop);
+                if (stop != 0) {
+                    TRACE_INFO_STRING("Traverse handler returned STOP.", "");
                     error = EINTR_INTERNAL;
                 }
                 /* Check what error we got */
-                if(error == EINTR_INTERNAL) {
-                    TRACE_FLOW_NUMBER("Internal error - means we are stopping.",error);
+                if (error == EINTR_INTERNAL) {
+                    TRACE_FLOW_NUMBER("Internal error - means we are stopping.", error);
                     return error;
                 }
-                else if(error) {
-                    TRACE_ERROR_NUMBER("Traverse handler returned error.",error);
+                else if (error) {
+                    TRACE_ERROR_NUMBER("Traverse handler returned error.", error);
                     return error;
                 }
 
-                if((mode_flags & COL_TRAVERSE_ONELEVEL) == 0) {
+                if ((mode_flags & COL_TRAVERSE_ONELEVEL) == 0) {
                     TRACE_INFO_STRING("Before diving into sub collection","");
                     sub = *((struct collection_item **)(current->data));
-                    TRACE_INFO_STRING("Sub collection name",sub->property);
-                    TRACE_INFO_NUMBER("Header type",sub->type);
+                    TRACE_INFO_STRING("Sub collection name", sub->property);
+                    TRACE_INFO_NUMBER("Header type", sub->type);
                     /* We need to go into sub collections */
-                    error = walk_items(sub, mode_flags,traverse_handler,traverse_data,
+                    error = walk_items(sub, mode_flags,
+                                       traverse_handler, traverse_data,
                                        user_item_handler, custom_data);
-                    TRACE_INFO_STRING("Returned from sub collection processing","");
-                    TRACE_INFO_STRING("Done processing item:",current->property);
-                    TRACE_INFO_NUMBER("Done processing item type:",current->type);
+                    TRACE_INFO_STRING("Returned from sub collection processing", "");
+                    TRACE_INFO_STRING("Done processing item:", current->property);
+                    TRACE_INFO_NUMBER("Done processing item type:", current->type);
 
                 }
             }
         }
         else
             /* Call handler then move on */
-            error = traverse_handler(ci,parent,current,traverse_data,user_item_handler,custom_data,&stop);
+            error = traverse_handler(ci, parent, current,
+                                     traverse_data, user_item_handler,
+                                     custom_data, &stop);
 
         /* If we are stopped - return EINTR_INTERNAL */
-        if(stop != 0) {
-            TRACE_INFO_STRING("Traverse handler returned STOP.","");
+        if (stop != 0) {
+            TRACE_INFO_STRING("Traverse handler returned STOP.", "");
             error = EINTR_INTERNAL;
         }
         /* Check what error we got */
-        if(error == EINTR_INTERNAL) {
-            TRACE_FLOW_NUMBER("Internal error - means we are stopping.",error);
+        if (error == EINTR_INTERNAL) {
+            TRACE_FLOW_NUMBER("Internal error - means we are stopping.", error);
             return error;
         }
-        else if(error) {
-            TRACE_ERROR_NUMBER("Traverse handler returned error.",error);
+        else if (error) {
+            TRACE_ERROR_NUMBER("Traverse handler returned error.", error);
             return error;
         }
 
@@ -640,14 +658,16 @@ static int walk_items(struct collection_item *ci,
 
     }
 
-    TRACE_INFO_STRING("Out of loop","");
+    TRACE_INFO_STRING("Out of loop", "");
 
-    if((mode_flags & COL_TRAVERSE_END) != 0) {
-        TRACE_INFO_STRING("About to do the special end collection invocation of handler","");
-        error = traverse_handler(ci,parent,current,traverse_data,user_item_handler,custom_data,&stop);
+    if ((mode_flags & COL_TRAVERSE_END) != 0) {
+        TRACE_INFO_STRING("About to do the special end collection invocation of handler", "");
+        error = traverse_handler(ci, parent, current,
+                                 traverse_data, user_item_handler,
+                                 custom_data, &stop);
     }
 
-    TRACE_FLOW_NUMBER("walk_items. Returns: ",error);
+    TRACE_FLOW_NUMBER("walk_items. Returns: ", error);
     return error;
 }
 
@@ -670,62 +690,64 @@ static int find_item_and_do(struct collection_item *ci,
     int error = EOK;
     struct find_name *traverse_data = NULL;
 
-    TRACE_FLOW_STRING("find_item_and_do","Entry.");
+    TRACE_FLOW_STRING("find_item_and_do", "Entry.");
 
     /* Item handler is always required */
-    if((item_handler == (item_fn)(NULL)) && (action ==COLLECTION_ACTION_FIND)) {
-        TRACE_ERROR_NUMBER("No item handler - returning error!",EINVAL);
+    if ((item_handler == NULL) &&
+        (action == COLLECTION_ACTION_FIND)) {
+        TRACE_ERROR_NUMBER("No item handler - returning error!", EINVAL);
         return EINVAL;
     }
 
     /* Make sure that there is anything to search */
     type &= COL_TYPE_ANY;
-    if((ci == (struct collection_item *)(NULL)) ||
-       ((property_to_find == NULL) && (type == 0)) ||
-       ((*property_to_find == '\0') && (type == 0))) {
-        TRACE_ERROR_NUMBER("No item search criteria specified - returning error!",ENOKEY);
+    if ((ci == NULL) ||
+        ((property_to_find == NULL) && (type == 0)) ||
+        ((*property_to_find == '\0') && (type == 0))) {
+        TRACE_ERROR_NUMBER("No item search criteria specified - returning error!", ENOKEY);
         return ENOKEY;
     }
     /* Prepare data for traversal */
     errno = 0;
-    traverse_data= (struct find_name *)(malloc(sizeof(struct find_name)));
-    if(traverse_data == (struct find_name *)(NULL)) {
+    traverse_data= (struct find_name *)malloc(sizeof(struct find_name));
+    if (traverse_data == NULL) {
         error = errno;
-        TRACE_ERROR_NUMBER("Failed to allocate traverse data memory - returning error!",errno);
+        TRACE_ERROR_NUMBER("Failed to allocate traverse data memory - returning error!", errno);
         return error;
     }
 
-    TRACE_INFO_STRING("find_item_and_do","Filling in traverse data.");
+    TRACE_INFO_STRING("find_item_and_do", "Filling in traverse data.");
 
     traverse_data->name_to_find = property_to_find;
     traverse_data->name_len_to_find = strlen(property_to_find);
     traverse_data->type_to_match = type;
     traverse_data->given_name = NULL;
     traverse_data->given_len = 0;
-    traverse_data->current_path = (struct path_data *)(NULL);
+    traverse_data->current_path = NULL;
     traverse_data->action = action;
 
     mode_flags |= COL_TRAVERSE_END;
 
-    TRACE_INFO_STRING("find_item_and_do","About to walk the tree.");
-    TRACE_INFO_NUMBER("Traverse flags",mode_flags);
+    TRACE_INFO_STRING("find_item_and_do", "About to walk the tree.");
+    TRACE_INFO_NUMBER("Traverse flags", mode_flags);
 
     error = walk_items(ci, mode_flags, act_traverse_handler,
                        (void *)traverse_data, item_handler, custom_data);
 
-    if(traverse_data->current_path != (struct path_data *)(NULL)) {
-        TRACE_INFO_STRING("find_item_and_do","Path was not cleared - deleting");
+    if (traverse_data->current_path != NULL) {
+        TRACE_INFO_STRING("find_item_and_do",
+                          "Path was not cleared - deleting");
         delete_path_data(traverse_data->current_path);
     }
 
-    free((void *)(traverse_data));
+    free(traverse_data);
 
-    if((error) && (error != EINTR_INTERNAL)) {
-        TRACE_ERROR_NUMBER("Walk items returned error. Returning: ",error);
+    if (error && (error != EINTR_INTERNAL)) {
+        TRACE_ERROR_NUMBER("Walk items returned error. Returning: ", error);
         return error;
     }
     else {
-        TRACE_FLOW_STRING("Walk items returned SUCCESS.","");
+        TRACE_FLOW_STRING("Walk items returned SUCCESS.", "");
         return EOK;
     }
 }
@@ -734,30 +756,33 @@ static int find_item_and_do(struct collection_item *ci,
 static int update_current_item(struct collection_item *current,
                                struct update_property *update_data)
 {
-    TRACE_FLOW_STRING("update_current_item","Entry");
+    TRACE_FLOW_STRING("update_current_item", "Entry");
 
-    /* If type is different or same but it is string or binary we need to replace the storage */
-    if((current->type != update_data->type) ||
-       ((current->type == update_data->type) &&
-       ((current->type == COL_TYPE_STRING) || (current->type == COL_TYPE_BINARY)))) {
-        TRACE_INFO_STRING("Replacing item data buffer","");
+    /* If type is different or same but it is string or binary we need to
+     * replace the storage */
+    if ((current->type != update_data->type) ||
+        ((current->type == update_data->type) &&
+        ((current->type == COL_TYPE_STRING) ||
+         (current->type == COL_TYPE_BINARY)))) {
+        TRACE_INFO_STRING("Replacing item data buffer", "");
         free(current->data);
         current->data = malloc(update_data->length);
-        if(current->data == NULL) {
-            TRACE_ERROR_STRING("Failed to allocate memory","");
+        if (current->data == NULL) {
+            TRACE_ERROR_STRING("Failed to allocate memory", "");
             current->length = 0;
             return ENOMEM;
         }
         current->length = update_data->length;
     }
 
-    TRACE_INFO_STRING("Overwriting item data","");
-    memcpy(current->data,update_data->data,current->length);
+    TRACE_INFO_STRING("Overwriting item data", "");
+    memcpy(current->data, update_data->data, current->length);
     current->type = update_data->type;
 
-    if(current->type == COL_TYPE_STRING) *(((char *)(current->data))+current->length-1) = '\0';
+    if (current->type == COL_TYPE_STRING)
+        ((char *)(current->data))[current->length-1] = '\0';
 
-    TRACE_FLOW_STRING("update_current_item","Exit");
+    TRACE_FLOW_STRING("update_current_item", "Exit");
     return EOK;
 }
 
@@ -775,9 +800,9 @@ inline static int simple_traverse_handler(struct collection_item *head,
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("simple_traverse_handler","Entry.");
+    TRACE_FLOW_STRING("simple_traverse_handler", "Entry.");
 
-    if(current == (struct collection_item *)(NULL)) current = &dummy;
+    if (current == NULL) current = &dummy;
 
     error = user_item_handler(current->property,
                               current->property_len,
@@ -787,7 +812,7 @@ inline static int simple_traverse_handler(struct collection_item *head,
                               custom_data,
                               stop);
 
-    TRACE_FLOW_NUMBER("simple_traverse_handler. Returning:",error);
+    TRACE_FLOW_NUMBER("simple_traverse_handler. Returning:", error);
     return error;
 }
 
@@ -812,16 +837,17 @@ static int act_traverse_handler(struct collection_item *head,
     int property_len;
     struct update_property *update_data;
 
-    TRACE_FLOW_STRING("act_traverse_handler","Entry.");
+    TRACE_FLOW_STRING("act_traverse_handler", "Entry.");
 
-    traverse_data = (struct find_name *)(passed_traverse_data);
+    traverse_data = (struct find_name *)passed_traverse_data;
 
     /* We can be called when current points to NULL */
-    if(current==(struct collection_item *)(NULL)) {
-        TRACE_INFO_STRING("act_traverse_handler","Special call at the end of the collection.");
+    if (current == NULL) {
+        TRACE_INFO_STRING("act_traverse_handler",
+                          "Special call at the end of the collection.");
         temp = traverse_data->current_path;
         traverse_data->current_path = temp->previous_path;
-        temp->previous_path = (struct path_data *)(NULL);
+        temp->previous_path = NULL;
         delete_path_data(temp);
         traverse_data->given_name = NULL;
         traverse_data->given_len = 0;
@@ -830,24 +856,25 @@ static int act_traverse_handler(struct collection_item *head,
     }
 
     /* Create new path at the beginning of a new sub collection */
-    if(current->type == COL_TYPE_COLLECTION) {
+    if (current->type == COL_TYPE_COLLECTION) {
 
-        TRACE_INFO_STRING("act_traverse_handler","Processing collection handle.");
+        TRACE_INFO_STRING("act_traverse_handler",
+                          "Processing collection handle.");
 
         /* Create new path */
-        if(traverse_data->current_path != (struct path_data *)(NULL)) {
-            TRACE_INFO_STRING("Already have part of the path","");
-            name = (traverse_data->current_path)->name;
-            length = (traverse_data->current_path)->length;
-            TRACE_INFO_STRING("Path:",name);
-            TRACE_INFO_NUMBER("Path len:",length);
+        if (traverse_data->current_path != NULL) {
+            TRACE_INFO_STRING("Already have part of the path", "");
+            name = traverse_data->current_path->name;
+            length = traverse_data->current_path->length;
+            TRACE_INFO_STRING("Path:", name);
+            TRACE_INFO_NUMBER("Path len:", length);
         }
         else {
             name = NULL;
             length = 0;
         }
 
-        if(traverse_data->given_name != NULL) {
+        if (traverse_data->given_name != NULL) {
             property = traverse_data->given_name;
             property_len = traverse_data->given_len;
         }
@@ -856,101 +883,108 @@ static int act_traverse_handler(struct collection_item *head,
             property_len = current->property_len;
         }
 
-        TRACE_INFO_STRING("act_traverse_handler","About to create path data.");
+        TRACE_INFO_STRING("act_traverse_handler", "About to create path data.");
 
         error = create_path_data(&(traverse_data->current_path),
-                                 name, length, property,property_len);
+                                 name, length, property, property_len);
 
         TRACE_INFO_NUMBER("create_path_data returned:", error);
         return error;
     }
 
     /* Handle the collection pointers */
-    if(current->type == COL_TYPE_COLLECTIONREF) {
+    if (current->type == COL_TYPE_COLLECTIONREF) {
         traverse_data->given_name = current->property;
         traverse_data->given_len = current->property_len;
-        TRACE_INFO_STRING("Saved given name:",traverse_data->given_name);
+        TRACE_INFO_STRING("Saved given name:", traverse_data->given_name);
     }
 
-    TRACE_INFO_STRING("Processing item with property:",current->property);
+    TRACE_INFO_STRING("Processing item with property:", current->property);
 
     /* Do here what we do with items */
-    if(match_item(current,traverse_data)) {
-        TRACE_INFO_STRING("Matched item:",current->property);
-        switch(traverse_data->action) {
-            case COLLECTION_ACTION_FIND:
-                TRACE_INFO_STRING("It is a find action - calling handler.","");
-                if(user_item_handler != (item_fn)(NULL)) {
-                    /* Call user handler */
-                    error = user_item_handler(current->property,
-                                              current->property_len,
-                                              current->type,
-                                              current->data,
-                                              current->length,
-                                              custom_data,
-                                              stop);
-
-                    TRACE_INFO_NUMBER("Handler returned:",error);
-                    TRACE_INFO_NUMBER("Handler set STOP to:",*stop);
+    if (match_item(current, traverse_data)) {
+        TRACE_INFO_STRING("Matched item:", current->property);
+        switch (traverse_data->action) {
+        case COLLECTION_ACTION_FIND:
+            TRACE_INFO_STRING("It is a find action - calling handler.", "");
+            if (user_item_handler != NULL) {
+                /* Call user handler */
+                error = user_item_handler(current->property,
+                                          current->property_len,
+                                          current->type,
+                                          current->data,
+                                          current->length,
+                                          custom_data,
+                                          stop);
+
+                TRACE_INFO_NUMBER("Handler returned:", error);
+                TRACE_INFO_NUMBER("Handler set STOP to:", *stop);
 
-                }
-                break;
-            case COLLECTION_ACTION_GET:
-                TRACE_INFO_STRING("It is a get action.","");
-                if(custom_data != NULL) *((struct collection_item **)(custom_data)) = current;
-                break;
-            case COLLECTION_ACTION_DEL:
-                TRACE_INFO_STRING("It is a delete action.","");
-                /* Make sure we tell the caller we found a match */
-                if(custom_data != NULL) *(int *)(custom_data) = COL_MATCH;
-                /* Dereference external collections */
-                if(current->type == COL_TYPE_COLLECTIONREF) {
-                    TRACE_INFO_STRING("Dereferencing a referenced collection.","");
-                    other = *((struct collection_item **)(current->data));
-                    header = (struct collection_header *)(other->data);
-                    destroy_collection(other);
-                }
+            }
+            break;
 
-                /* Adjust header of the collection */
-                header = (struct collection_header *)(head->data);
-                (header->count)--;
-                if(current->next == (struct collection_item *)(NULL)) header->last = previous;
+        case COLLECTION_ACTION_GET:
+            TRACE_INFO_STRING("It is a get action.", "");
+            if (custom_data != NULL)
+                *((struct collection_item **)(custom_data)) = current;
+            break;
 
-                /* Unlink and delete iteam */
-                /* Previous can't be NULL here becuase we never delete header elements */
-                previous->next = current->next;
-                delete_item(current);
-                TRACE_INFO_STRING("Did the delete of the item.","");
-                break;
-            case COLLECTION_ACTION_UPDATE:
-                TRACE_INFO_STRING("It is an update action.","");
-                if((current->type == COL_TYPE_COLLECTION) ||
-                   (current->type == COL_TYPE_COLLECTIONREF)) {
-                    TRACE_ERROR_STRING("Can't update collections it is an error for now","");
-                    return EINVAL;
-                }
+        case COLLECTION_ACTION_DEL:
+            TRACE_INFO_STRING("It is a delete action.", "");
+            /* Make sure we tell the caller we found a match */
+            if (custom_data != NULL)
+                *(int *)custom_data = COL_MATCH;
+            /* Dereference external collections */
+            if (current->type == COL_TYPE_COLLECTIONREF) {
+                TRACE_INFO_STRING("Dereferencing a referenced collection.", "");
+                other = *((struct collection_item **)current->data);
+                header = (struct collection_header *)other->data;
+                destroy_collection(other);
+            }
 
-                /* Make sure we tell the caller we found a match */
-                if(custom_data != NULL) {
-                    update_data = (struct update_property *) custom_data;
-                    update_data-> found = COL_MATCH;
-                    error = update_current_item(current, update_data);
-                }
-                else {
-                    TRACE_ERROR_STRING("Error - update data is required","");
-                    return EINVAL;
-                }
+            /* Adjust header of the collection */
+            header = (struct collection_header *)head->data;
+            header->count--;
+            if (current->next == NULL)
+                header->last = previous;
+
+            /* Unlink and delete iteam */
+            /* Previous can't be NULL here becuase we never delete
+             * header elements */
+            previous->next = current->next;
+            delete_item(current);
+            TRACE_INFO_STRING("Did the delete of the item.", "");
+            break;
 
-                TRACE_INFO_STRING("Did the delete of the item.","");
-                break;
-            default:
-                break;
+        case COLLECTION_ACTION_UPDATE:
+            TRACE_INFO_STRING("It is an update action.", "");
+            if((current->type == COL_TYPE_COLLECTION) ||
+               (current->type == COL_TYPE_COLLECTIONREF)) {
+                TRACE_ERROR_STRING("Can't update collections it is an error for now", "");
+                return EINVAL;
+            }
+
+            /* Make sure we tell the caller we found a match */
+            if (custom_data != NULL) {
+                update_data = (struct update_property *)custom_data;
+                update_data->found = COL_MATCH;
+                error = update_current_item(current, update_data);
+            }
+            else {
+                TRACE_ERROR_STRING("Error - update data is required", "");
+                return EINVAL;
+            }
+
+            TRACE_INFO_STRING("Did the delete of the item.", "");
+            break;
+        default:
+            break;
         }
         /* Force interrupt if we found */
         *stop = 1;
     }
 
-    TRACE_FLOW_NUMBER("act_traverse_handler returning",error);
+    TRACE_FLOW_NUMBER("act_traverse_handler returning", error);
     return error;
 }
 
@@ -967,80 +1001,85 @@ static int copy_traverse_handler(struct collection_item *head,
     int error = EOK;
     struct collection_item *parent;
     struct collection_item *item;
-    struct collection_item *new_collection = (struct collection_item *)(NULL);
+    struct collection_item *new_collection = NULL;
 
-    TRACE_FLOW_STRING("copy_traverse_handler","Entry.");
+    TRACE_FLOW_STRING("copy_traverse_handler", "Entry.");
 
-    parent = (struct collection_item *)(passed_traverse_data);
+    parent = (struct collection_item *)passed_traverse_data;
 
     /* Skip current element but rather work with next if it is not NULL */
     item = current->next;
-    if(item == (struct collection_item *)(NULL)) return error;
+    if (item == NULL) return error;
 
 
     /* Check if this is a special case of sub collection */
-    if(item->type == COL_TYPE_COLLECTIONREF) {
-        TRACE_INFO_STRING("Found a subcollection we need to copy. Name:",item->property);
+    if (item->type == COL_TYPE_COLLECTIONREF) {
+        TRACE_INFO_STRING("Found a subcollection we need to copy. Name:",
+                          item->property);
 
         error = copy_collection(&new_collection,
                                 *((struct collection_item **)(item->data)),
                                 item->property);
-        if(error) {
-            TRACE_ERROR_NUMBER("Copy subcollection returned error:",error);
+        if (error) {
+            TRACE_ERROR_NUMBER("Copy subcollection returned error:", error);
             return error;
         }
 
-        /* Add new item to a collection - all references are now sub collections */
-        (void)add_property(parent,NULL,item->property,(void *)(&new_collection),
-                           sizeof(struct collection_item **),
-                           COL_TYPE_COLLECTIONREF, &error);
-        if(error) {
-            TRACE_ERROR_NUMBER("Add property returned error:",error);
+        /* Add new item to a collection
+         * all references are now sub collections */
+        add_property(parent, NULL, item->property,
+                     (void *)(&new_collection),
+                     sizeof(struct collection_item **),
+                     COL_TYPE_COLLECTIONREF, &error);
+        if (error) {
+            TRACE_ERROR_NUMBER("Add property returned error:", error);
             return error;
         }
     }
     else {
-        (void)add_property(parent,NULL,item->property,item->data,
-                           item->length,item->type,&error);
-        if(error) {
-            TRACE_ERROR_NUMBER("Add property returned error:",error);
+        add_property(parent, NULL, item->property,
+                     item->data, item->length, item->type, &error);
+        if (error) {
+            TRACE_ERROR_NUMBER("Add property returned error:", error);
             return error;
         }
     }
 
-    TRACE_FLOW_NUMBER("copy_traverse_handler returning",error);
+    TRACE_FLOW_NUMBER("copy_traverse_handler returning", error);
     return error;
 }
 
 
 
-/********************* MAIN INTERFACE FUNCTIONS ***********************************/
+/********************* MAIN INTERFACE FUNCTIONS *****************************/
 
 
 /* CREATE */
 
 /* Function that creates an named collection of a given class*/
-int create_collection(struct collection_item **ci,char *name, unsigned class)
+int create_collection(struct collection_item **ci, char *name, unsigned cclass)
 {
-    struct collection_item *handle = (struct collection_item *)(NULL);
+    struct collection_item *handle = NULL;
     struct collection_header header;
-    int error=EOK;
+    int error = EOK;
 
-    TRACE_FLOW_STRING("create_collection","Entry.");
+    TRACE_FLOW_STRING("create_collection", "Entry.");
 
     /* Prepare header */
-    header.last = (struct collection_item *)(NULL);
+    header.last = NULL;
     header.reference_count = 1;
     header.count = 0;
-    header.class = class;
+    header.cclass = cclass;
 
     /* Create a collection type property */
-    handle = add_property((struct collection_item *)(NULL),NULL,name,&header,sizeof(header), COL_TYPE_COLLECTION, &error);
-    if(error) return error;
+    handle = add_property(NULL, NULL, name,
+                          &header, sizeof(header),
+                          COL_TYPE_COLLECTION, &error);
+    if (error) return error;
 
     *ci = handle;
 
-    TRACE_FLOW_STRING("create_collection","Success Exit.");
+    TRACE_FLOW_STRING("create_collection", "Success Exit.");
     return 0;
 }
 
@@ -1052,28 +1091,31 @@ void destroy_collection(struct collection_item *ci)
 {
     struct collection_header *header;
 
-    TRACE_FLOW_STRING("destroy_collection","Entry.");
+    TRACE_FLOW_STRING("destroy_collection", "Entry.");
 
     /* Do not try to delete NULL */
-    if(ci == (struct collection_item *)(NULL)) return;
+    if (ci == NULL) return;
 
     /* You can delete only whole collection not a part of it */
-    if(ci->type != COL_TYPE_COLLECTION) {
-        TRACE_ERROR_STRING("Attempt to delete a non collection - BAD!","");
-        TRACE_ERROR_NUMBER("Actual type is:",ci->type);
+    if (ci->type != COL_TYPE_COLLECTION) {
+        TRACE_ERROR_STRING("Attempt to delete a non collection - BAD!", "");
+        TRACE_ERROR_NUMBER("Actual type is:", ci->type);
         return;
     }
 
     /* Collection can be referenced by other collection */
     header = (struct collection_header *)(ci->data);
-    if(header->reference_count>1) {
-        TRACE_INFO_STRING("Dereferencing a referenced collection.","");
-        (header->reference_count)--;
-        TRACE_INFO_NUMBER("Number after dereferencing.",header->reference_count);
+    if (header->reference_count > 1) {
+        TRACE_INFO_STRING("Dereferencing a referenced collection.", "");
+        header->reference_count--;
+        TRACE_INFO_NUMBER("Number after dereferencing.",
+                          header->reference_count);
+    }
+    else {
+        delete_collection(ci);
     }
-    else delete_collection(ci);
 
-    TRACE_FLOW_STRING("destroy_collection","Exit.");
+    TRACE_FLOW_STRING("destroy_collection", "Exit.");
 }
 
 
@@ -1082,272 +1124,313 @@ void destroy_collection(struct collection_item *ci)
 /* Add a string property.
    If length equals 0, the length is determined based on the string.
    Lenght INCLUDES the terminating 0 */
-inline int add_str_property(struct collection_item *ci,char *subcollection, char *property,char *string,int length)
+inline int add_str_property(struct collection_item *ci, char *subcollection,
+                            char *property,char *string,int length)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_str_property","Entry.");
+    TRACE_FLOW_STRING("add_str_property", "Entry.");
+
+    if (length == 0)
+        length = strlen(string) + 1;
 
-    if(length == 0) length = strlen(string) + 1;
-    (void)(add_property(ci,subcollection,property,(void *)(string),length, COL_TYPE_STRING, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(string), length, COL_TYPE_STRING, &error);
 
-    TRACE_FLOW_NUMBER("add_str_property returning",error);
+    TRACE_FLOW_NUMBER("add_str_property returning", error);
     return error;
 }
 
 /* Add a binary property. */
-inline int add_binary_property(struct collection_item *ci,char *subcollection, char *property,void *binary_data,int length)
+inline int add_binary_property(struct collection_item *ci, char *subcollection,
+                               char *property, void *binary_data, int length)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_binary_property","Entry.");
+    TRACE_FLOW_STRING("add_binary_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,binary_data,length, COL_TYPE_BINARY, &error));
+    add_property(ci, subcollection, property,
+                 binary_data, length, COL_TYPE_BINARY, &error);
 
-    TRACE_FLOW_NUMBER("add_binary_property returning",error);
+    TRACE_FLOW_NUMBER("add_binary_property returning", error);
     return error;
 }
 
 /* Add an int property. */
-inline int add_int_property(struct collection_item *ci,char *subcollection, char *property,int number)
+inline int add_int_property(struct collection_item *ci, char *subcollection,
+                            char *property,int number)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_int_property","Entry.");
+    TRACE_FLOW_STRING("add_int_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(int), COL_TYPE_INTEGER, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(&number), sizeof(int),
+                 COL_TYPE_INTEGER, &error);
 
-    TRACE_FLOW_NUMBER("add_int_property returning",error);
+    TRACE_FLOW_NUMBER("add_int_property returning", error);
     return error;
 }
 
 /* Add an unsigned int property. */
-inline int add_unsigned_property(struct collection_item *ci,char *subcollection, char *property,unsigned int number)
+inline int add_unsigned_property(struct collection_item *ci,
+                                 char *subcollection,
+                                 char *property, unsigned int number)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_unsigned_property","Entry.");
+    TRACE_FLOW_STRING("add_unsigned_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(int), COL_TYPE_UNSIGNED, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(&number), sizeof(int), COL_TYPE_UNSIGNED, &error);
 
-    TRACE_FLOW_NUMBER("add_unsigned_property returning",error);
+    TRACE_FLOW_NUMBER("add_unsigned_property returning", error);
     return error;
 }
 
 /* Add an long property. */
-inline int add_long_property(struct collection_item *ci,char *subcollection, char *property,long number)
+inline int add_long_property(struct collection_item *ci, char *subcollection,
+                             char *property,long number)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_long_property","Entry.");
+    TRACE_FLOW_STRING("add_long_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(long), COL_TYPE_LONG, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(&number), sizeof(long), COL_TYPE_LONG, &error);
 
-    TRACE_FLOW_NUMBER("add_long_property returning",error);
+    TRACE_FLOW_NUMBER("add_long_property returning", error);
     return error;
 }
 
 /* Add an unsigned long property. */
-inline int add_ulong_property(struct collection_item *ci,char *subcollection, char *property,unsigned long number)
+inline int add_ulong_property(struct collection_item *ci, char *subcollection,
+                              char *property, unsigned long number)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_ulong_property","Entry.");
+    TRACE_FLOW_STRING("add_ulong_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(long), COL_TYPE_ULONG, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(&number), sizeof(long),
+                 COL_TYPE_ULONG, &error);
 
-    TRACE_FLOW_NUMBER("add_ulong_property returning",error);
+    TRACE_FLOW_NUMBER("add_ulong_property returning", error);
     return error;
 }
 
 /* Add a double property. */
-inline int add_double_property(struct collection_item *ci,char *subcollection, char *property,double number)
+inline int add_double_property(struct collection_item *ci, char *subcollection,
+                               char *property,double number)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_double_property","Entry.");
+    TRACE_FLOW_STRING("add_double_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(double), COL_TYPE_DOUBLE, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(&number), sizeof(double), COL_TYPE_DOUBLE, &error);
 
-    TRACE_FLOW_NUMBER("add_double_property returning",error);
+    TRACE_FLOW_NUMBER("add_double_property returning", error);
     return error;
 }
 
 /* Add a bool property. */
-inline int add_bool_property(struct collection_item *ci,char *subcollection, char *property,unsigned char logical)
+inline int add_bool_property(struct collection_item *ci, char *subcollection,
+                             char *property,unsigned char logical)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_bool_property","Entry.");
+    TRACE_FLOW_STRING("add_bool_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,(void *)(&logical),sizeof(unsigned char), COL_TYPE_BOOL, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(&logical), sizeof(unsigned char),
+                 COL_TYPE_BOOL, &error);
 
-    TRACE_FLOW_NUMBER("add_bool_property returning",error);
+    TRACE_FLOW_NUMBER("add_bool_property returning", error);
     return error;
 }
 
 /* A function to add a property */
 inline int add_any_property(struct collection_item *ci,
-                            char *subcollection,
-                            char *property,
-                            int type,
-                            void *data,
-                            int length)
+                            char *subcollection, char *property,
+                            int type, void *data, int length)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_any_property","Entry.");
+    TRACE_FLOW_STRING("add_any_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,data,length, type, &error));
+    add_property(ci, subcollection, property, data, length, type, &error);
 
-    TRACE_FLOW_NUMBER("add_any_property returning",error);
+    TRACE_FLOW_NUMBER("add_any_property returning", error);
     return error;
 }
 
 /* Add a string property.
    If length equals 0, the length is determined based on the string.
    Lenght INCLUDES the terminating 0 */
-inline int add_str_property_with_ref(struct collection_item *ci,char *subcollection,
-                                     char *property,char *string,int length,
+inline int add_str_property_with_ref(struct collection_item *ci,
+                                     char *subcollection, char *property,
+                                     char *string, int length,
                                      struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_str_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_str_property_with_ref", "Entry.");
 
-    if(length == 0) length = strlen(string) + 1;
-    item = add_property(ci,subcollection,property,(void *)(string),length, COL_TYPE_STRING, &error);
+    if (length == 0) length = strlen(string) + 1;
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    item = add_property(ci, subcollection, property,
+                        (void *)(string), length, COL_TYPE_STRING, &error);
 
-    TRACE_FLOW_NUMBER("add_str_property_with_ref returning",error);
+    if (ref_ret != NULL) *ref_ret = item;
+
+    TRACE_FLOW_NUMBER("add_str_property_with_ref returning", error);
     return error;
 }
 
 /* Add a binary property. */
-inline int add_binary_property_with_ref(struct collection_item *ci,char *subcollection,
-                                        char *property,void *binary_data,int length,
+inline int add_binary_property_with_ref(struct collection_item *ci,
+                                        char *subcollection, char *property,
+                                        void *binary_data, int length,
                                         struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_binary_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_binary_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,binary_data,length, COL_TYPE_BINARY, &error);
+    item = add_property(ci, subcollection, property,
+                        binary_data, length, COL_TYPE_BINARY, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_binary_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_binary_property_with_ref returning", error);
     return error;
 }
 
 /* Add an int property. */
-inline int add_int_property_with_ref(struct collection_item *ci,char *subcollection,
-                                     char *property,int number,
+inline int add_int_property_with_ref(struct collection_item *ci,
+                                     char *subcollection, char *property,
+                                     int number,
                                      struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_int_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_int_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,(void *)(&number),sizeof(int), COL_TYPE_INTEGER, &error);
+    item = add_property(ci, subcollection, property,
+                        (void *)(&number), sizeof(int),
+                        COL_TYPE_INTEGER, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_int_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_int_property_with_ref returning", error);
     return error;
 }
 
 /* Add an unsigned int property. */
-inline int add_unsigned_property_with_ref(struct collection_item *ci,char *subcollection,
-                                          char *property,unsigned int number,
+inline int add_unsigned_property_with_ref(struct collection_item *ci,
+                                          char *subcollection, char *property,
+                                          unsigned int number,
                                           struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_unsigned_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_unsigned_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,(void *)(&number),sizeof(int), COL_TYPE_UNSIGNED, &error);
+    item = add_property(ci, subcollection, property,
+                        (void *)(&number), sizeof(int),
+                        COL_TYPE_UNSIGNED, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_unsigned_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_unsigned_property_with_ref returning", error);
     return error;
 }
 
 /* Add an long property. */
-inline int add_long_property_with_ref(struct collection_item *ci,char *subcollection,
-                                      char *property,long number,
+inline int add_long_property_with_ref(struct collection_item *ci,
+                                      char *subcollection, char *property,
+                                      long number,
                                       struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_long_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_long_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,(void *)(&number),sizeof(long), COL_TYPE_LONG, &error);
+    item = add_property(ci, subcollection, property,
+                        (void *)(&number), sizeof(long), COL_TYPE_LONG, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_long_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_long_property_with_ref returning", error);
     return error;
 }
 
 /* Add an unsigned long property. */
-inline int add_ulong_property_with_ref(struct collection_item *ci,char *subcollection,
-                                       char *property,unsigned long number,
+inline int add_ulong_property_with_ref(struct collection_item *ci,
+                                       char *subcollection, char *property,
+                                       unsigned long number,
                                        struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_ulong_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_ulong_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,(void *)(&number),sizeof(long), COL_TYPE_ULONG, &error);
+    item = add_property(ci, subcollection, property,
+                        (void *)(&number), sizeof(long),
+                        COL_TYPE_ULONG, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_ulong_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_ulong_property_with_ref returning", error);
     return error;
 }
 
 /* Add a double property. */
-inline int add_double_property_with_ref(struct collection_item *ci,char *subcollection,
-                                        char *property,double number,
+inline int add_double_property_with_ref(struct collection_item *ci,
+                                        char *subcollection, char *property,
+                                        double number,
                                         struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_double_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_double_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,(void *)(&number),sizeof(double), COL_TYPE_DOUBLE, &error);
+    item = add_property(ci, subcollection, property,
+                        (void *)(&number), sizeof(double),
+                        COL_TYPE_DOUBLE, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_double_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_double_property_with_ref returning", error);
     return error;
 }
 
 /* Add a bool property. */
-inline int add_bool_property_with_ref(struct collection_item *ci,char *subcollection,
-                                      char *property,unsigned char logical,
+inline int add_bool_property_with_ref(struct collection_item *ci,
+                                      char *subcollection, char *property,
+                                      unsigned char logical,
                                       struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_bool_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_bool_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,(void *)(&logical),sizeof(unsigned char), COL_TYPE_BOOL, &error);
+    item = add_property(ci, subcollection, property,
+                        (void *)(&logical), sizeof(unsigned char),
+                        COL_TYPE_BOOL, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_bool_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_bool_property_with_ref returning", error);
     return error;
 }
 
@@ -1363,13 +1446,14 @@ inline int add_any_property_with_ref(struct collection_item *ci,
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_any_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_any_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,data,length, type, &error);
+    item = add_property(ci, subcollection, property,
+                        data, length, type, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_any_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_any_property_with_ref returning", error);
     return error;
 }
 
@@ -1381,35 +1465,37 @@ inline int add_any_property_with_ref(struct collection_item *ci,
 /* Referenced collections of the donor are copied as sub collections. */
 int copy_collection(struct collection_item **collection_copy,
                     struct collection_item *collection_to_copy,
-                    char *name_to_use) {
-
+                    char *name_to_use)
+{
     int error = EOK;
-    struct collection_item *new_collection = (struct collection_item *)(NULL);
+    struct collection_item *new_collection = NULL;
     char *name;
     struct collection_header *header;
 
-    TRACE_FLOW_STRING("copy_collection","Entry.");
+    TRACE_FLOW_STRING("copy_collection", "Entry.");
 
     /* Determine what name to use */
-    if(name_to_use != NULL) name = name_to_use;
-    else name = collection_to_copy->property;
+    if (name_to_use != NULL)
+        name = name_to_use;
+    else
+        name = collection_to_copy->property;
 
-    header = (struct collection_header *)(collection_to_copy->data);
+    header = (struct collection_header *)collection_to_copy->data;
 
     /* Create a new collection */
-    error = create_collection(&new_collection,name,header->class);
-    if(error) {
-        TRACE_ERROR_NUMBER("Create_cllection failed returning",error);
+    error = create_collection(&new_collection, name, header->cclass);
+    if (error) {
+        TRACE_ERROR_NUMBER("Create_cllection failed returning", error);
         return error;
     }
 
-    error = walk_items(collection_to_copy, COL_TRAVERSE_ONELEVEL, copy_traverse_handler,
-                       new_collection, NULL, NULL);
+    error = walk_items(collection_to_copy, COL_TRAVERSE_ONELEVEL,
+                       copy_traverse_handler, new_collection, NULL, NULL);
 
-    if(!error) *collection_copy = new_collection;
+    if (!error) *collection_copy = new_collection;
     else destroy_collection(new_collection);
 
-    TRACE_FLOW_NUMBER("copy_collection returning",error);
+    TRACE_FLOW_NUMBER("copy_collection returning", error);
     return error;
 
 }
@@ -1422,42 +1508,46 @@ int get_collection_reference(struct collection_item *ci,          /* High level
                              char *collection_to_find)            /* Name to of the collection */
 {
     struct collection_header *header;
-    struct collection_item *subcollection = (struct collection_item *)(NULL);
+    struct collection_item *subcollection = NULL;
     int error = EOK;
 
-    TRACE_FLOW_STRING("get_collection_reference","Entry.");
+    TRACE_FLOW_STRING("get_collection_reference", "Entry.");
 
-    if((ci == (struct collection_item *)(NULL)) ||
-       (ci->type != COL_TYPE_COLLECTION) ||
-       (acceptor == (struct collection_item **)(NULL)) ||
-       (collection_to_find == NULL)) {
+    if ((ci == NULL) ||
+        (ci->type != COL_TYPE_COLLECTION) ||
+        (acceptor == NULL) ||
+        (collection_to_find == NULL)) {
         TRACE_ERROR_NUMBER("Invalid parameter - returning error",EINVAL);
         return EINVAL;
     }
 
     /* Find a sub collection */
-    TRACE_INFO_STRING("We are given subcollection name - search it:",collection_to_find);
-    error = find_item_and_do(ci,collection_to_find,COL_TYPE_COLLECTIONREF,
+    TRACE_INFO_STRING("We are given subcollection name - search it:",
+                      collection_to_find);
+    error = find_item_and_do(ci, collection_to_find,
+                             COL_TYPE_COLLECTIONREF,
                              COL_TRAVERSE_DEFAULT,
-                             get_subcollection,(void *)(&subcollection),COLLECTION_ACTION_FIND);
-    if(error) {
-        TRACE_ERROR_NUMBER("Search failed returning error",error);
+                             get_subcollection,
+                             (void *)(&subcollection),
+                             COLLECTION_ACTION_FIND);
+    if (error) {
+        TRACE_ERROR_NUMBER("Search failed returning error", error);
         return error;
     }
 
-    if(subcollection == (struct collection_item *)(NULL)) {
-        TRACE_ERROR_STRING("Search for subcollection returned NULL pointer","");
+    if (subcollection == NULL) {
+        TRACE_ERROR_STRING("Search for subcollection returned NULL pointer", "");
         return ENOENT;
     }
 
-    header = (struct collection_header *)(subcollection->data);
-    TRACE_INFO_NUMBER("Count:",header->count);
-    TRACE_INFO_NUMBER("Ref count:",header->reference_count);
-    (header->reference_count)++;
-    TRACE_INFO_NUMBER("Ref count after increment:",header->reference_count);
+    header = (struct collection_header *)subcollection->data;
+    TRACE_INFO_NUMBER("Count:", header->count);
+    TRACE_INFO_NUMBER("Ref count:", header->reference_count);
+    header->reference_count++;
+    TRACE_INFO_NUMBER("Ref count after increment:", header->reference_count);
     *acceptor = subcollection;
 
-    TRACE_FLOW_STRING("get_collection_reference","Success Exit.");
+    TRACE_FLOW_STRING("get_collection_reference", "Success Exit.");
     return EOK;
 }
 
@@ -1466,27 +1556,27 @@ int get_reference_from_item(struct collection_item *ci,
                             struct collection_item **acceptor)
 {
     struct collection_header *header;
-    struct collection_item *subcollection = (struct collection_item *)(NULL);
+    struct collection_item *subcollection = NULL;
 
-    TRACE_FLOW_STRING("get_reference_from_item","Entry.");
+    TRACE_FLOW_STRING("get_reference_from_item", "Entry.");
 
-    if((ci == (struct collection_item *)(NULL)) ||
-       (ci->type != COL_TYPE_COLLECTIONREF) ||
-       (acceptor == (struct collection_item **)(NULL))) {
+    if ((ci == NULL) ||
+        (ci->type != COL_TYPE_COLLECTIONREF) ||
+        (acceptor == NULL)) {
         TRACE_ERROR_NUMBER("Invalid parameter - returning error",EINVAL);
         return EINVAL;
     }
 
-    subcollection = *((struct collection_item **)(ci->data));
+    subcollection = *((struct collection_item **)ci->data);
 
-    header = (struct collection_header *)(subcollection->data);
-    TRACE_INFO_NUMBER("Count:",header->count);
-    TRACE_INFO_NUMBER("Ref count:",header->reference_count);
-    (header->reference_count)++;
-    TRACE_INFO_NUMBER("Ref count after increment:",header->reference_count);
+    header = (struct collection_header *)subcollection->data;
+    TRACE_INFO_NUMBER("Count:", header->count);
+    TRACE_INFO_NUMBER("Ref count:", header->reference_count);
+    header->reference_count++;
+    TRACE_INFO_NUMBER("Ref count after increment:", header->reference_count);
     *acceptor = subcollection;
 
-    TRACE_FLOW_STRING("get_reference_from_item","Success Exit.");
+    TRACE_FLOW_STRING("get_reference_from_item", "Success Exit.");
     return EOK;
 }
 
@@ -1504,121 +1594,143 @@ int add_collection_to_collection(
    struct collection_item *collection_to_add, /* Collection to add */
    int mode)                                  /* How this collection needs to be added */
 {
-    struct collection_item *acceptor = (struct collection_item *)(NULL);
+    struct collection_item *acceptor = NULL;
     char *name_to_use;
     struct collection_header *header;
     struct collection_item *collection_copy;
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_collection_to_collection","Entry.");
+    TRACE_FLOW_STRING("add_collection_to_collection", "Entry.");
 
-    if((ci == (struct collection_item *)(NULL)) ||
-       (ci->type != COL_TYPE_COLLECTION) ||
-       (collection_to_add == (struct collection_item *)(NULL)) ||
-       (collection_to_add->type != COL_TYPE_COLLECTION)) {
+    if ((ci == NULL) ||
+        (ci->type != COL_TYPE_COLLECTION) ||
+        (collection_to_add == NULL) ||
+        (collection_to_add->type != COL_TYPE_COLLECTION)) {
         /* Need to debug here */
-        TRACE_ERROR_NUMBER("Missing parameter - returning error",EINVAL);
+        TRACE_ERROR_NUMBER("Missing parameter - returning error", EINVAL);
         return EINVAL;
     }
 
-    if(sub_collection_name != NULL) {
+    if (sub_collection_name != NULL) {
         /* Find a sub collection */
-        TRACE_INFO_STRING("We are given subcollection name - search it:",sub_collection_name);
-        error = find_item_and_do(ci,sub_collection_name,COL_TYPE_COLLECTIONREF,
+        TRACE_INFO_STRING("We are given subcollection name - search it:",
+                          sub_collection_name);
+        error = find_item_and_do(ci, sub_collection_name,
+                                 COL_TYPE_COLLECTIONREF,
                                  COL_TRAVERSE_DEFAULT,
-                                 get_subcollection,(void *)(&acceptor),COLLECTION_ACTION_FIND);
-        if(error) {
-            TRACE_ERROR_NUMBER("Search failed returning error",error);
+                                 get_subcollection,
+                                 (void *)(&acceptor),
+                                 COLLECTION_ACTION_FIND);
+        if (error) {
+            TRACE_ERROR_NUMBER("Search failed returning error", error);
             return error;
         }
 
-        if(acceptor == (struct collection_item *)(NULL)) {
-            TRACE_ERROR_STRING("Search for subcollection returned NULL pointer","");
+        if (acceptor == NULL) {
+            TRACE_ERROR_STRING("Search for subcollection returned NULL pointer", "");
             return ENOENT;
         }
 
     }
-    else acceptor = ci;
+    else {
+        acceptor = ci;
+    }
 
-    if(as_property != NULL)
+    if (as_property != NULL)
         name_to_use = as_property;
     else
         name_to_use = collection_to_add->property;
 
 
-    TRACE_INFO_STRING("Going to use name:",name_to_use);
-
-
-    switch(mode) {
-        case COL_ADD_MODE_REFERENCE:
-            TRACE_INFO_STRING("We are adding a reference.","");
-            TRACE_INFO_NUMBER("Type of the header element:",collection_to_add->type);
-            TRACE_INFO_STRING("Header name we are adding.",collection_to_add->property);
-            /* Create a pointer to external collection */
-            /* For future thread safety: Transaction start -> */
-            (void)(add_property(acceptor,NULL,name_to_use,(void *)(&collection_to_add),
-                                sizeof(struct collection_item **),
-                                COL_TYPE_COLLECTIONREF, &error));
-
-            TRACE_INFO_NUMBER("Type of the header element after add_property:",collection_to_add->type);
-            TRACE_INFO_STRING("Header name we just added.",collection_to_add->property);
-            if(error) {
-                TRACE_ERROR_NUMBER("Adding property failed with error:",error);
-                return error;
-            }
-            header = (struct collection_header *)(collection_to_add->data);
-            TRACE_INFO_NUMBER("Count:",header->count);
-            TRACE_INFO_NUMBER("Ref count:",header->reference_count);
-            (header->reference_count)++;
-            TRACE_INFO_NUMBER("Ref count after increment:",header->reference_count);
-            /* -> Transaction end */
-            break;
-        case COL_ADD_MODE_EMBED:
-            TRACE_INFO_STRING("We are embedding the collection.","");
-            /* First check if the passed in collection is referenced more than once */
-            TRACE_INFO_NUMBER("Type of the header element we are adding:",collection_to_add->type);
-            TRACE_INFO_STRING("Header name we are adding.",collection_to_add->property);
-            TRACE_INFO_NUMBER("Type of the header element we are adding to:",acceptor->type);
-            TRACE_INFO_STRING("Header name we are adding to.",acceptor->property);
-
-            (void)(add_property(acceptor,NULL,name_to_use,(void *)(&collection_to_add),
-                                sizeof(struct collection_item **),
-                                COL_TYPE_COLLECTIONREF, &error));
-
-            TRACE_INFO_NUMBER("Adding property returned:",error);
-            break;
-
-        case COL_ADD_MODE_CLONE:
-            TRACE_INFO_STRING("We are cloning the collection.","");
-            TRACE_INFO_STRING("Name we will use.",name_to_use);
-
-            /* For future thread safety: Transaction start -> */
-            error = copy_collection(&collection_copy, collection_to_add, name_to_use);
-            if(error) return error;
-
-            TRACE_INFO_STRING("We have a collection copy.", collection_copy->property);
-            TRACE_INFO_NUMBER("Collection type.", collection_copy->type);
-            TRACE_INFO_STRING("Acceptor collection.", acceptor->property);
-            TRACE_INFO_NUMBER("Acceptor collection type.", acceptor->type);
-
-            (void)(add_property(acceptor,NULL,name_to_use,(void *)(&collection_copy),
-                                sizeof(struct collection_item **),
-                                COL_TYPE_COLLECTIONREF, &error));
-
-            /* -> Transaction end */
-            TRACE_INFO_NUMBER("Adding property returned:",error);
-            break;
-
-        default: error = EINVAL;
-    }
-
-    TRACE_FLOW_NUMBER("add_collection_to_collection returning:",error);
+    TRACE_INFO_STRING("Going to use name:", name_to_use);
+
+
+    switch (mode) {
+    case COL_ADD_MODE_REFERENCE:
+        TRACE_INFO_STRING("We are adding a reference.", "");
+        TRACE_INFO_NUMBER("Type of the header element:",
+                          collection_to_add->type);
+        TRACE_INFO_STRING("Header name we are adding.",
+                          collection_to_add->property);
+        /* Create a pointer to external collection */
+        /* For future thread safety: Transaction start -> */
+        add_property(acceptor, NULL, name_to_use,
+                     (void *)(&collection_to_add),
+                     sizeof(struct collection_item **),
+                     COL_TYPE_COLLECTIONREF, &error);
+
+        TRACE_INFO_NUMBER("Type of the header element after add_property:",
+                          collection_to_add->type);
+        TRACE_INFO_STRING("Header name we just added.",
+                          collection_to_add->property);
+        if (error) {
+            TRACE_ERROR_NUMBER("Adding property failed with error:", error);
+            return error;
+        }
+        header = (struct collection_header *)collection_to_add->data;
+        TRACE_INFO_NUMBER("Count:", header->count);
+        TRACE_INFO_NUMBER("Ref count:", header->reference_count);
+        header->reference_count++;
+        TRACE_INFO_NUMBER("Ref count after increment:",
+                          header->reference_count);
+        /* -> Transaction end */
+        break;
+
+    case COL_ADD_MODE_EMBED:
+        TRACE_INFO_STRING("We are embedding the collection.", "");
+        /* First check if the passed in collection is referenced more than once */
+        TRACE_INFO_NUMBER("Type of the header element we are adding:",
+                          collection_to_add->type);
+        TRACE_INFO_STRING("Header name we are adding.",
+                          collection_to_add->property);
+        TRACE_INFO_NUMBER("Type of the header element we are adding to:",
+                          acceptor->type);
+        TRACE_INFO_STRING("Header name we are adding to.",
+                          acceptor->property);
+
+        add_property(acceptor, NULL, name_to_use,
+                     (void *)(&collection_to_add),
+                     sizeof(struct collection_item **),
+                     COL_TYPE_COLLECTIONREF, &error);
+
+        TRACE_INFO_NUMBER("Adding property returned:", error);
+        break;
+
+    case COL_ADD_MODE_CLONE:
+        TRACE_INFO_STRING("We are cloning the collection.", "");
+        TRACE_INFO_STRING("Name we will use.", name_to_use);
+
+        /* For future thread safety: Transaction start -> */
+        error = copy_collection(&collection_copy,
+                                collection_to_add, name_to_use);
+        if (error) return error;
+
+        TRACE_INFO_STRING("We have a collection copy.", collection_copy->property);
+        TRACE_INFO_NUMBER("Collection type.", collection_copy->type);
+        TRACE_INFO_STRING("Acceptor collection.", acceptor->property);
+        TRACE_INFO_NUMBER("Acceptor collection type.", acceptor->type);
+
+        add_property(acceptor, NULL, name_to_use,
+                     (void *)(&collection_copy),
+                     sizeof(struct collection_item **),
+                     COL_TYPE_COLLECTIONREF, &error);
+
+        /* -> Transaction end */
+        TRACE_INFO_NUMBER("Adding property returned:", error);
+        break;
+
+    default:
+        error = EINVAL;
+    }
+
+    TRACE_FLOW_NUMBER("add_collection_to_collection returning:", error);
     return error;
 }
 
 /* TRAVERSING */
 
-/* Function to traverse the entire collection including optionally sub collections */
+/* Function to traverse the entire collection including optionally
+ * sub collections */
 inline int traverse_collection(struct collection_item *ci,
                                int mode_flags,
                                item_fn item_handler,
@@ -1626,17 +1738,17 @@ inline int traverse_collection(struct collection_item *ci,
 {
 
     int error = EOK;
-    TRACE_FLOW_STRING("traverse_collection","Entry.");
+    TRACE_FLOW_STRING("traverse_collection", "Entry.");
 
     error = walk_items(ci, mode_flags, simple_traverse_handler,
                        NULL, item_handler, custom_data);
 
-    if((error != 0) && (error != EINTR_INTERNAL)) {
-        TRACE_ERROR_NUMBER("Error walking tree",error);
+    if ((error != 0) && (error != EINTR_INTERNAL)) {
+        TRACE_ERROR_NUMBER("Error walking tree", error);
         return error;
     }
 
-    TRACE_FLOW_STRING("traverse_collection","Success exit.");
+    TRACE_FLOW_STRING("traverse_collection", "Success exit.");
     return EOK;
 }
 
@@ -1654,10 +1766,13 @@ inline int is_item_in_collection(struct collection_item *ci,
     TRACE_FLOW_STRING("is_item_in_collection","Entry.");
 
     *found = COL_NOMATCH;
-    error = find_item_and_do(ci,property_to_find,type,mode_flags,
-                             is_in_item_handler,(void *)found,COLLECTION_ACTION_FIND);
+    error = find_item_and_do(ci, property_to_find,
+                             type, mode_flags,
+                             is_in_item_handler,
+                             (void *)found,
+                             COLLECTION_ACTION_FIND);
 
-    TRACE_FLOW_NUMBER("is_item_in_collection returning",error);
+    TRACE_FLOW_NUMBER("is_item_in_collection returning", error);
     return error;
 }
 
@@ -1676,9 +1791,13 @@ inline int get_item_and_do(struct collection_item *ci,       /* Collection to fi
 
     TRACE_FLOW_STRING("get_item_and_do","Entry.");
 
-    error = find_item_and_do(ci,property_to_find,type,mode_flags,item_handler,custom_data,COLLECTION_ACTION_FIND);
+    error = find_item_and_do(ci, property_to_find,
+                             type, mode_flags,
+                             item_handler,
+                             custom_data,
+                             COLLECTION_ACTION_FIND);
 
-    TRACE_FLOW_NUMBER("get_item_and_do returning",error);
+    TRACE_FLOW_NUMBER("get_item_and_do returning", error);
     return error;
 }
 
@@ -1693,11 +1812,14 @@ inline int get_item(struct collection_item *ci,       /* Collection to find thin
 
     int error = EOK;
 
-    TRACE_FLOW_STRING("get_item","Entry.");
+    TRACE_FLOW_STRING("get_item", "Entry.");
 
-    error = find_item_and_do(ci,property_to_find,type,mode_flags,NULL,(void *)(item),COLLECTION_ACTION_GET);
+    error = find_item_and_do(ci, property_to_find,
+                             type, mode_flags,
+                             NULL, (void *)item,
+                             COLLECTION_ACTION_GET);
 
-    TRACE_FLOW_NUMBER("get_item returning",error);
+    TRACE_FLOW_NUMBER("get_item returning", error);
     return error;
 }
 
@@ -1711,13 +1833,18 @@ inline int delete_property(struct collection_item *ci,    /* Collection to find
     int error = EOK;
     int found;
 
-    TRACE_FLOW_STRING("delete_property","Entry.");
+    TRACE_FLOW_STRING("delete_property", "Entry.");
     found = COL_NOMATCH;
 
-    error = find_item_and_do(ci,property_to_find,type,mode_flags,NULL,(void *)(&found),COLLECTION_ACTION_DEL);
+    error = find_item_and_do(ci, property_to_find,
+                             type, mode_flags,
+                             NULL, (void *)(&found),
+                             COLLECTION_ACTION_DEL);
 
-    if((error == EOK) && (found == COL_NOMATCH)) error = ENOENT;
-    TRACE_FLOW_NUMBER("delete_property returning",error);
+    if ((error == EOK) && (found == COL_NOMATCH))
+        error = ENOENT;
+
+    TRACE_FLOW_NUMBER("delete_property returning", error);
     return error;
 }
 
@@ -1734,20 +1861,26 @@ int update_property(struct collection_item *ci,    /* Collection to find things
     int error = EOK;
     struct update_property update_data;
 
-    TRACE_FLOW_STRING("update_property","Entry.");
+    TRACE_FLOW_STRING("update_property", "Entry.");
     update_data.type = type;
     update_data.data = new_data;
     update_data.length = length;
     update_data.found = COL_NOMATCH;
 
-    error = find_item_and_do(ci,property_to_find,type,mode_flags,NULL,(void *)(&update_data),COLLECTION_ACTION_UPDATE);
+    error = find_item_and_do(ci, property_to_find,
+                             type, mode_flags,
+                             NULL, (void *)(&update_data),
+                             COLLECTION_ACTION_UPDATE);
+
+    if ((error == EOK) && (update_data.found == COL_NOMATCH))
+        error = ENOENT;
 
-    if((error == EOK) && (update_data.found == COL_NOMATCH)) error = ENOENT;
-    TRACE_FLOW_NUMBER("update_property returning",error);
+    TRACE_FLOW_NUMBER("update_property returning", error);
     return error;
 }
 
-/* Update a string property in the collection. Length should include the null terminating 0  */
+/* Update a string property in the collection.
+ * Length should include the terminating 0  */
 inline int update_str_property(struct collection_item *ci,
                                char *property,
                                int mode_flags,
@@ -1755,12 +1888,13 @@ inline int update_str_property(struct collection_item *ci,
                                int length)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_str_property","Entry.");
+    TRACE_FLOW_STRING("update_str_property", "Entry.");
 
-    if(length == 0) length = strlen(string) + 1;
-    error =  update_property(ci,property, COL_TYPE_STRING, (void *)(string),length,mode_flags);
+    if (length == 0) length = strlen(string) + 1;
+    error =  update_property(ci, property, COL_TYPE_STRING,
+                             (void *)string, length, mode_flags);
 
-    TRACE_FLOW_NUMBER("update_str_property Returning",error);
+    TRACE_FLOW_NUMBER("update_str_property Returning", error);
     return error;
 }
 
@@ -1772,11 +1906,12 @@ inline int update_binary_property(struct collection_item *ci,
                                   int length)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_binary_property","Entry.");
+    TRACE_FLOW_STRING("update_binary_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_BINARY, binary_data, length, mode_flags);
+    error =  update_property(ci, property, COL_TYPE_BINARY,
+                             binary_data, length, mode_flags);
 
-    TRACE_FLOW_NUMBER("update_binary_property Returning",error);
+    TRACE_FLOW_NUMBER("update_binary_property Returning", error);
     return error;
 }
 
@@ -1787,25 +1922,28 @@ inline int update_int_property(struct collection_item *ci,
                                int number)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_int_property","Entry.");
+    TRACE_FLOW_STRING("update_int_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_INTEGER, (void *)(&number), sizeof(int), mode_flags);
+    error =  update_property(ci, property, COL_TYPE_INTEGER,
+                             (void *)(&number), sizeof(int), mode_flags);
 
-    TRACE_FLOW_NUMBER("update_int_property Returning",error);
+    TRACE_FLOW_NUMBER("update_int_property Returning", error);
     return error;
 }
 
 /* Update an unsigned int property. */
 inline int update_unsigned_property(struct collection_item *ci,
-                                    char *property,int mode_flags,
+                                    char *property, int mode_flags,
                                     unsigned int number)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_unsigned_property","Entry.");
+    TRACE_FLOW_STRING("update_unsigned_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_UNSIGNED, (void *)(&number), sizeof(unsigned int), mode_flags);
+    error =  update_property(ci, property, COL_TYPE_UNSIGNED,
+                             (void *)(&number), sizeof(unsigned int),
+                             mode_flags);
 
-    TRACE_FLOW_NUMBER("update_unsigned_property Returning",error);
+    TRACE_FLOW_NUMBER("update_unsigned_property Returning", error);
     return error;
 }
 /* Update a long property. */
@@ -1815,11 +1953,12 @@ inline int update_long_property(struct collection_item *ci,
                                 long number)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_long_property","Entry.");
+    TRACE_FLOW_STRING("update_long_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_LONG, (void *)(&number), sizeof(long), mode_flags);
+    error =  update_property(ci, property, COL_TYPE_LONG,
+                             (void *)(&number), sizeof(long), mode_flags);
 
-    TRACE_FLOW_NUMBER("update_long_property Returning",error);
+    TRACE_FLOW_NUMBER("update_long_property Returning", error);
     return error;
 
 }
@@ -1831,11 +1970,13 @@ inline int update_ulong_property(struct collection_item *ci,
                                  unsigned long number)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_ulong_property","Entry.");
+    TRACE_FLOW_STRING("update_ulong_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_ULONG, (void *)(&number), sizeof(unsigned long), mode_flags);
+    error =  update_property(ci, property, COL_TYPE_ULONG,
+                             (void *)(&number), sizeof(unsigned long),
+                             mode_flags);
 
-    TRACE_FLOW_NUMBER("update_ulong_property Returning",error);
+    TRACE_FLOW_NUMBER("update_ulong_property Returning", error);
     return error;
 }
 
@@ -1846,11 +1987,12 @@ inline int update_double_property(struct collection_item *ci,
                                   double number)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_double_property","Entry.");
+    TRACE_FLOW_STRING("update_double_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_DOUBLE, (void *)(&number), sizeof(double), mode_flags);
+    error =  update_property(ci, property, COL_TYPE_DOUBLE,
+                             (void *)(&number), sizeof(double), mode_flags);
 
-    TRACE_FLOW_NUMBER("update_double_property Returning",error);
+    TRACE_FLOW_NUMBER("update_double_property Returning", error);
     return error;
 }
 
@@ -1861,11 +2003,13 @@ inline int update_bool_property(struct collection_item *ci,
                                 unsigned char logical)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_bool_property","Entry.");
+    TRACE_FLOW_STRING("update_bool_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_BOOL, (void *)(&logical), sizeof(unsigned char), mode_flags);
+    error =  update_property(ci, property, COL_TYPE_BOOL,
+                             (void *)(&logical), sizeof(unsigned char),
+                             mode_flags);
 
-    TRACE_FLOW_NUMBER("update_bool_property Returning",error);
+    TRACE_FLOW_NUMBER("update_bool_property Returning", error);
     return error;
 }
 
@@ -1876,33 +2020,34 @@ int modify_item(struct collection_item *item,
                 void *data,
                 int length)
 {
-    TRACE_FLOW_STRING("modify_item","Entry");
+    TRACE_FLOW_STRING("modify_item", "Entry");
 
-    if((item == (struct collection_item *)(NULL)) ||
-       (item->type == COL_TYPE_COLLECTION) ||
-       (item->type == COL_TYPE_COLLECTIONREF)) {
-        TRACE_ERROR_NUMBER("Invalid argument or invalid argument type",EINVAL);
+    if ((item == NULL) ||
+        (item->type == COL_TYPE_COLLECTION) ||
+        (item->type == COL_TYPE_COLLECTIONREF)) {
+        TRACE_ERROR_NUMBER("Invalid argument or invalid argument type", EINVAL);
         return EINVAL;
     }
 
-    if(property != NULL) {
+    if (property != NULL) {
         free(item->property);
         item->property=strdup(property);
-        if(item->property == NULL) {
-            TRACE_ERROR_STRING("Failed to allocate memory","");
+        if (item->property == NULL) {
+            TRACE_ERROR_STRING("Failed to allocate memory", "");
             return ENOMEM;
         }
     }
 
-    /* If type is different or same but it is string or binary we need to replace the storage */
-    if((item->type != type) ||
-       ((item->type == type) &&
-       ((item->type == COL_TYPE_STRING) || (item->type == COL_TYPE_BINARY)))) {
-        TRACE_INFO_STRING("Replacing item data buffer","");
+    /* If type is different or same but it is string or binary we need to
+     * replace the storage */
+    if ((item->type != type) ||
+        ((item->type == type) &&
+        ((item->type == COL_TYPE_STRING) || (item->type == COL_TYPE_BINARY)))) {
+        TRACE_INFO_STRING("Replacing item data buffer", "");
         free(item->data);
         item->data = malloc(length);
-        if(item->data == NULL) {
-            TRACE_ERROR_STRING("Failed to allocate memory","");
+        if (item->data == NULL) {
+            TRACE_ERROR_STRING("Failed to allocate memory", "");
             item->length = 0;
             return ENOMEM;
         }
@@ -1910,13 +2055,14 @@ int modify_item(struct collection_item *item,
     }
 
 
-    TRACE_INFO_STRING("Overwriting item data","");
-    memcpy(item->data,data,item->length);
+    TRACE_INFO_STRING("Overwriting item data", "");
+    memcpy(item->data, data, item->length);
     item->type = type;
 
-    if(item->type == COL_TYPE_STRING) *(((char *)(item->data))+item->length-1) = '\0';
+    if (item->type == COL_TYPE_STRING)
+        ((char *)(item->data))[item->length - 1] = '\0';
 
-    TRACE_FLOW_STRING("modify_item","Exit");
+    TRACE_FLOW_STRING("modify_item", "Exit");
     return EOK;
 }
 
@@ -1931,14 +2077,16 @@ inline int modify_str_item(struct collection_item *item,
     int len;
     int error;
 
-    TRACE_FLOW_STRING("modify_str_item","Entry");
+    TRACE_FLOW_STRING("modify_str_item", "Entry");
 
-    if(length != 0) len = length;
-    else len = strlen(string) + 1;
+    if (length != 0)
+        len = length;
+    else
+        len = strlen(string) + 1;
 
-    error = modify_item(item,property,COL_TYPE_STRING,(void *)string,len);
+    error = modify_item(item, property, COL_TYPE_STRING, (void *)string, len);
 
-    TRACE_FLOW_STRING("modify_str_item","Exit");
+    TRACE_FLOW_STRING("modify_str_item", "Exit");
     return error;
 }
 
@@ -1950,11 +2098,11 @@ inline int modify_binary_item(struct collection_item *item,
 {
     int error;
 
-    TRACE_FLOW_STRING("modify_binary_item","Entry");
+    TRACE_FLOW_STRING("modify_binary_item", "Entry");
 
-    error = modify_item(item,property,COL_TYPE_BINARY,binary_data,length);
+    error = modify_item(item, property, COL_TYPE_BINARY, binary_data, length);
 
-    TRACE_FLOW_STRING("modify_binary_item","Exit");
+    TRACE_FLOW_STRING("modify_binary_item", "Exit");
     return error;
 }
 
@@ -1965,11 +2113,11 @@ inline int modify_bool_item(struct collection_item *item,
 {
     int error;
 
-    TRACE_FLOW_STRING("modify_bool_item","Entry");
+    TRACE_FLOW_STRING("modify_bool_item", "Entry");
 
-    error = modify_item(item,property,COL_TYPE_BOOL,(void *)(&logical),1);
+    error = modify_item(item, property, COL_TYPE_BOOL, (void *)(&logical), 1);
 
-    TRACE_FLOW_STRING("modify_bool_item","Exit");
+    TRACE_FLOW_STRING("modify_bool_item", "Exit");
     return error;
 }
 
@@ -1982,9 +2130,10 @@ inline int modify_int_item(struct collection_item *item,
 
     TRACE_FLOW_STRING("modify_int_item","Entry");
 
-    error = modify_item(item,property,COL_TYPE_INTEGER,(void *)(&number),sizeof(int));
+    error = modify_item(item, property, COL_TYPE_INTEGER,
+                        (void *)(&number), sizeof(int));
 
-    TRACE_FLOW_STRING("modify_int_item","Exit");
+    TRACE_FLOW_STRING("modify_int_item", "Exit");
     return error;
 }
 
@@ -1995,11 +2144,12 @@ inline int modify_long_item(struct collection_item *item,
 {
     int error;
 
-    TRACE_FLOW_STRING("modify_long_item","Entry");
+    TRACE_FLOW_STRING("modify_long_item", "Entry");
 
-    error = modify_item(item,property,COL_TYPE_LONG,(void *)(&number),sizeof(long));
+    error = modify_item(item, property, COL_TYPE_LONG,
+                        (void *)(&number), sizeof(long));
 
-    TRACE_FLOW_STRING("modify_long_item","Exit");
+    TRACE_FLOW_STRING("modify_long_item", "Exit");
     return error;
 }
 
@@ -2010,11 +2160,12 @@ inline int modify_ulong_item(struct collection_item *item,
 {
     int error;
 
-    TRACE_FLOW_STRING("modify_ulong_item","Entry");
+    TRACE_FLOW_STRING("modify_ulong_item", "Entry");
 
-    error = modify_item(item,property,COL_TYPE_ULONG,(void *)(&number),sizeof(unsigned long));
+    error = modify_item(item, property, COL_TYPE_ULONG,
+                        (void *)(&number), sizeof(unsigned long));
 
-    TRACE_FLOW_STRING("modify_ulong_item","Exit");
+    TRACE_FLOW_STRING("modify_ulong_item", "Exit");
     return error;
 }
 
@@ -2024,11 +2175,12 @@ inline int modify_unsigned_item(struct collection_item *item,
 {
     int error;
 
-    TRACE_FLOW_STRING("modify_unsigned_item","Entry");
+    TRACE_FLOW_STRING("modify_unsigned_item", "Entry");
 
-    error = modify_item(item,property,COL_TYPE_UNSIGNED,(void *)(&number),sizeof(unsigned));
+    error = modify_item(item, property, COL_TYPE_UNSIGNED,
+                        (void *)(&number), sizeof(unsigned));
 
-    TRACE_FLOW_STRING("modify_unsigned_item","Exit");
+    TRACE_FLOW_STRING("modify_unsigned_item", "Exit");
     return error;
 }
 
@@ -2038,11 +2190,12 @@ inline int modify_double_item(struct collection_item *item,
 {
     int error;
 
-    TRACE_FLOW_STRING("modify_double_item","Entry");
+    TRACE_FLOW_STRING("modify_double_item", "Entry");
 
-    error = modify_item(item,property,COL_TYPE_DOUBLE,(void *)(&number),sizeof(double));
+    error = modify_item(item, property, COL_TYPE_DOUBLE,
+                        (void *)(&number), sizeof(double));
 
-    TRACE_FLOW_STRING("modify_double_item","Exit");
+    TRACE_FLOW_STRING("modify_double_item", "Exit");
     return error;
 }
 
@@ -2053,20 +2206,20 @@ static int grow_stack(struct collection_iterator *iterator, unsigned desired)
     int grow_by = 0;
     struct collection_item **temp;
 
-    TRACE_FLOW_STRING("grow_stack","Entry.");
+    TRACE_FLOW_STRING("grow_stack", "Entry.");
 
-    if(desired > iterator->stack_size) {
+    if (desired > iterator->stack_size) {
         grow_by = (((desired - iterator->stack_size) / STACK_DEPTH_BLOCK) + 1) * STACK_DEPTH_BLOCK;
         errno = 0;
-        temp = (struct collection_item **)(realloc(iterator->stack,grow_by * sizeof(struct collection_item *)));
-        if(temp == (struct collection_item **)(NULL)) {
-            TRACE_ERROR_NUMBER("Failed to allocate memory",ENOMEM);
+        temp = (struct collection_item **)realloc(iterator->stack, grow_by * sizeof(struct collection_item *));
+        if (temp == NULL) {
+            TRACE_ERROR_NUMBER("Failed to allocate memory", ENOMEM);
             return ENOMEM;
         }
         iterator->stack = temp;
         iterator->stack_size += grow_by;
     }
-    TRACE_FLOW_STRING("grow_stack","Exit.");
+    TRACE_FLOW_STRING("grow_stack", "Exit.");
     return EOK;
 }
 
@@ -2079,83 +2232,81 @@ int bind_iterator(struct collection_iterator **iterator,
 {
     int error;
     struct collection_header *header;
-    struct collection_iterator *iter = (struct collection_iterator *)(NULL);
+    struct collection_iterator *iter = NULL;
 
-    TRACE_FLOW_STRING("bind_iterator","Entry.");
+    TRACE_FLOW_STRING("bind_iterator", "Entry.");
 
     /* Do some argument checking first */
-    if((iterator == (struct collection_iterator **)(NULL)) ||
-       (ci == (struct collection_item *)(NULL))) {
-        TRACE_ERROR_NUMBER("Invalid parameter.",EINVAL);
+    if ((iterator == NULL) || (ci == NULL)) {
+        TRACE_ERROR_NUMBER("Invalid parameter.", EINVAL);
         return EINVAL;
     }
 
     iter = (struct collection_iterator *)malloc(sizeof(struct collection_iterator));
-    if(iter == (struct collection_iterator *)(NULL)) {
-        TRACE_ERROR_NUMBER("Error allocating memory for the iterator.",ENOMEM);
+    if (iter == NULL) {
+        TRACE_ERROR_NUMBER("Error allocating memory for the iterator.", ENOMEM);
         return ENOMEM;
     }
 
     /* Allocate memory for the stack */
-    iter->stack = (struct collection_item **)(NULL);
+    iter->stack = NULL;
     iter->stack_size = 0;
     iter->stack_depth = 0;
     iter->flags = mode_flags;
 
     /* Allocate memory for stack */
-    error = grow_stack(iter,1);
+    error = grow_stack(iter, 1);
     if(error) {
         free(iter);
-        TRACE_ERROR_NUMBER("Error growing stack.",error);
+        TRACE_ERROR_NUMBER("Error growing stack.", error);
         return error;
     }
 
     /* Make sure that we tie iterator to the collection */
-    header = (struct collection_header *)(ci->data);
-    (header->reference_count)++;
+    header = (struct collection_header *)ci->data;
+    header->reference_count++;
     iter->top = ci;
     *(iter->stack) = ci;
     iter->stack_depth++;
 
     *iterator = iter;
 
-    TRACE_FLOW_STRING("bind_iterator","Exit");
+    TRACE_FLOW_STRING("bind_iterator", "Exit");
     return EOK;
 }
 
-/* Stop processing this subcollection and move to the next item in the collection 'level' levels up.*/
+/* Stop processing this subcollection and move to the next item in the
+ * collection 'level' levels up.*/
 inline int iterate_up(struct collection_iterator *iterator, int level)
 {
-    TRACE_FLOW_STRING("iterate_up","Entry");
+    TRACE_FLOW_STRING("iterate_up", "Entry");
 
-    if((iterator == (struct collection_iterator *)(NULL)) ||
-       (level >= iterator->stack_depth)) {
-        TRACE_ERROR_NUMBER("Invalid parameter.",EINVAL);
+    if ((iterator == NULL) || (level >= iterator->stack_depth)) {
+        TRACE_ERROR_NUMBER("Invalid parameter.", EINVAL);
         return EINVAL;
     }
 
-    TRACE_INFO_NUMBER("Going up:",level);
+    TRACE_INFO_NUMBER("Going up:", level);
 
     iterator->stack_depth--;
 
-    TRACE_INFO_NUMBER("Stack depth at the end:",iterator->stack_depth);
-    TRACE_FLOW_STRING("iterate_up","Exit");
+    TRACE_INFO_NUMBER("Stack depth at the end:", iterator->stack_depth);
+    TRACE_FLOW_STRING("iterate_up", "Exit");
     return EOK;
 }
 /* How deep are we relative to the top level.*/
 inline int get_iterator_depth(struct collection_iterator *iterator, int *depth)
 {
-    TRACE_FLOW_STRING("iterate_up","Entry");
+    TRACE_FLOW_STRING("iterate_up", "Entry");
 
-    if((iterator == (struct collection_iterator *)(NULL)) ||
-       (depth == (int *)(NULL))) {
-        TRACE_ERROR_NUMBER("Invalid parameter.",EINVAL);
+    if ((iterator == NULL) || (depth == NULL)) {
+        TRACE_ERROR_NUMBER("Invalid parameter.", EINVAL);
         return EINVAL;
     }
 
     *depth = iterator->stack_depth -1;
 
-    TRACE_INFO_NUMBER("Stack depth at the end:",iterator->stack_depth);
+    TRACE_INFO_NUMBER("Stack depth at the end:", iterator->stack_depth);
     TRACE_FLOW_STRING("iterate_up","Exit");
     return EOK;
 }
@@ -2164,177 +2315,181 @@ inline int get_iterator_depth(struct collection_iterator *iterator, int *depth)
 /* Unbind the iterator from the collection */
 inline void unbind_iterator(struct collection_iterator *iterator)
 {
-    TRACE_FLOW_STRING("unbind_iterator","Entry.");
-    if(iterator != (struct collection_iterator *)(NULL)) {
+    TRACE_FLOW_STRING("unbind_iterator", "Entry.");
+    if (iterator != NULL) {
         destroy_collection(iterator->top);
-        if(iterator->stack != (struct collection_item **)(NULL)) free(iterator->stack);
+        if (iterator->stack != NULL) free(iterator->stack);
         free(iterator);
     }
-    TRACE_FLOW_STRING("unbind_iterator","Exit");
+    TRACE_FLOW_STRING("unbind_iterator", "Exit");
 }
 
 /* Get items from the collection one by one following the tree */
-int iterate_collection(struct collection_iterator *iterator, struct collection_item **item)
+int iterate_collection(struct collection_iterator *iterator,
+                       struct collection_item **item)
 {
     int error;
     struct collection_item *current;
     struct collection_item *other;
 
-    TRACE_FLOW_STRING("iterate_collection","Entry.");
+    TRACE_FLOW_STRING("iterate_collection", "Entry.");
 
     /* Check if we have storage for item */
-    if(item == (struct collection_item **)(NULL)) {
-        TRACE_ERROR_NUMBER("Invalid parameter.",EINVAL);
+    if (item == NULL) {
+        TRACE_ERROR_NUMBER("Invalid parameter.", EINVAL);
         return EINVAL;
     }
 
-    while(1) {
+    while (1) {
 
-        TRACE_INFO_NUMBER("Stack depth:",iterator->stack_depth);
+        TRACE_INFO_NUMBER("Stack depth:", iterator->stack_depth);
 
         /* Are we done? */
-        if(iterator->stack_depth == 0) {
-            TRACE_FLOW_STRING("We are done.","");
-            *item = (struct collection_item *)(NULL);
+        if (iterator->stack_depth == 0) {
+            TRACE_FLOW_STRING("We are done.", "");
+            *item = NULL;
             return EOK;
         }
 
         /* Is current item available */
-        current = *(iterator->stack + iterator->stack_depth - 1);
+        current = iterator->stack[iterator->stack_depth - 1];
 
         /* We are not done so check if we have an item  */
-        if(current != (struct collection_item *)(NULL)) {
+        if (current != NULL) {
 
-            TRACE_INFO_STRING("Current item:",current->property);
-            TRACE_INFO_NUMBER("Current item type:",current->type);
+            TRACE_INFO_STRING("Current item:", current->property);
+            TRACE_INFO_NUMBER("Current item type:", current->type);
 
             /* Is this a collection reference */
-            if(current->type == COL_TYPE_COLLECTIONREF) {
+            if (current->type == COL_TYPE_COLLECTIONREF) {
                 /* We do follow references? */
-                TRACE_INFO_STRING("Current item:","collection reference");
-                if((iterator->flags & COL_TRAVERSE_IGNORE) == 0) {
+                TRACE_INFO_STRING("Current item:", "collection reference");
+                if ((iterator->flags & COL_TRAVERSE_IGNORE) == 0) {
                     /* We should not ignore - then move on */
-                    TRACE_INFO_STRING("Collection references are not ignored","");
-                    error = grow_stack(iterator,iterator->stack_depth + 1);
-                    if(error) {
-                        TRACE_ERROR_NUMBER("Error growing stack.",error);
+                    TRACE_INFO_STRING("Collection references are not ignored", "");
+                    error = grow_stack(iterator, iterator->stack_depth + 1);
+                    if (error) {
+                        TRACE_ERROR_NUMBER("Error growing stack.", error);
                         return error;
                     }
                     /* Do we need to go deeper than one level ? */
-                    if((iterator->flags & COL_TRAVERSE_ONELEVEL) == 0) {
-                        TRACE_INFO_STRING("Need to go deeper","");
+                    if ((iterator->flags & COL_TRAVERSE_ONELEVEL) == 0) {
+                        TRACE_INFO_STRING("Need to go deeper", "");
                         /* We need to go deeper... */
                         /* Do we need to show headers but not reference? */
-                        if((iterator->flags & COL_TRAVERSE_ONLYSUB) != 0) {
-                            TRACE_INFO_STRING("Instructed to show header not reference","");
-                            other = *((struct collection_item **)(current->data));
-                            *(iterator->stack + iterator->stack_depth) = other->next;
+                        if ((iterator->flags & COL_TRAVERSE_ONLYSUB) != 0) {
+                            TRACE_INFO_STRING("Instructed to show header not reference", "");
+                            other = *((struct collection_item **)current->data);
+                            iterator->stack[iterator->stack_depth] = other->next;
                             *item = other;
                         }
                         /* Do we need to show both? */
-                        else if((iterator->flags & COL_TRAVERSE_SHOWSUB) != 0) {
+                        else if ((iterator->flags & COL_TRAVERSE_SHOWSUB) != 0) {
                             TRACE_INFO_STRING("Instructed to show header and reference","");
-                            *(iterator->stack + iterator->stack_depth) = *((struct collection_item **)(current->data));
+                            iterator->stack[iterator->stack_depth] = *((struct collection_item **)(current->data));
                             *item = current;
                         }
                         /* We need to show reference only */
                         else {
-                            TRACE_INFO_STRING("Instructed to show reference only","");
-                            other = *((struct collection_item **)(current->data));
-                            TRACE_INFO_STRING("Sub collection:",other->property);
-                            TRACE_INFO_NUMBER("Sub collection type:",other->type);
-                            *(iterator->stack + iterator->stack_depth) = other->next;
-                            if(other->next != (struct collection_item *)(NULL)) {
-                                TRACE_INFO_STRING("Will show this item next time:",(other->next)->property);
-                                TRACE_INFO_NUMBER("Will show this item next time type:",(other->next)->type);
+                            TRACE_INFO_STRING("Instructed to show reference only", "");
+                            other = *((struct collection_item **)current->data);
+                            TRACE_INFO_STRING("Sub collection:", other->property);
+                            TRACE_INFO_NUMBER("Sub collection type:", other->type);
+                            iterator->stack[iterator->stack_depth] = other->next;
+                            if (other->next != NULL) {
+                                TRACE_INFO_STRING("Will show this item next time:", other->next->property);
+                                TRACE_INFO_NUMBER("Will show this item next time type:", other->next->type);
                             }
                             *item = current;
                         }
 
-                        TRACE_INFO_STRING("We return item:",(*item)->property);
-                        TRACE_INFO_NUMBER("We return item type:",(*item)->type);
-                        TRACE_INFO_STRING("Moving to the next item on the previous item in stack","");
-                        *(iterator->stack + iterator->stack_depth - 1) = current->next;
-                        (iterator->stack_depth)++;
+                        TRACE_INFO_STRING("We return item:", (*item)->property);
+                        TRACE_INFO_NUMBER("We return item type:", (*item)->type);
+                        TRACE_INFO_STRING("Moving to the next item on the previous item in stack", "");
+                        iterator->stack[iterator->stack_depth - 1] = current->next;
+                        iterator->stack_depth++;
 
                     }
                     else {
-                        TRACE_INFO_STRING("Instructed to parse just one level","");
+                        TRACE_INFO_STRING("Instructed to parse just one level", "");
                         /* On one level - just return current */
                         *item = current;
-                        TRACE_INFO_STRING("Moving to the next item on one level","");
-                        *(iterator->stack + iterator->stack_depth - 1) = current->next;
+                        TRACE_INFO_STRING("Moving to the next item on one level", "");
+                        iterator->stack[iterator->stack_depth - 1] = current->next;
                     }
                     break;
                 }
                 else {
                     /* We need to ignore references so move to the next item */
-                    TRACE_INFO_STRING("Stepping over the reference","");
-                    *(iterator->stack + iterator->stack_depth - 1) = current->next;
+                    TRACE_INFO_STRING("Stepping over the reference", "");
+                    iterator->stack[iterator->stack_depth - 1] = current->next;
                     continue;
                 }
             }
             else {
                 /* Got a normal item - return it and move to the next one */
-                TRACE_INFO_STRING("Simple item","");
+                TRACE_INFO_STRING("Simple item", "");
                 *item = current;
-                *(iterator->stack + iterator->stack_depth - 1) = current->next;
+                iterator->stack[iterator->stack_depth - 1] = current->next;
                 break;
             }
         }
         else {
             /* Item is NULL */
-            TRACE_INFO_STRING("Finished level","moving to upper level");
+            TRACE_INFO_STRING("Finished level", "moving to upper level");
             iterator->stack_depth--;
-            TRACE_INFO_NUMBER("Stack depth at the end:",iterator->stack_depth);
-            if((iterator->flags & COL_TRAVERSE_END) != 0) {
+            TRACE_INFO_NUMBER("Stack depth at the end:", iterator->stack_depth);
+            if ((iterator->flags & COL_TRAVERSE_END) != 0) {
                 /* Return dummy entry to indicate the end of the collection */
-                TRACE_INFO_STRING("Finished level","told to return END");
+                TRACE_INFO_STRING("Finished level", "told to return END");
                 *item = &dummy;
                 break;
             }
-            else continue; /* Move to next level */
+            else {
+                /* Move to next level */
+                continue;
+            }
         }
     }
 
-    TRACE_FLOW_STRING("iterate_collection","Exit");
+    TRACE_FLOW_STRING("iterate_collection", "Exit");
     return EOK;
 }
 
 /* Set collection class */
-inline int set_collection_class(struct collection_item *item, unsigned class)
+inline int set_collection_class(struct collection_item *item, unsigned cclass)
 {
     struct collection_header *header;
 
-    TRACE_FLOW_STRING("set_collection_class","Entry");
+    TRACE_FLOW_STRING("set_collection_class", "Entry");
 
-    if(item->type != COL_TYPE_COLLECTION) {
-        TRACE_INFO_NUMBER("Not a collectin object. Type is",item->type);
+    if (item->type != COL_TYPE_COLLECTION) {
+        TRACE_INFO_NUMBER("Not a collectin object. Type is", item->type);
         return EINVAL;
     }
 
-    header = (struct collection_header *)(item->data);
-    header->class = class;
-    TRACE_FLOW_STRING("set_collection_class","Exit");
+    header = (struct collection_header *)item->data;
+    header->cclass = cclass;
+    TRACE_FLOW_STRING("set_collection_class", "Exit");
     return EOK;
 }
 
 /* Get collection class */
 inline int get_collection_class(struct collection_item *item,
-                                unsigned *class)
+                                unsigned *cclass)
 {
     struct collection_header *header;
 
-    TRACE_FLOW_STRING("get_collection_class","Entry");
+    TRACE_FLOW_STRING("get_collection_class", "Entry");
 
-    if(item->type != COL_TYPE_COLLECTION) {
-        TRACE_ERROR_NUMBER("Not a collection object. Type is",item->type);
+    if (item->type != COL_TYPE_COLLECTION) {
+        TRACE_ERROR_NUMBER("Not a collection object. Type is", item->type);
         return EINVAL;
     }
 
-    header = (struct collection_header *)(item->data);
-    *class  = header->class;
-    TRACE_FLOW_STRING("get_collection_class","Exit");
+    header = (struct collection_header *)item->data;
+    *cclass  = header->cclass;
+    TRACE_FLOW_STRING("get_collection_class", "Exit");
     return EOK;
 }
 
@@ -2344,38 +2499,40 @@ inline int get_collection_count(struct collection_item *item,
 {
     struct collection_header *header;
 
-    TRACE_FLOW_STRING("get_collection_count","Entry");
+    TRACE_FLOW_STRING("get_collection_count", "Entry");
 
-    if(item->type != COL_TYPE_COLLECTION) {
-        TRACE_ERROR_NUMBER("Not a collectin object. Type is",item->type);
+    if (item->type != COL_TYPE_COLLECTION) {
+        TRACE_ERROR_NUMBER("Not a collectin object. Type is", item->type);
         return EINVAL;
     }
 
-    header = (struct collection_header *)(item->data);
+    header = (struct collection_header *)item->data;
     *count  = header->count;
-    TRACE_FLOW_STRING("get_collection_count","Exit");
+    TRACE_FLOW_STRING("get_collection_count", "Exit");
     return EOK;
 
 }
 
 /* Convinience function to check if the collection is of the specific class */
 /* In case of internal error assumes that collection is not of the right class */
-inline int is_of_class(struct collection_item *item,unsigned class)
+inline int is_of_class(struct collection_item *item, unsigned cclass)
 {
     int error = EOK;
     unsigned ret_class = 0;
 
-    TRACE_FLOW_STRING("is_of_class invoked","");
+    TRACE_FLOW_STRING("is_of_class invoked", "");
 
-    error = get_collection_class(item,&ret_class);
-    if((error) || (ret_class != class)) return 0;
-    else return 1;
+    error = get_collection_class(item, &ret_class);
+    if (error || (ret_class != cclass))
+        return 0;
+    else
+        return 1;
 }
 
 /* Get propery */
 inline char *get_item_property(struct collection_item *ci,int *property_len)
 {
-    if(property_len != NULL) *property_len = ci->property_len;
+    if (property_len != NULL) *property_len = ci->property_len;
     return ci->property;
 }
 
@@ -2399,42 +2556,45 @@ void *get_item_data(struct collection_item *ci)
 
 
 /* Set time stamp in the collection - FIXME move to another level */
-int set_timestamp(struct collection_item *ci,struct collection_item **timestr_ref,struct collection_item **timeint_ref)
+int set_timestamp(struct collection_item *ci,
+                  struct collection_item **timestr_ref,
+                  struct collection_item **timeint_ref)
 {
     time_t utctime;
     struct tm time_struct;
     char time_array[TIME_ARRAY_SIZE+1];
     int len;
-    struct collection_item *timestr = (struct collection_item *)(NULL);
-    struct collection_item *timeint = (struct collection_item *)(NULL);
+    struct collection_item *timestr = NULL;
+    struct collection_item *timeint = NULL;
     int error = EOK;
 
-    TRACE_FLOW_STRING("set_timestamp","Entry point");
+    TRACE_FLOW_STRING("set_timestamp", "Entry point");
 
     utctime = time(NULL);
-    localtime_r(&utctime,&time_struct);
+    localtime_r(&utctime, &time_struct);
 
     len = strftime(time_array, TIME_ARRAY_SIZE, DATE_FORMAT, &time_struct);
-    if(len == 0) {
-        TRACE_ERROR_STRING("add_time","CODING ERROR - INCREASE THE BUFFER");
+    if (len == 0) {
+        TRACE_ERROR_STRING("add_time", "CODING ERROR - INCREASE THE BUFFER");
         return EMSGSIZE;
     }
 
-    TRACE_INFO_STRING("Timestamp:",time_array);
+    TRACE_INFO_STRING("Timestamp:", time_array);
 
     /* Check if we have the timestamp item already */
-    error = get_item(ci, TS_NAME, COL_TYPE_STRING,COL_TRAVERSE_IGNORE,&timestr);
-    if(error) {
-        TRACE_ERROR_NUMBER("search failed with error:",error);
+    error = get_item(ci, TS_NAME, COL_TYPE_STRING,
+                     COL_TRAVERSE_IGNORE, &timestr);
+    if (error) {
+        TRACE_ERROR_NUMBER("search failed with error:", error);
         return error;
     }
 
-    if(timestr != (struct collection_item *)(NULL)) {
+    if (timestr != NULL) {
         /* There is a timestamp */
         free(timestr->data);
         timestr->data = strdup(time_array);
-        if(timestr->data == NULL) {
-            TRACE_ERROR_NUMBER("failed to add timestamp property:",error);
+        if (timestr->data == NULL) {
+            TRACE_ERROR_NUMBER("failed to add timestamp property:", error);
             return ENOMEM;
         }
         timestr->length = len+1;
@@ -2442,35 +2602,38 @@ int set_timestamp(struct collection_item *ci,struct collection_item **timestr_re
     }
     else {
         /* Add timestamp to the collection */
-        error = add_str_property_with_ref(ci,NULL, TS_NAME,time_array,len+1,timestr_ref);
-        if(error) {
-            TRACE_ERROR_NUMBER("failed to add timestamp property:",error);
+        error = add_str_property_with_ref(ci, NULL, TS_NAME,
+                                          time_array, len+1, timestr_ref);
+        if (error) {
+            TRACE_ERROR_NUMBER("failed to add timestamp property:", error);
             return error;
         }
     }
 
     /* Check if we have the time item already */
-    error = get_item(ci, T_NAME, COL_TYPE_INTEGER,COL_TRAVERSE_IGNORE,&timeint);
-    if(error) {
-        TRACE_ERROR_NUMBER("search failed with error:",error);
+    error = get_item(ci, T_NAME, COL_TYPE_INTEGER,
+                     COL_TRAVERSE_IGNORE, &timeint);
+    if (error) {
+        TRACE_ERROR_NUMBER("search failed with error:", error);
         return error;
     }
 
-    if(timeint != (struct collection_item *)(NULL)) {
+    if (timeint != NULL) {
         /* There is a time property */
         *((int *)(timeint->data)) = utctime;
         *timeint_ref = timeint;
     }
     else {
         /* Add time to the collection */
-        error = add_int_property_with_ref(ci,NULL, T_NAME,utctime,timeint_ref);
-        if(error) {
-            TRACE_ERROR_NUMBER("failed to add time property:",error);
+        error = add_int_property_with_ref(ci, NULL, T_NAME,
+                                          utctime, timeint_ref);
+        if (error) {
+            TRACE_ERROR_NUMBER("failed to add time property:", error);
             return error;
         }
     }
 
-    TRACE_FLOW_STRING("set_timestamp","Exit point");
+    TRACE_FLOW_STRING("set_timestamp", "Exit point");
     return EOK;
 }