Adding INSERT into collection functionality.

Add was always insterting at the end of the collection.
With this change one can control where the item is
inserted and deal with the duplicates too.
Also one now can extract items from collection
using absolute and relative disposition.
Using more advanced hashing function.

1 files changed, 1266 insertions, 0 deletions

diff --git a/common/collection/collection_cnv.c b/common/collection/collection_cnv.c
new file mode 100644
index 000000000..ca9c483ed
--- /dev/null
+++ b/common/collection/collection_cnv.c
@@ -0,0 +1,1266 @@
+/*
+    COLLECTION LIBRARY
+
+    Convenience wrapper functions are implemented here.
+    They take a lot of space but pretty simple so they
+    are separated from the core logic.
+
+    Copyright (C) Dmitri Pal <dpal@redhat.com> 2009
+
+    Collection Library is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Collection Library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with Collection Library.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#define _GNU_SOURCE
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <ctype.h>
+#include <time.h>
+#include "trace.h"
+
+/* The collection should use the teal structures */
+#include "collection_priv.h"
+#include "collection.h"
+
+/* PROPERTIES */
+/* Insert string property with positioning */
+int insert_str_property(struct collection_item *ci,
+                        const char *subcollection,
+                        int disposition,
+                        const char *refprop,
+                        int index,
+                        unsigned flags,
+                        const char *property,
+                        char *string,
+                        int length)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_string_property", "Entry.");
+
+    if (length == 0) length = strlen(string) + 1;
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_STRING,
+                                     (void *)string,
+                                     length,
+                                     NULL);
+
+    TRACE_FLOW_NUMBER("insert_string_property returning", error);
+    return error;
+}
+
+/* Insert binary property with positioning */
+int insert_binary_property(struct collection_item *ci,
+                           const char *subcollection,
+                           int disposition,
+                           const char *refprop,
+                           int index,
+                           unsigned flags,
+                           const char *property,
+                           void *binary_data,
+                           int length)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_binary_property", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_BINARY,
+                                     binary_data,
+                                     length,
+                                     NULL);
+
+    TRACE_FLOW_NUMBER("insert_binary_property returning", error);
+    return error;
+}
+
+
+/* Insert integer property with positioning */
+int insert_int_property(struct collection_item *ci,
+                        const char *subcollection,
+                        int disposition,
+                        const char *refprop,
+                        int index,
+                        unsigned flags,
+                        const char *property,
+                        int number)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_int_property", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_INTEGER,
+                                     (void *)&number,
+                                     sizeof(int),
+                                     NULL);
+
+    TRACE_FLOW_NUMBER("insert_int_property returning", error);
+    return error;
+}
+
+
+/* Insert unsigned property with positioning */
+int insert_unsigned_property(struct collection_item *ci,
+                             const char *subcollection,
+                             int disposition,
+                             const char *refprop,
+                             int index,
+                             unsigned flags,
+                             const char *property,
+                             unsigned number)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_unsigned_property", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_LONG,
+                                     (void *)&number,
+                                     sizeof(unsigned),
+                                     NULL);
+
+    TRACE_FLOW_NUMBER("insert_unsigned_property returning", error);
+    return error;
+}
+
+
+/* Insert long property with positioning */
+int insert_long_property(struct collection_item *ci,
+                         const char *subcollection,
+                         int disposition,
+                         const char *refprop,
+                         int index,
+                         unsigned flags,
+                         const char *property,
+                         long number)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_long_property", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_LONG,
+                                     (void *)&number,
+                                     sizeof(long),
+                                     NULL);
+
+    TRACE_FLOW_NUMBER("insert_long_property returning", error);
+    return error;
+}
+
+/* Insert unsigned long property with positioning */
+int insert_ulong_property(struct collection_item *ci,
+                          const char *subcollection,
+                          int disposition,
+                          const char *refprop,
+                          int index,
+                          unsigned flags,
+                          const char *property,
+                          unsigned long number)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_ulong_property", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_ULONG,
+                                     (void *)&number,
+                                     sizeof(unsigned long),
+                                     NULL);
+
+    TRACE_FLOW_NUMBER("insert_ulong_property returning", error);
+    return error;
+}
+
+/* Insert double property with positioning */
+int insert_double_property(struct collection_item *ci,
+                           const char *subcollection,
+                           int disposition,
+                           const char *refprop,
+                           int index,
+                           unsigned flags,
+                           const char *property,
+                           double number)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_double_property", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_DOUBLE,
+                                     (void *)&number,
+                                     sizeof(double),
+                                     NULL);
+
+    TRACE_FLOW_NUMBER("insert_double_property returning", error);
+    return error;
+}
+
+/* Insert bool property with positioning */
+int insert_bool_property(struct collection_item *ci,
+                         const char *subcollection,
+                         int disposition,
+                         const char *refprop,
+                         int index,
+                         unsigned flags,
+                         const char *property,
+                         unsigned char logical)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_bool_property", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_BOOL,
+                                     (void *)&logical,
+                                     sizeof(unsigned char),
+                                     NULL);
+
+    TRACE_FLOW_NUMBER("insert_bool_property returning", error);
+    return error;
+}
+
+
+/* Insert string property with positioning and reference. */
+int insert_str_property_with_ref(struct collection_item *ci,
+                                 const char *subcollection,
+                                 int disposition,
+                                 const char *refprop,
+                                 int index,
+                                 unsigned flags,
+                                 const char *property,
+                                 char *string,
+                                 int length,
+                                 struct collection_item **ret_ref)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_string_property_with_ref", "Entry.");
+
+    if (length == 0) length = strlen(string) + 1;
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_STRING,
+                                     (void *)string,
+                                     length,
+                                     ret_ref);
+
+    TRACE_FLOW_NUMBER("insert_string_property_with_ref returning", error);
+    return error;
+}
+
+/* Insert binary property with positioning and reference. */
+int insert_binary_property_with_ref(struct collection_item *ci,
+                                    const char *subcollection,
+                                    int disposition,
+                                    const char *refprop,
+                                    int index,
+                                    unsigned flags,
+                                    const char *property,
+                                    void *binary_data,
+                                    int length,
+                                    struct collection_item **ret_ref)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_binary_property_with_ref", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_BINARY,
+                                     (void *)binary_data,
+                                     length,
+                                     ret_ref);
+
+    TRACE_FLOW_NUMBER("insert_binary_property_with_ref returning", error);
+    return error;
+}
+
+/* Insert int property with positioning and reference. */
+int insert_int_property_with_ref(struct collection_item *ci,
+                                 const char *subcollection,
+                                 int disposition,
+                                 const char *refprop,
+                                 int index,
+                                 unsigned flags,
+                                 const char *property,
+                                 int number,
+                                 struct collection_item **ret_ref)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_int_property_with_ref", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_INTEGER,
+                                     (void *)&number,
+                                     sizeof(int),
+                                     ret_ref);
+
+    TRACE_FLOW_NUMBER("insert_int_property_with_ref returning", error);
+    return error;
+}
+
+
+/* Insert unsigned property with positioning and reference. */
+int insert_unsigned_property_with_ref(struct collection_item *ci,
+                                      const char *subcollection,
+                                      int disposition,
+                                      const char *refprop,
+                                      int index,
+                                      unsigned flags,
+                                      const char *property,
+                                      unsigned number,
+                                      struct collection_item **ret_ref)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_unsigned_property_with_ref", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_UNSIGNED,
+                                     (void *)&number,
+                                     sizeof(unsigned),
+                                     ret_ref);
+
+    TRACE_FLOW_NUMBER("insert_unsigned_property_with_ref returning", error);
+    return error;
+}
+
+/* Insert long property with positioning and reference. */
+int insert_long_property_with_ref(struct collection_item *ci,
+                                  const char *subcollection,
+                                  int disposition,
+                                  const char *refprop,
+                                  int index,
+                                  unsigned flags,
+                                  const char *property,
+                                  long number,
+                                  struct collection_item **ret_ref)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_long_property_with_ref", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_LONG,
+                                     (void *)&number,
+                                     sizeof(long),
+                                     ret_ref);
+
+    TRACE_FLOW_NUMBER("insert_long_property_with_ref returning", error);
+    return error;
+}
+
+/* Insert unsigned long property with positioning and reference. */
+int insert_ulong_property_with_ref(struct collection_item *ci,
+                                   const char *subcollection,
+                                   int disposition,
+                                   const char *refprop,
+                                   int index,
+                                   unsigned flags,
+                                   const char *property,
+                                   unsigned long number,
+                                   struct collection_item **ret_ref)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_ulong_property_with_ref", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_ULONG,
+                                     (void *)&number,
+                                     sizeof(unsigned long),
+                                     ret_ref);
+
+    TRACE_FLOW_NUMBER("insert_ulong_property_with_ref returning", error);
+    return error;
+}
+
+/* Insert double property with positioning and reference. */
+int insert_double_property_with_ref(struct collection_item *ci,
+                                    const char *subcollection,
+                                    int disposition,
+                                    const char *refprop,
+                                    int index,
+                                    unsigned flags,
+                                    const char *property,
+                                    double number,
+                                    struct collection_item **ret_ref)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_double_property_with_ref", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_DOUBLE,
+                                     (void *)&number,
+                                     sizeof(double),
+                                     ret_ref);
+
+    TRACE_FLOW_NUMBER("insert_double_property_with_ref returning", error);
+    return error;
+}
+
+/* Insert bool property with positioning and reference. */
+int insert_bool_property_with_ref(struct collection_item *ci,
+                                  const char *subcollection,
+                                  int disposition,
+                                  const char *refprop,
+                                  int index,
+                                  unsigned flags,
+                                  const char *property,
+                                  unsigned char logical,
+                                  struct collection_item **ret_ref)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("insert_bool_property_with_ref", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     disposition,
+                                     refprop,
+                                     index,
+                                     flags,
+                                     property,
+                                     COL_TYPE_BOOL,
+                                     (void *)&logical,
+                                     sizeof(unsigned char),
+                                     ret_ref);
+
+    TRACE_FLOW_NUMBER("insert_bool_property_with_ref returning", error);
+    return error;
+}
+
+
+/* Add a string property. */
+int add_str_property(struct collection_item *ci,
+                     const char *subcollection,
+                     const char *property,
+                     char *string,
+                     int length)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_str_property", "Entry.");
+
+    error = insert_str_property(ci,
+                                subcollection,
+                                COL_DSP_END,
+                                NULL,
+                                0,
+                                0,
+                                property,
+                                string,
+                                length);
+
+    TRACE_FLOW_NUMBER("add_str_property returning", error);
+    return error;
+}
+
+/* Add a binary property. */
+int add_binary_property(struct collection_item *ci,
+                        const char *subcollection,
+                        const char *property,
+                        void *binary_data,
+                        int length)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_binary_property", "Entry.");
+
+    error = insert_binary_property(ci,
+                                   subcollection,
+                                   COL_DSP_END,
+                                   NULL,
+                                   0,
+                                   0,
+                                   property,
+                                   binary_data,
+                                   length);
+
+    TRACE_FLOW_NUMBER("add_binary_property returning", error);
+    return error;
+}
+
+/* Add an int property. */
+int add_int_property(struct collection_item *ci,
+                     const char *subcollection,
+                     const char *property,
+                     int number)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_int_property", "Entry.");
+
+    error = insert_int_property(ci,
+                                subcollection,
+                                COL_DSP_END,
+                                NULL,
+                                0,
+                                0,
+                                property,
+                                number);
+
+    TRACE_FLOW_NUMBER("add_int_property returning", error);
+    return error;
+}
+
+/* Add an unsigned int property. */
+int add_unsigned_property(struct collection_item *ci,
+                          const char *subcollection,
+                          const char *property,
+                          unsigned int number)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_unsigned_property", "Entry.");
+
+    error = insert_unsigned_property(ci,
+                                     subcollection,
+                                     COL_DSP_END,
+                                     NULL,
+                                     0,
+                                     0,
+                                     property,
+                                     number);
+
+    TRACE_FLOW_NUMBER("add_unsigned_property returning", error);
+    return error;
+}
+
+/* Add an long property. */
+int add_long_property(struct collection_item *ci,
+                      const char *subcollection,
+                      const char *property,
+                      long number)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_long_property", "Entry.");
+
+
+    error = insert_long_property(ci,
+                                 subcollection,
+                                 COL_DSP_END,
+                                 NULL,
+                                 0,
+                                 0,
+                                 property,
+                                 number);
+
+    TRACE_FLOW_NUMBER("add_long_property returning", error);
+    return error;
+}
+
+/* Add an unsigned long property. */
+int add_ulong_property(struct collection_item *ci,
+                       const char *subcollection,
+                       const char *property,
+                       unsigned long number)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_ulong_property", "Entry.");
+
+    error = insert_ulong_property(ci,
+                                  subcollection,
+                                  COL_DSP_END,
+                                  NULL,
+                                  0,
+                                  0,
+                                  property,
+                                  number);
+
+    TRACE_FLOW_NUMBER("add_ulong_property returning", error);
+    return error;
+}
+
+/* Add a double property. */
+int add_double_property(struct collection_item *ci,
+                        const char *subcollection,
+                        const char *property,
+                        double number)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_double_property", "Entry.");
+
+    error = insert_double_property(ci,
+                                   subcollection,
+                                   COL_DSP_END,
+                                   NULL,
+                                   0,
+                                   0,
+                                   property,
+                                   number);
+
+    TRACE_FLOW_NUMBER("add_double_property returning", error);
+    return error;
+}
+
+/* Add a bool property. */
+int add_bool_property(struct collection_item *ci,
+                      const char *subcollection,
+                      const char *property,
+                      unsigned char logical)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_bool_property", "Entry.");
+
+    error = insert_bool_property(ci,
+                                 subcollection,
+                                 COL_DSP_END,
+                                 NULL,
+                                 0,
+                                 0,
+                                 property,
+                                 logical);
+
+    TRACE_FLOW_NUMBER("add_bool_property returning", error);
+    return error;
+}
+
+/* A function to add a property */
+int add_any_property(struct collection_item *ci,
+                     const char *subcollection,
+                     const char *property,
+                     int type,
+                     void *data,
+                     int length)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_any_property", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     COL_DSP_END,
+                                     NULL,
+                                     0,
+                                     0,
+                                     property,
+                                     type,
+                                     data,
+                                     length,
+                                     NULL);
+
+    TRACE_FLOW_NUMBER("add_any_property returning", error);
+    return error;
+}
+
+/* Add a string property with reference */
+inline int add_str_property_with_ref(struct collection_item *ci,
+                                     const char *subcollection,
+                                     const char *property,
+                                     char *string, int length,
+                                     struct collection_item **ref_ret)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_str_property_with_ref", "Entry.");
+
+    error = insert_str_property_with_ref(ci,
+                                         subcollection,
+                                         COL_DSP_END,
+                                         NULL,
+                                         0,
+                                         0,
+                                         property,
+                                         string,
+                                         length,
+                                         ref_ret);
+
+    TRACE_FLOW_NUMBER("add_str_property_with_ref returning", error);
+    return error;
+}
+
+/* Add a binary property with reference. */
+int add_binary_property_with_ref(struct collection_item *ci,
+                                 const char *subcollection,
+                                 const char *property,
+                                 void *binary_data, int length,
+                                 struct collection_item **ref_ret)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_binary_property_with_ref", "Entry.");
+
+    error = insert_binary_property_with_ref(ci,
+                                            subcollection,
+                                            COL_DSP_END,
+                                            NULL,
+                                            0,
+                                            0,
+                                            property,
+                                            binary_data,
+                                            length,
+                                            ref_ret);
+
+    TRACE_FLOW_NUMBER("add_binary_property_with_ref returning", error);
+    return error;
+}
+
+/* Add an int property with reference. */
+int add_int_property_with_ref(struct collection_item *ci,
+                              const char *subcollection,
+                              const char *property,
+                              int number,
+                              struct collection_item **ref_ret)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_int_property_with_ref", "Entry.");
+
+    error = insert_int_property_with_ref(ci,
+                                         subcollection,
+                                         COL_DSP_END,
+                                         NULL,
+                                         0,
+                                         0,
+                                         property,
+                                         number,
+                                         ref_ret);
+
+    TRACE_FLOW_NUMBER("add_int_property_with_ref returning", error);
+    return error;
+}
+
+/* Add an unsigned int property with reference.  */
+int add_unsigned_property_with_ref(struct collection_item *ci,
+                                   const char *subcollection,
+                                   const char *property,
+                                   unsigned int number,
+                                   struct collection_item **ref_ret)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_unsigned_property_with_ref", "Entry.");
+
+    error = insert_unsigned_property_with_ref(ci,
+                                              subcollection,
+                                              COL_DSP_END,
+                                              NULL,
+                                              0,
+                                              0,
+                                              property,
+                                              number,
+                                              ref_ret);
+
+    TRACE_FLOW_NUMBER("add_unsigned_property_with_ref returning", error);
+    return error;
+}
+
+/* Add an long property with reference. */
+int add_long_property_with_ref(struct collection_item *ci,
+                               const char *subcollection,
+                               const char *property,
+                               long number,
+                               struct collection_item **ref_ret)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_long_property_with_ref", "Entry.");
+
+    error = insert_long_property_with_ref(ci,
+                                          subcollection,
+                                          COL_DSP_END,
+                                          NULL,
+                                          0,
+                                          0,
+                                          property,
+                                          number,
+                                          ref_ret);
+
+    TRACE_FLOW_NUMBER("add_long_property_with_ref returning", error);
+    return error;
+}
+
+/* Add an unsigned long property with reference. */
+int add_ulong_property_with_ref(struct collection_item *ci,
+                                const char *subcollection,
+                                const char *property,
+                                unsigned long number,
+                                struct collection_item **ref_ret)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_ulong_property_with_ref", "Entry.");
+
+    error = insert_ulong_property_with_ref(ci,
+                                           subcollection,
+                                           COL_DSP_END,
+                                           NULL,
+                                           0,
+                                           0,
+                                           property,
+                                           number,
+                                           ref_ret);
+
+    TRACE_FLOW_NUMBER("add_ulong_property_with_ref returning", error);
+    return error;
+}
+
+/* Add a double property with reference. */
+int add_double_property_with_ref(struct collection_item *ci,
+                                 const char *subcollection,
+                                 const char *property,
+                                 double number,
+                                 struct collection_item **ref_ret)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_double_property_with_ref", "Entry.");
+
+    error = insert_double_property_with_ref(ci,
+                                            subcollection,
+                                            COL_DSP_END,
+                                            NULL,
+                                            0,
+                                            0,
+                                            property,
+                                            number,
+                                            ref_ret);
+
+    TRACE_FLOW_NUMBER("add_double_property_with_ref returning", error);
+    return error;
+}
+
+/* Add a bool property with reference. */
+int add_bool_property_with_ref(struct collection_item *ci,
+                               const char *subcollection,
+                               const char *property,
+                               unsigned char logical,
+                               struct collection_item **ref_ret)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_bool_property_with_ref", "Entry.");
+
+    error = insert_bool_property_with_ref(ci,
+                                          subcollection,
+                                          COL_DSP_END,
+                                          NULL,
+                                          0,
+                                          0,
+                                          property,
+                                          logical,
+                                          ref_ret);
+
+    TRACE_FLOW_NUMBER("add_bool_property_with_ref returning", error);
+    return error;
+}
+
+/* A function to add a property with reference. */
+int add_any_property_with_ref(struct collection_item *ci,
+                              const char *subcollection,
+                              const char *property,
+                              int type,
+                              void *data,
+                              int length,
+                              struct collection_item **ref_ret)
+{
+    int error = EOK;
+
+    TRACE_FLOW_STRING("add_any_property_with_ref", "Entry.");
+
+    error = insert_property_with_ref(ci,
+                                     subcollection,
+                                     COL_DSP_END,
+                                     NULL,
+                                     0,
+                                     0,
+                                     property,
+                                     type,
+                                     data,
+                                     length,
+                                     ref_ret);
+
+    TRACE_FLOW_NUMBER("add_any_property_with_ref returning", error);
+    return error;
+}
+
+
+/* Update a string property in the collection.
+ * Length should include the terminating 0  */
+int update_str_property(struct collection_item *ci,
+                        const char *property,
+                        int mode_flags,
+                        char *string,
+                        int length)
+{
+    int error = EOK;
+    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);
+
+    TRACE_FLOW_NUMBER("update_str_property Returning", error);
+    return error;
+}
+
+/* Update a binary property in the collection.  */
+int update_binary_property(struct collection_item *ci,
+                           const char *property,
+                           int mode_flags,
+                           void *binary_data,
+                           int length)
+{
+    int error = EOK;
+    TRACE_FLOW_STRING("update_binary_property", "Entry.");
+
+    error =  update_property(ci, property, COL_TYPE_BINARY,
+                             binary_data, length, mode_flags);
+
+    TRACE_FLOW_NUMBER("update_binary_property Returning", error);
+    return error;
+}
+
+/* Update an int property in the collection. */
+int update_int_property(struct collection_item *ci,
+                        const char *property,
+                        int mode_flags,
+                        int number)
+{
+    int error = EOK;
+    TRACE_FLOW_STRING("update_int_property", "Entry.");
+
+    error =  update_property(ci, property, COL_TYPE_INTEGER,
+                             (void *)(&number), sizeof(int), mode_flags);
+
+    TRACE_FLOW_NUMBER("update_int_property Returning", error);
+    return error;
+}
+
+/* Update an unsigned int property. */
+int update_unsigned_property(struct collection_item *ci,
+                             const char *property,
+                             int mode_flags,
+                             unsigned int number)
+{
+    int error = EOK;
+    TRACE_FLOW_STRING("update_unsigned_property", "Entry.");
+
+    error =  update_property(ci, property, COL_TYPE_UNSIGNED,
+                             (void *)(&number), sizeof(unsigned int),
+                             mode_flags);
+
+    TRACE_FLOW_NUMBER("update_unsigned_property Returning", error);
+    return error;
+}
+
+/* Update a long property. */
+int update_long_property(struct collection_item *ci,
+                         const char *property,
+                         int mode_flags,
+                         long number)
+{
+    int error = EOK;
+    TRACE_FLOW_STRING("update_long_property", "Entry.");
+
+    error =  update_property(ci, property, COL_TYPE_LONG,
+                             (void *)(&number), sizeof(long), mode_flags);
+
+    TRACE_FLOW_NUMBER("update_long_property Returning", error);
+    return error;
+
+}
+
+/* Update an unsigned long property. */
+int update_ulong_property(struct collection_item *ci,
+                          const char *property,
+                          int mode_flags,
+                          unsigned long number)
+{
+    int error = EOK;
+    TRACE_FLOW_STRING("update_ulong_property", "Entry.");
+
+    error =  update_property(ci, property, COL_TYPE_ULONG,
+                             (void *)(&number), sizeof(unsigned long),
+                             mode_flags);
+
+    TRACE_FLOW_NUMBER("update_ulong_property Returning", error);
+    return error;
+}
+
+/* Update a double property. */
+int update_double_property(struct collection_item *ci,
+                           const char *property,
+                           int mode_flags,
+                           double number)
+{
+    int error = EOK;
+    TRACE_FLOW_STRING("update_double_property", "Entry.");
+
+    error =  update_property(ci, property, COL_TYPE_DOUBLE,
+                             (void *)(&number), sizeof(double), mode_flags);
+
+    TRACE_FLOW_NUMBER("update_double_property Returning", error);
+    return error;
+}
+
+/* Update a bool property. */
+int update_bool_property(struct collection_item *ci,
+                         const char *property,
+                         int mode_flags,
+                         unsigned char logical)
+{
+    int error = EOK;
+    TRACE_FLOW_STRING("update_bool_property", "Entry.");
+
+    error =  update_property(ci, property, COL_TYPE_BOOL,
+                             (void *)(&logical), sizeof(unsigned char),
+                             mode_flags);
+
+    TRACE_FLOW_NUMBER("update_bool_property Returning", error);
+    return error;
+}
+
+/* Rename item */
+int modify_item_property(struct collection_item *item,
+                         const char *property)
+{
+    int error;
+
+    TRACE_FLOW_STRING("modify_item_property", "Entry");
+
+    error = modify_item(item, property, 0, NULL, 0);
+
+    TRACE_FLOW_STRING("modify_item_property", "Exit");
+    return error;
+}
+
+/* Convenience functions that wrap modify_item(). */
+/* Modify item data to be str */
+int modify_str_item(struct collection_item *item,
+                    const char *property,
+                    char *string,
+                    int length)
+{
+    int len;
+    int error;
+
+    TRACE_FLOW_STRING("modify_str_item", "Entry");
+
+    if (length != 0) len = length;
+    else len = strlen(string) + 1;
+
+    error = modify_item(item, property, COL_TYPE_STRING, (void *)string, len);
+
+    TRACE_FLOW_STRING("modify_str_item", "Exit");
+    return error;
+}
+
+/* Modify item data to be binary */
+int modify_binary_item(struct collection_item *item,
+                       const char *property,
+                       void *binary_data,
+                       int length)
+{
+    int error;
+
+    TRACE_FLOW_STRING("modify_binary_item", "Entry");
+
+    error = modify_item(item, property, COL_TYPE_BINARY, binary_data, length);
+
+    TRACE_FLOW_STRING("modify_binary_item", "Exit");
+    return error;
+}
+
+/* Modify item data to be bool */
+int modify_bool_item(struct collection_item *item,
+                     const char *property,
+                     unsigned char logical)
+{
+    int error;
+
+    TRACE_FLOW_STRING("modify_bool_item", "Entry");
+
+    error = modify_item(item, property, COL_TYPE_BOOL, (void *)(&logical), 1);
+
+    TRACE_FLOW_STRING("modify_bool_item", "Exit");
+    return error;
+}
+
+/* Modify item data to be int */
+int modify_int_item(struct collection_item *item,
+                    const char *property,
+                    int number)
+{
+    int error;
+
+    TRACE_FLOW_STRING("modify_int_item","Entry");
+
+    error = modify_item(item, property, COL_TYPE_INTEGER,
+                        (void *)(&number), sizeof(int));
+
+    TRACE_FLOW_STRING("modify_int_item", "Exit");
+    return error;
+}
+
+/* Modify item data to be long */
+int modify_long_item(struct collection_item *item,
+                     const char *property,
+                     long number)
+{
+    int error;
+
+    TRACE_FLOW_STRING("modify_long_item", "Entry");
+
+    error = modify_item(item, property, COL_TYPE_LONG,
+                        (void *)(&number), sizeof(long));
+
+    TRACE_FLOW_STRING("modify_long_item", "Exit");
+    return error;
+}
+
+/* Modify item data to be unigned long */
+int modify_ulong_item(struct collection_item *item,
+                      const char *property,
+                      unsigned long number)
+{
+    int error;
+
+    TRACE_FLOW_STRING("modify_ulong_item", "Entry");
+
+    error = modify_item(item, property, COL_TYPE_ULONG,
+                        (void *)(&number), sizeof(unsigned long));
+
+    TRACE_FLOW_STRING("modify_ulong_item", "Exit");
+    return error;
+}
+
+int modify_unsigned_item(struct collection_item *item,
+                         const char *property,
+                         unsigned number)
+{
+    int error;
+
+    TRACE_FLOW_STRING("modify_unsigned_item", "Entry");
+
+    error = modify_item(item, property, COL_TYPE_UNSIGNED,
+                        (void *)(&number), sizeof(unsigned));
+
+    TRACE_FLOW_STRING("modify_unsigned_item", "Exit");
+    return error;
+}
+
+int modify_double_item(struct collection_item *item,
+                       const char *property,
+                       double number)
+{
+    int error;
+
+    TRACE_FLOW_STRING("modify_double_item", "Entry");
+
+    error = modify_item(item, property, COL_TYPE_DOUBLE,
+                        (void *)(&number), sizeof(double));
+
+    TRACE_FLOW_STRING("modify_double_item", "Exit");
+    return error;
+}