MeVisLab/Standard/Sources/Inventor/SoShader/Inventor/SbList.h

Go to the documentation of this file.

// **InsertLicense** code
//-----------------------------------------------------------------------------

#ifndef  _SB_LIST_
#define  _SB_LIST_

#include "SoShaderSystem.h"


// This class is loosely derived from class SbPList.

template <class Type> 
class SbList
{
   public:
   
      // Constructor
      SbList() {
         ptrs  = NULL;
         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 = (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 != NULL) {
            for(int i = 0; i < nPtrs; i++)
               newPtrs[i] = ptrs[i];
            delete [] ptrs;
         }

         ptrs = newPtrs;
      }
};

#endif  // _SB_LIST_