GenDataObj.h

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     7-10-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

/// GenDataObj.h
///  Simainlib
/// A generic data object

#ifndef __SIMIAN_GENERIC_DATA_OBJ_DOT_H
#define __SIMIAN_GENERIC_DATA_OBJ_DOT_H

#include <core/DataObj.h>
#include <smartptr.h>
#include <vector>

//////////////////////////////////////////////////////////////////
/// a base class for 2 kinds of generic data objects.
/// this is just the interface, see the classes below too.
///  fills data vector with "nObs" Null objects, just place holders

template<class T, class P>
class GenDataObj_base : public DataObj
{
public:
   typedef T                     DATA_TYPE;
   typedef P                     PTR_TYPE;
   typedef std::vector<PTR_TYPE> VEC_TYPE;

   /// child classes are responsible for
   /// deleting their data
   virtual ~GenDataObj_base() 
   {
   } 
   
   ////////////////////////////////////////
   /// Public DATA
   ////////////////////////////////////////

   /// a vector of "ptrs" to the data
   VEC_TYPE dataVec;
   
   ////////////////////////////////////////
   /// Safe interface, use it if you like
   ////////////////////////////////////////

   ////////////////////////////////////////
   /// restate the size
   int size() { return int(dataVec.size()); }

   ////////////////////////////////////////
   /// safe way to get the data, zeroth by default
   PTR_TYPE getData(int i=0)
   {
      if(i >= size())
         return PTR_TYPE(0);
      return dataVec[i];
   }

   ////////////////////////////////////////
   /// safe way to set the data
   void setData(int i, PTR_TYPE d)
   {
      if( i > size() )
         for(int k = size()-1; k<i; ++k)
            dataVec.push_back(PTR_TYPE(0));
      dataVec[i] = d;
   }

   ////////////////////////////////////////
   /// set zeroth entry for convenience
   void setData(PTR_TYPE d)
   {
      if(dataVec.size() == 0)
         dataVec.push_back(d);
      else
         dataVec[0] = d;
   }

   ////////////////////////////////////////
   /// delete an entry
   void delData(int i=0)
   {
      if(i >= size()) return;
      _delData(i);
   }

   ////////////////////////////////////////
   /// pack vector
   void pack()
   {
      int laste = 0;
      for(int i=0; i < size(); ++i)
      {
         if(!dataVec[i]) continue;
         if(laste != i)
            dataVec[laste] = dataVec[i];
         ++laste;
      }
      for(int i=laste; i< size(); ++i)
         dataVec.pop_back();
   }

protected:
   GenDataObj_base(int nObjs, const char *name=0)
      : DataObj()
   { 
      if(name)
         SimBase::setName(name); 
      for(int i=0; i<nObjs; ++i)
         dataVec.push_back((PTR_TYPE)(0));
   }
   virtual void _delData(int i) = 0;
};


//////////////////////////////////////////////////////////////////
/// this is a generic data object for all types that are "Counted"
template<class T>
class GenDataObj : public GenDataObj_base< T , gutz::SmartPtr<T> > {
public:
   typedef GenDataObj_base<T, gutz::SmartPtr<T> > BASE_TYPE;
   typedef typename BASE_TYPE::DATA_TYPE          DATA_TYPE;
   typedef typename BASE_TYPE::PTR_TYPE           PTR_TYPE;
   typedef typename BASE_TYPE::VEC_TYPE           VEC_TYPE;

   GenDataObj(int nObjs=0, const char *name=0)
      : BASE_TYPE(nObjs,name)
   { 
   }

   /// smartptrs nuke themselves
   virtual ~GenDataObj() {} 


protected:
   virtual void _delData(int i)
   {
      dataVec[i] = PTR_TYPE(0);
   }
};

//////////////////////////////////////////////////////////////////
/// this is a generic data object for all types that are 
/// NOT "Counted", you have a choice, let the data be deleted
/// with this class, or nuke it yourself
template<class T>
class GenDataObjNSP : public GenDataObj_base< T , T*> {
public:
   typedef GenDataObj_base< T , T*>          BASE_TYPE;
   typedef typename BASE_TYPE::DATA_TYPE     DATA_TYPE;
   typedef typename BASE_TYPE::PTR_TYPE      PTR_TYPE;
   typedef typename BASE_TYPE::VEC_TYPE      VEC_TYPE;

   GenDataObjNSP(int nObjs=0, const char *name=0, bool del=true)
      : BASE_TYPE(nObjs,name), _del(del)
   {
      if(_del)
         for(int i=size()-1; i >=0; --i)
         {
            _delData(i);
            dataVec.pop_back();
         }
   }

   /// real pointers, yuky
   virtual ~GenDataObjNSP() 
   {
   }

protected:
   virtual void _delData(int i)
   {
      if(_del && dataVec[i]) delete dataVec[i];
      dataVec[i] = (PTR_TYPE)(0);
   }
   bool _del;

};

#endif

---

Send questions, comments, and bug reports to: