ClassRef.h

/*  _________________________________________________________________________
 *
 *  UTILIB: A utility library for developing portable C++ codes.
 *  Copyright (c) 2001, Sandia National Laboratories.
 *  This software is distributed under the GNU Lesser General Public License.
 *  For more information, see the README file in the top UTILIB directory.
 *  _________________________________________________________________________
 */

//
// ClassRef.h
//
#ifndef __ClassRef_h
#define __ClassRef_h

#define __math_h_NO_ARRAYS
#include "_math.h"
#undef __math_h_NO_ARRAYS
#include "errmsg.h"

typedef size_t size_type;


template <class V> 
class ClassRef {
 
public:

  static int num_refs_limit;

  ClassRef() {own=DataNotOwned; ref=0; ref_ptrs=0; ptrlen=0; const_ref=FALSE;}
  virtual ~ClassRef() {if (ref_ptrs) delete [] ref_ptrs;}

  void update_refs()
        {
        if (const_ref == TRUE)
           ErrAbort("Setting data for an ClassRef object with constant data references.");
        for (int i=0; i<ref; i++)
          copy_data(ref_ptrs[i]);
        }
  void acquire(V* array);
  bool release(V* array);
  void resize_ref_ptrs(const int);
  virtual void copy_data(V* array) = 0;
  virtual void reset_data(V* array) = 0;
  virtual void delete_data() = 0;

  EnumDataOwned own;
  int ref;

  void freeze()
        { const_ref=TRUE; }
  int const_ref;

protected:

  int ptrlen;
  V** ref_ptrs;
};


template <class V>
int ClassRef<V>::num_refs_limit=32;



template <class V>
void ClassRef<V>::acquire(V* array)
{
if (const_ref == FALSE) {
   //
   // Ignore num_refs_limit if this is a constant reference
   //
   if (ref == num_refs_limit)
      ErrAbort(errmsg("Exceeded maximum number of reference counts allowed in ClassRef<V>::num_refs_limit = %d",num_refs_limit));

   if (ref == ptrlen)
      resize_ref_ptrs(ptrlen*2+2);
   ref_ptrs[ref++] = array;
   }
copy_data(array);
}



template <class V>
bool ClassRef<V>::release(V* array)
{
if (const_ref == FALSE) {
   V** tmp = ref_ptrs;
   int i=0;
   for (i=0; i<(ref-1); i++, tmp++)
     if (*tmp == array)  break;
   if (i < (ref-1))
      ref_ptrs[i] = ref_ptrs[--ref];
   else
      ref--;
   if ((ptrlen > 2) && (ref < ptrlen/2))
      resize_ref_ptrs(ref);
   }
else
   ref--;

if (ref == 0) {
   delete_data();
   own = DataNotOwned;
   const_ref=FALSE;
   delete [] ref_ptrs;
   ref_ptrs = 0;
   }

reset_data(array);
return (ref == 0);
}



template <class V>
void ClassRef<V>::resize_ref_ptrs(const int newlen)
{
V** tmp = new V* [newlen];
if (ref) {
   for (int i=0; i<min(ref,newlen); i++)
     tmp[i] = ref_ptrs[i];
   delete [] ref_ptrs;
   }
ptrlen = newlen;
ref_ptrs=tmp;
}



template <class T, class V> 
class ArrayRef : public ClassRef<V> {
 
public:

  ArrayRef() {Len=0; Data=0;}
  virtual ~ArrayRef() {if (own) delete [] Data;}

  void copy_data(V* array);
  void reset_data(V* array);
  void delete_data()
        { if (own) delete [] Data; Data=0; }

  void set_data(T* Data_, size_type Len_, EnumDataOwned own_);

  T* Data;
  size_type Len;

};


template <class T, class V>
void ArrayRef<T,V>::copy_data(V* array)
{
array->Data = Data;
array->Len  = Len;
}


template <class T, class V>
void ArrayRef<T,V>::reset_data(V* array)
{
array->Data = 0;
array->Len  = 0;
}


template <class T, class V>
void ArrayRef<T,V>::set_data(T* Data_, size_type Len_, EnumDataOwned own_)
{
if (const_ref == TRUE)
   ErrAbort("Setting data for an ArrayRef object with constant data references.");

if (Data && own && (Len > 0))
   delete [] Data;
if (Len_ > 0) {
   Data = Data_;
   own = own_;
   Len = Len_;
   }
else {
   Data=0;
   Len=0;
   own=DataNotOwned;
   }
update_refs();
}

#endif