libbdiobject_array_definition_template.h

Go to the documentation of this file.

/*********************************************************************
 ** Copyright (c) 2019 VT MAK
 ** All rights reserved.
 *********************************************************************/


#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include <libbdilog.h>
#include <new_strdup.h>
#include <bdiDataTracker.h>
#include <bdi_macros.h>

#define CLASS_NAME_AS_STRING(x) xCLASS_NAME_AS_STRING(x)
#define xCLASS_NAME_AS_STRING(x) #x

#ifdef LIBBDIOBJECT_ARRAY_INLINE
#define BDI_INLINE inline
#else
#define BDI_INLINE
#endif

namespace makVrv
{
 /****************************************************************************/
BDI_INLINE
LIBBDIOBJECT_ARRAY_CLASS_NAME::LIBBDIOBJECT_ARRAY_CLASS_NAME(int initial_size,
   int increment)
   :
   data_tracker(new bdiDataTracker())
{
   assert(data_tracker);

   if (initial_size < 1)
      initial_size = 1;
   if (increment < 1)
      increment = 1;

   /*
    *  Allocate memory.
    */
   m_num_objects_allocated = initial_size;
   m_objects = new LIBBDIOBJECT_ARRAY_TYPE*[m_num_objects_allocated];
   if (!m_objects)
   {
      bdi_log_printf(BDI_LOG_ERROR,
         "ERROR: Array out of memory trying to allocate %d objects.\n",
         initial_size);
   }

   /*
    *  Set newly allocated objects to NULL.
    */
   memset(m_objects, 0, m_num_objects_allocated * sizeof(LIBBDIOBJECT_ARRAY_TYPE*));

   /*
    *  Set more data members.
    */
   m_num_objects = 0;
   m_own_objects = 0;
   m_array_delete = 0;
   m_pop_back_delete = 0;
   m_geometric_growth = 0;
   m_name = new_strdup("");
   m_increment = increment;

   data_tracker->raise_modified_all();
}


/****************************************************************************/
// virtual
BDI_INLINE
LIBBDIOBJECT_ARRAY_CLASS_NAME::~LIBBDIOBJECT_ARRAY_CLASS_NAME()
{
   if (m_objects)
   {
      if (m_own_objects)
      {
         if (m_pop_back_delete)
         {
            LIBBDIOBJECT_ARRAY_TYPE* object;
            while ((object = pop_back()))
            {
               if (m_array_delete)
                  delete[] object;
               else
                  delete object;

               object = NULL;
            }
         }
         else
         {
            int i;
            int size = m_num_objects;
            for (i = 0; i < size; i++)
            {
               if (m_array_delete)
                  delete[] m_objects[i];
               else
                  delete m_objects[i];

               m_objects[i] = NULL;
            }
         }
      }

      m_num_objects = 0;

      if (data_tracker)
         data_tracker->raise_modified_all();

      delete[] m_objects;
      m_objects = NULL;
   }

   if (m_name)
      delete[] m_name;
   m_name = NULL;

   delete data_tracker;
   data_tracker = NULL;
}


/****************************************************************************/
BDI_INLINE int
LIBBDIOBJECT_ARRAY_CLASS_NAME::push_front(LIBBDIOBJECT_ARRAY_TYPE* object)
{
   return insert_at_index(0, object);
}


/****************************************************************************/
BDI_INLINE int
LIBBDIOBJECT_ARRAY_CLASS_NAME::push_back(LIBBDIOBJECT_ARRAY_TYPE* object)
{
   /*
    *  See if we need to allocate more space.
    */
   if (check_object_allocation(m_num_objects + 1))
      return -1;

   /*
    *  Set the information for this object.
    */
   m_objects[m_num_objects] = object;
   m_num_objects++;

   data_tracker->raise_modified_all();

   return 0;
}

/****************************************************************************/
BDI_INLINE LIBBDIOBJECT_ARRAY_TYPE*
LIBBDIOBJECT_ARRAY_CLASS_NAME::replace_at_index(int index, LIBBDIOBJECT_ARRAY_TYPE* object_ptr)
{
   if ((index < 0) ||
      (index > m_num_objects))
   {
      return NULL;
   }

   LIBBDIOBJECT_ARRAY_TYPE* object = m_objects[index];
   m_objects[index] = object_ptr;

   data_tracker->raise_modified_all();

   return object;
}


/****************************************************************************/
BDI_INLINE int
LIBBDIOBJECT_ARRAY_CLASS_NAME::insert_at_index(int index, LIBBDIOBJECT_ARRAY_TYPE* object_ptr)
{
   int i;

   if ((index < 0) ||
      (index > m_num_objects))
   {
      return -1;
   }

   /*
    *  Make sure we have enough memory allocated.
    */
   if (check_object_allocation(m_num_objects + 1))
      return -1;

   /*
    *  Shift all objects after the specified object right.
    */
   for (i = m_num_objects; i > index; i--)
      m_objects[i] = m_objects[i - 1];

   /*
    *  Add the object at index.
    */
   m_objects[index] = object_ptr;

   m_num_objects += 1;

   data_tracker->raise_modified_all();

   return 0;
}


/****************************************************************************/
BDI_INLINE LIBBDIOBJECT_ARRAY_TYPE*
LIBBDIOBJECT_ARRAY_CLASS_NAME::pop_front(void)
{
   return remove_at_index(0);
}


/****************************************************************************/
BDI_INLINE LIBBDIOBJECT_ARRAY_TYPE*
LIBBDIOBJECT_ARRAY_CLASS_NAME::pop_back(void)
{
   LIBBDIOBJECT_ARRAY_TYPE* object = NULL;

   if (m_num_objects == 0)
      return NULL;

   object = m_objects[m_num_objects - 1];
   m_num_objects -= 1;

   data_tracker->raise_modified_all();

   return object;
}


/****************************************************************************/
BDI_INLINE LIBBDIOBJECT_ARRAY_TYPE*
LIBBDIOBJECT_ARRAY_CLASS_NAME::remove_at_index(int index)
{
   LIBBDIOBJECT_ARRAY_TYPE* object = NULL;
   int i;

   if ((index < 0) ||
      (index >= m_num_objects))
   {
      return NULL;
   }

   object = m_objects[index];

   /*
    *  Shift all objects after the specified object left.
    */
   for (i = index; i < (m_num_objects - 1); i++)
      m_objects[i] = m_objects[i + 1];

   m_objects[m_num_objects - 1] = NULL;

   m_num_objects -= 1;

   data_tracker->raise_modified_all();

   return object;
}


/****************************************************************************/
BDI_INLINE int
LIBBDIOBJECT_ARRAY_CLASS_NAME::delete_at_index(int index)
{
   LIBBDIOBJECT_ARRAY_TYPE* object = NULL;

   if ((index < 0) ||
      (index >= m_num_objects))
   {
      return -1;
   }

   object = remove_at_index(index);
   if (!object)
      return -1;

   if (m_array_delete)
      delete[] object;
   else
      delete object;

   return 0;
}


/****************************************************************************/
BDI_INLINE LIBBDIOBJECT_ARRAY_TYPE*
LIBBDIOBJECT_ARRAY_CLASS_NAME::remove(LIBBDIOBJECT_ARRAY_TYPE* object)
{
   int i;
   int index = -1;

   /*
    *  Find the passed pointer in m_objects.
    */
   for (i = 0; (i < m_num_objects && (index == -1)); i++)
   {
      if (object == m_objects[i])
         index = i;
   }

   if (index != -1)
      return remove_at_index(index);

   return NULL;
}


/****************************************************************************/
BDI_INLINE int
LIBBDIOBJECT_ARRAY_CLASS_NAME::remove_all(void)
{
   if (m_objects)
   {
      if (m_own_objects)
      {
         if (m_pop_back_delete)
         {
            LIBBDIOBJECT_ARRAY_TYPE* object;
            while ((object = pop_back()))
            {
               if (m_array_delete)
                  delete[] object;
               else
                  delete object;
            }
         }
         else
         {
            int i;
            int size = m_num_objects;
            for (i = 0; i < size; i++)
            {
               if (m_array_delete)
                  delete[] m_objects[i];
               else
                  delete m_objects[i];
            }
         }
      }
      if (m_num_objects != 0)
      {
         m_num_objects = 0;
         data_tracker->raise_modified_all();
      }
   }

   return 0;
}


/****************************************************************************/
BDI_INLINE LIBBDIOBJECT_ARRAY_TYPE*
LIBBDIOBJECT_ARRAY_CLASS_NAME::get_at_index(int index) const
{

#ifdef LIBBDIOBJECT_ARRAY_DISABLE_BOUNDS_CHECKING

   assert((index >= 0) && (index < m_num_objects));

#else

   if ((index < 0) ||
      (index >= m_num_objects))
   {
#ifdef BDI_DEBUG
      bdi_log_printf(BDI_LOG_WARN, "WARNING: Index %d out of bounds in %s; legal indices are %d to %d.\n",
         index,
         CLASS_NAME_AS_STRING(LIBBDIOBJECT_ARRAY_CLASS_NAME),
         0,
         m_num_objects - 1);
#endif

      return NULL;
   }

#endif

   return m_objects[index];
}


/****************************************************************************/
BDI_INLINE LIBBDIOBJECT_ARRAY_TYPE*
LIBBDIOBJECT_ARRAY_CLASS_NAME::operator [] (int index) const
{

#ifdef LIBBDIOBJECT_ARRAY_DISABLE_BOUNDS_CHECKING

   assert((index >= 0) && (index < m_num_objects));

#else

   if ((index < 0) ||
      (index >= m_num_objects))
   {
#ifdef BDI_DEBUG
      bdi_log_printf(BDI_LOG_WARN, "WARNING: Index %d out of bounds in %s; legal indices are %d to %d.\n",
         index,
         CLASS_NAME_AS_STRING(LIBBDIOBJECT_ARRAY_CLASS_NAME),
         0,
         m_num_objects - 1);
#endif

      return NULL;
   }

#endif

   return m_objects[index];
}


/****************************************************************************/
BDI_INLINE int
LIBBDIOBJECT_ARRAY_CLASS_NAME::get_index(LIBBDIOBJECT_ARRAY_TYPE* object) const
{
   int i;

   /*
    *  Find the passed pointer in m_objects.
    */
   for (i = 0; i < m_num_objects; i++)
   {
      if (object == m_objects[i])
         return i;
   }

   return -1;
}


/****************************************************************************/
BDI_INLINE void
LIBBDIOBJECT_ARRAY_CLASS_NAME::get_indices(int* indices,
   const LIBBDIOBJECT_ARRAY_CLASS_NAME& src) const
{
   BDI_ASSERT_AND_RET_IF_NULL(indices);
   assert(m_num_objects >= 0);

   // for small objects, do it the original way
   if ((m_num_objects < 4) || (src.size() < 4))
   {
      int i;
      for (i = 0; i < src.size(); i++)
      {
         indices[i] = get_index(src[i]);
      }
      return;
   }

   // uses open address hashtables, see CLR pg 232

   // find the first power of two at least twice as large as m_num_objects
   unsigned int htsize = 2;
   while (htsize < (2 * (unsigned int)m_num_objects)) htsize <<= 1;
   assert(htsize);                        /* overflow */

   unsigned int i, j;
   int k;

   // initialize the hashtable
   int *htvals = new int[htsize];
   for (i = 0; i < htsize; i++)
   {
      htvals[i] = -1;
   }

#ifdef BDI_DEBUG
   unsigned int total_search = 0;
   unsigned int longest_search = 0;
#endif

   // populate the hashtable
   for (k = 0; k < m_num_objects; k++)
   {
      LIBBDIOBJECT_ARRAY_TYPE* lookfor = m_objects[k];
      unsigned int h1 = ((unsigned int)(lookfor - m_objects[0])) % htsize;
      unsigned int h2 = (((unsigned int)(lookfor - m_objects[0])) * 2 + 1) % htsize;
      for (i = 0; i <= htsize; i++)
      {
         j = (h1 + i * h2) % htsize;
         if (htvals[j] == -1)
         {
            htvals[j] = k;
            break;
         }
         else if (m_objects[htvals[j]] == lookfor)
         {
            // do not insert duplicate entry
            break;
         }
      }
      assert(i <= htsize);//overflow
#ifdef BDI_DEBUG
      total_search += i;
      if (i > longest_search)
      {
         longest_search = i;
      }
#endif
   }

#ifdef BDI_DEBUG
   bdi_log_printf(BDI_LOG_DEBUG_LV6, "libbdiobject_array::get_indices: n = %d, m = %u, total = %u, longest = %u, avg = %g\n",
      m_num_objects, htsize, total_search, longest_search, m_num_objects ? (((double)total_search) / m_num_objects) : 0.0);
#endif

   // now search the hashtable
   int nk = src.size();
   for (k = 0; k < nk; k++)
   {
      LIBBDIOBJECT_ARRAY_TYPE* lookfor = src[k];
      unsigned int h1 = ((unsigned int)(lookfor - m_objects[0])) % htsize;
      unsigned int h2 = (((unsigned int)(lookfor - m_objects[0])) * 2 + 1) % htsize;
      indices[k] = -1;
      for (i = 0; i <= htsize; i++)
      {
         j = (h1 + i * h2) % htsize;
         if ((m_objects[htvals[j]] == lookfor) || (htvals[j] == -1))
         {
            indices[k] = htvals[j];
            break;
         }
      }
   }

   delete[] htvals;
}


/****************************************************************************/
BDI_INLINE void
LIBBDIOBJECT_ARRAY_CLASS_NAME::get_ushort_indices(unsigned short* indices,
   const LIBBDIOBJECT_ARRAY_CLASS_NAME& src) const
{
   BDI_ASSERT_AND_RET_IF_NULL(indices);
   assert(m_num_objects >= 0);

   // for small objects, do it the original way
   if ((m_num_objects < 4) || (src.size() < 4))
   {
      int i;
      for (i = 0; i < src.size(); i++)
      {
         indices[i] = (unsigned short)get_index(src[i]);
      }
      return;
   }

   // uses open address hashtables, see CLR pg 232

   // find the first power of two at least twice as large as m_num_objects
   unsigned int htsize = 2;
   while (htsize < (2 * (unsigned int)m_num_objects)) htsize <<= 1;
   assert(htsize);                        /* overflow */

   unsigned int i, j;
   int k;

   // initialize the hashtable
   int *htvals = new int[htsize];
   for (i = 0; i < htsize; i++)
   {
      htvals[i] = -1;
   }

#ifdef BDI_DEBUG
   unsigned int total_search = 0;
   unsigned int longest_search = 0;
#endif

   // populate the hashtable
   for (k = 0; k < m_num_objects; k++)
   {
      LIBBDIOBJECT_ARRAY_TYPE* lookfor = m_objects[k];
      unsigned int h1 = ((unsigned int)(lookfor - m_objects[0])) % htsize;
      unsigned int h2 = (((unsigned int)(lookfor - m_objects[0])) * 2 + 1) % htsize;
      for (i = 0; i <= htsize; i++)
      {
         j = (h1 + i * h2) % htsize;
         if (htvals[j] == -1)
         {
            htvals[j] = k;
            break;
         }
         else if (m_objects[htvals[j]] == lookfor)
         {
            // do not insert duplicate entry
            break;
         }
      }
      assert(i <= htsize);//overflow
#ifdef BDI_DEBUG
      total_search += i;
      if (i > longest_search)
      {
         longest_search = i;
      }
#endif
   }

#ifdef BDI_DEBUG
   bdi_log_printf(BDI_LOG_DEBUG_LV6, "libbdiobject_array::get_indices: n = %d, m = %u, total = %u, longest = %u, avg = %g\n",
      m_num_objects, htsize, total_search, longest_search, m_num_objects ? (((double)total_search) / m_num_objects) : 0.0);
#endif

   // now search the hashtable
   int nk = src.size();
   for (k = 0; k < nk; k++)
   {
      LIBBDIOBJECT_ARRAY_TYPE* lookfor = src[k];
      unsigned int h1 = ((unsigned int)(lookfor - m_objects[0])) % htsize;
      unsigned int h2 = (((unsigned int)(lookfor - m_objects[0])) * 2 + 1) % htsize;
      indices[k] = (unsigned short)-1;
      for (i = 0; i <= htsize; i++)
      {
         j = (h1 + i * h2) % htsize;
         if ((m_objects[htvals[j]] == lookfor) || (htvals[j] == -1))
         {
            indices[k] = (unsigned short)htvals[j];
            break;
         }
      }
   }

   delete[] htvals;
}


/****************************************************************************/
BDI_INLINE int
LIBBDIOBJECT_ARRAY_CLASS_NAME::resize_allocation(int new_num_objects)
{
   if (m_num_objects_allocated == new_num_objects)
      return 0;

   int i;

   LIBBDIOBJECT_ARRAY_TYPE** old_objects = m_objects;
   int old_num_objects = m_num_objects;
   int old_num_objects_allocated = m_num_objects_allocated;

   if (new_num_objects > m_num_objects_allocated)
   {
      // need to grow the array.
      m_num_objects_allocated = new_num_objects;

      m_objects = new LIBBDIOBJECT_ARRAY_TYPE*[m_num_objects_allocated];
      if (m_objects == NULL)
      {
         bdi_log_printf(BDI_LOG_ERROR, "ERROR: %s %d Out of memory.\n",
            __FILE__, __LINE__);
         return -1;
      }

      /*
       *  Transfer old objects to new objects.  Don't set m_num_objects.
       */
      memcpy(m_objects, old_objects, old_num_objects_allocated * sizeof(LIBBDIOBJECT_ARRAY_TYPE*));

      memset(&m_objects[old_num_objects_allocated],
         0,
         (m_num_objects_allocated - old_num_objects_allocated) * sizeof(LIBBDIOBJECT_ARRAY_TYPE*));

      /*
       *  Delete old objects.
       */
      delete[] old_objects;
      return 0;
   }

   /*
    *  Need to shrink the array.
    *
    *  If m_num_objects_allocated is 0, set it to 1 to avoid
    *   a new error.
    */
   m_num_objects_allocated = new_num_objects;

   if (m_num_objects_allocated == 0)
   {
      m_num_objects_allocated = 1;
      m_num_objects = 0;
   }

   m_objects = new LIBBDIOBJECT_ARRAY_TYPE*[m_num_objects_allocated];
   if (m_objects == NULL)
   {
      bdi_log_printf(BDI_LOG_ERROR, "ERROR: %s %d Out of memory.\n",
         __FILE__, __LINE__);
      return -1;
   }

   /*
    *  Transfer old objects to new objects.  Use new_num_objects
    *   instead of m_num_objects_allocated in case we changed
    *   m_num_objects_allocated to 1 above.
    */
   memcpy(m_objects, old_objects, new_num_objects * sizeof(LIBBDIOBJECT_ARRAY_TYPE*));

   if (m_num_objects > new_num_objects)
      m_num_objects = new_num_objects;

   /*
    *  Delete appropriate old_objects.  Again, use new_num_objects.
    */
   if (m_own_objects)
   {
      for (i = new_num_objects; i < old_num_objects; i++)
      {
         if (m_array_delete)
            delete[] old_objects[i];
         else
            delete old_objects[i];
      }
   }

   /*
    *  Delete old objects.
    */
   delete[] old_objects;
   return 0;
}


/****************************************************************************/
BDI_INLINE int
LIBBDIOBJECT_ARRAY_CLASS_NAME::check_object_allocation(int min_objects)
{
   /*
    *  See if we need to allocate more space.
    */
   if (m_num_objects_allocated < min_objects)
   {
      LIBBDIOBJECT_ARRAY_TYPE** old_objects = m_objects;
      int old_num_objects_allocated = m_num_objects_allocated;

      if (m_geometric_growth)
      {
         //use a doubling method to grow the arrays
         if (m_num_objects_allocated > 0)
            m_num_objects_allocated *= 2;
         else
            m_num_objects_allocated = 2;
      }
      else
      {
         /*
          *  If we need to allocate more objects, add at least
          *   m_increment more.
          */
         m_num_objects_allocated += m_increment;
      }
      if (m_num_objects_allocated < min_objects)
         m_num_objects_allocated = min_objects;

      m_objects = new LIBBDIOBJECT_ARRAY_TYPE*[m_num_objects_allocated];
      if (m_objects == NULL)
      {
         bdi_log_printf(BDI_LOG_ERROR, "ERROR: %s %d Out of memory.\n",
            __FILE__, __LINE__);
         return -1;
      }

      /*
       *  Transfer old objects to new objects.
       */
      if (old_num_objects_allocated > 0)
         memcpy(m_objects,
            old_objects,
            old_num_objects_allocated * sizeof(LIBBDIOBJECT_ARRAY_TYPE*));

      memset(&m_objects[old_num_objects_allocated],
         0,
         (m_num_objects_allocated - old_num_objects_allocated) * sizeof(LIBBDIOBJECT_ARRAY_TYPE*));

      /*
       *  Delete old objects.
       */
      delete[] old_objects;
   }

   return 0;
}


/****************************************************************************/
BDI_INLINE const char*
LIBBDIOBJECT_ARRAY_CLASS_NAME::get_name(void) const
{
   return m_name;
}


/****************************************************************************/
BDI_INLINE void
LIBBDIOBJECT_ARRAY_CLASS_NAME::set_name(const char* name)
{
   if (m_name)
   {
      delete[] m_name;
      m_name = NULL;
   }

   if (name && (strlen(name) > 0))
      m_name = new_strdup(name);
   else
      m_name = new_strdup("");
}


#ifdef LIBBDIOBJECT_ARRAY_DEEP_COPY

/****************************************************************************/
BDI_INLINE void
LIBBDIOBJECT_ARRAY_CLASS_NAME::deep_copy(const LIBBDIOBJECT_ARRAY_CLASS_NAME & rhs)
{
   int i;

   // WARNING this code assumes that you manage the objects
   remove_all();
   resize_allocation(rhs.size());

   for (i = 0; i < rhs.size(); i++)
   {
      LIBBDIOBJECT_ARRAY_TYPE* new_object = new LIBBDIOBJECT_ARRAY_TYPE(*rhs.m_objects[i]);
      push_back(new_object);
   }

   data_tracker->raise_modified_all();
}

#endif  // LIBBDIOBJECT_ARRAY_DEEP_COPY


#ifdef LIBBDIOBJECT_ARRAY_PACKABLE

/****************************************************************************/
BDI_INLINE bdiCfgEntry*
LIBBDIOBJECT_ARRAY_CLASS_NAME::create_cfg_entry(bdiCfgEntry *e, const char * array_name)
{
   if (size() == 0)
      return NULL;

   bdiCfgEntry* sub_ent = new bdiCfgEntry(array_name, "");
   int i = 0;
   for (i = 0; i < size(); i++)
   {
      bdiCfgEntryLine * l = new bdiCfgEntryLine("value");
      m_objects[i]->pack_unpack(1, l);
      sub_ent->add_line(l);
   }

   if (e)
      e->add_subentry(sub_ent);

   return sub_ent;
}


/****************************************************************************/
BDI_INLINE void
LIBBDIOBJECT_ARRAY_CLASS_NAME::parse_cfg_entry(bdiCfgEntry *e)
{
   int i;

   resize_allocation(e->get_num_lines());

   for (i = 0; i < e->get_num_lines(); i++)
   {
      bdiCfgEntryLine * l = e->get_line(i);

      LIBBDIOBJECT_ARRAY_TYPE* new_object = new LIBBDIOBJECT_ARRAY_TYPE;
      push_back(new_object);
      new_object->pack_unpack(0, l);
   }

   data_tracker->raise_modified_all();
}

#endif  // LIBBDIOBJECT_ARRAY_PACKABLE


#ifdef LIBBDIOBJECT_ARRAY_PACKABLE_SUBENTRIES

/****************************************************************************/
BDI_INLINE bdiCfgEntry*
LIBBDIOBJECT_ARRAY_CLASS_NAME::create_cfg_entry(bdiCfgEntry *e, const char * array_name)
{
   if (size() == 0)
      return NULL;

   bdiCfgEntry* sub_ent = new bdiCfgEntry(array_name, "keys");
   int i = 0;
   for (i = 0; i < size(); i++)
   {
      bdiCfgEntry * l = new bdiCfgEntry("value", "");
      m_objects[i]->pack_unpack(1, l);
      sub_ent->add_subentry(l);
   }

   if (e)
      e->add_subentry(sub_ent);

   return sub_ent;
}


/****************************************************************************/
BDI_INLINE void
LIBBDIOBJECT_ARRAY_CLASS_NAME::parse_cfg_entry(bdiCfgEntry *e)
{
   int i;

   resize_allocation(e->get_num_subentries());

   for (i = 0; i < e->get_num_subentries(); i++)
   {
      bdiCfgEntry * l = e->get_subentry(i);

      LIBBDIOBJECT_ARRAY_TYPE* new_object = new LIBBDIOBJECT_ARRAY_TYPE;
      push_back(new_object);
      new_object->pack_unpack(0, l);
   }

   data_tracker->raise_modified_all();
}

#endif  // LIBBDIOBJECT_ARRAY_PACKABLE_SUBENTRIES

/****************************************************************************/
BDI_INLINE size_t
LIBBDIOBJECT_ARRAY_CLASS_NAME::get_memory_usage()
{
   size_t retval = 0;
   retval += sizeof(*this);
   if (m_name) {
      retval += strlen(m_name) * sizeof(char);
   }
   retval += m_num_objects_allocated * sizeof(LIBBDIOBJECT_ARRAY_TYPE *);
   retval += get_children_memory_usage();
   return retval;
}

/****************************************************************************/
BDI_INLINE size_t
LIBBDIOBJECT_ARRAY_CLASS_NAME::get_children_memory_usage()
{
   size_t retval = 0;
   if (m_own_objects) {
#ifdef LIBBDIOBJECT_GET_MEMORY_USAGE
      int i;
      for (i = 0; i < m_num_objects; i++)
      {
         retval += m_objects[i]->get_memory_usage();
      }
#else
      retval += sizeof(LIBBDIOBJECT_ARRAY_TYPE)*m_num_objects;
#endif
   }
   return retval;
}

#ifdef BDI_INLINE
#undef BDI_INLINE
#endif
}