SbList.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef SB_LIST_H
#define SB_LIST_H
 
#include "SoShaderSystem.h"
 
 
// This class is loosely derived from class SbPList.
 
template <class Type>
class SbList
{
   public:
 
      // Constructor
      SbList() {
         ptrs  = nullptr;
         nPtrs = ptrsSize = 0;
 
         setSize(0);
      }
 
      // Constructor allocates enough room for the given number of pointers
      SbList(int initSize) {
         ptrs  = NULL;
         nPtrs = ptrsSize = 0;
 
         setSize(initSize);             // Makes enough room for initSize entries
         setSize(0);                    // Sets nPtrs back to 0
      }
 
      // Constructor for copying
      SbList(const SbList &pl) {
         nPtrs = pl.nPtrs;
         ptrsSize = pl.ptrsSize;
         ptrs = new Type[ptrsSize];
 
         for(int i = 0; i < nPtrs; i++)
            ptrs[i] = pl.ptrs[i];
      }
 
      // Destructor
      ~SbList() {
         delete [] ptrs;
      }
 
      // Adds given pointer to end of list
      void      append(const Type &value) {
         if(nPtrs + 1 > ptrsSize) expand(nPtrs + 1);
         ptrs[nPtrs++] = value;
      }
 
      // Returns index of given pointer in list, or -1 if not found
      int       find(const Type &value) const {
         for(int i = 0; i < nPtrs; i++)
            if(ptrs[i] == value)
               return(i);
 
         return -1;     // Not found
      }
 
      // Inserts given pointer in list before pointer with given index
      void      insert(const Type &value, int addBefore) {
         // If addBefore is off the end of the list, grow the list (and
         // initialize any new elements to NULL)
         if(addBefore > nPtrs) grow(addBefore);
 
         // Make room for one more
         setSize(nPtrs + 1);
 
         // Move pointers forward to make room
         for(int i = nPtrs - 1; i > addBefore; --i)
            ptrs[i] = ptrs[i - 1];
 
         // Insert the new one
         ptrs[addBefore] = value;
      }
 
      // Removes pointer with given index
      void      remove(int which) {
         // Move all pointers after the ith one backward
         for(int i = which; i < nPtrs - 1; i++)
            ptrs[i] = ptrs[i + 1];
 
         // Shrink the list
         setSize(nPtrs - 1);
      }
 
      // Returns number of pointers in list
      int       getLength() const {
         return nPtrs;
      }
 
      // Removes all pointers after one with given index, inclusive
      // ??? should really be an error check in here
      void      truncate(int start) {
         nPtrs = start;
      }
 
      // Copy a PList
      void      copy(const SbList &pl) {
         setSize(pl.nPtrs);
 
         for(int i = 0; i < nPtrs; i++)
            ptrs[i] = pl.ptrs[i];
      }
 
      SbList   &operator =(const SbList &pl) {
         copy(pl); return *this;
      }
 
      // Returns pointer with given index
      Type     &operator [](int i) const {
         if(i >= nPtrs) grow(i);
         return ptrs[i];
      }
 
      // equality tests
      int       operator ==(const SbList &pl) const {
         return pl.nPtrs == nPtrs ? compare(pl) : FALSE;
      }
      int       operator !=(const SbList &pl) const {
         return pl.nPtrs == nPtrs ? ! compare(pl) : TRUE;
      }
 
   // Internal versions of [] that do not check for bounds:
   SoINTERNAL public:
 
      void *    get(int i) const {
         return ptrs[i];
      }
      void      set(int i, void *j) {
         ptrs[i] = j;
      }
 
   private:
 
      // NOTE: this must be called only if the number of elements in the two
      // lists is the same, otherwise badness could result
      int       compare(const SbList &pl) const {
         for(int i = 0; i < nPtrs; i++)
         if((*this)[i] != pl[i])
            return FALSE;
 
         return TRUE;
      }
 
      Type     *ptrs;           // The collection of pointers
      int       nPtrs;          // Number of pointers used
      int       ptrsSize;       // Number of pointers allocated
 
      // There are three(!) methods to expand the list.  grow() is used
      // when space is dynamically created, and needs to be initialized
      // to NULL:
      void      grow(int max) const {
         int newSize = max+1;
         int oldSize = nPtrs;
 
#ifdef DEBUG
         if(newSize <= oldSize)
            SoDebugError::post("(internal) SbList::grow", "newSize <= oldSize!");
#endif // DEBUG
 
         // Get around the const thing:
         SbList *me = static_cast<SbList *>(this);
 
         me->setSize(newSize);
 
         for(int i = oldSize; i < newSize; i++)
            me->ptrs[i] = NULL;
      }
 
      // setSize is used by grow and in other places internally where we
      // know that nothing needs to be initialized to NULL.
      void      setSize(int size) {
         if(size > ptrsSize) expand(size);
         nPtrs = size;
      }
 
      // expand is the lowest level routine.  It just reallocates the
      // array and copies over the old values.
      void      expand(int size) {
         if(ptrsSize == 0)
            ptrsSize = 4;
 
         while(size > ptrsSize) {
#ifdef DEBUG
            // check for overflow
            int oldPtrsSize = ptrsSize;
            ptrsSize *= 2;
            if(ptrsSize < oldPtrsSize)
               SoDebugError::post("SbList::expand", "Attempt to expand list beyond capacity;\n A core dump is likely");
#else
            ptrsSize *= 2;
#endif
         }
 
         Type *newPtrs = new Type[ptrsSize];
 
         if(ptrs != nullptr) {
            for(int i = 0; i < nPtrs; i++)
               newPtrs[i] = ptrs[i];
            delete [] ptrs;
         }
 
         ptrs = newPtrs;
      }
};
 
#endif  // _SB_LIST_