---

refcontainer.h

Go to the documentation of this file.

#include "refclass.h"
template <class TRefType,class Arg> class KillableTStar: public TRefType {
  bool killed;
public:
  bool Killed()const {return killed;}
  void Kill() {killed=true;}
  KillableTStar(const Arg & a): TRefType(a){killed=false;}
};

template <class T, class Arg, class TStar = TRef<T,Arg> > class RefContainer: public RefClass<T,Arg,KillableTStar<TStar, Arg> > {
protected:
#define SuperType RefClass<T,Arg,KillableTStar<TStar,Arg> >
#define ThisType RefContainer<T,Arg,TStar>
  void DestroyObject() {
    SuperType::DestroyObject();
    SuperType::SetNull();
  }
public:
  RefContainer (): SuperType (NOTATHANG,NOTATHANG){}
  RefContainer (const Arg & a) : SuperType (a) {}
  RefContainer (const ThisType & a): SuperType (a) {}
  RefContainer<T,Arg,TStar> & operator = (const SuperType & r) {
    SuperType ::operator = (r);
    return *this;
  }
  void Kill() {
    if (! SuperType ::IsNull()){
      (*t).second.killed=true;
      DestroyObject();
    }
  }
  void SetNull(){
    if (! SuperType ::IsNull()) {
      DestroyObject();
    }
  }
  bool nullCheck() {
    if ( SuperType ::IsNull())
      return true;
    else if ((*t).killed()) {
      DestroyObject();
      return true;
    }
    return false;    
  }
  bool IsNull()const  {
    if ( SuperType ::IsNull()) {
      return true;
    }else {
      return (*t).killed;
    }
  }
  const T * Get ()const {
    if (IsNull())
      return 0;
    return SuperType ::Get();
  }
  T * Get () {
    if (SuperType ::IsNull())
      return 0;
    else if ((*t).killed()) {
      DestroyObject();
      return 0;
    }
    return SuperType ::Get();
  }
  T * operator * () {return Get();}
  const T * operator * ()const {return Get();}
  //the arrow operators don't check...so it's fast to just use 'em all the time
  bool operator == (const ThisType & o)const {
    bool a= IsNull();bool b = o.IsNull();
    if (a||b)
      return a==b;
    return SuperType ::operator == (o);
  }
  bool operator != (const ThisType & o)const {
    return !((*this)==o);
  }
  bool operator < (const ThisType & o)const {
    bool a= IsNull();bool b = o.IsNull();
    if (a||b)
      return (!a)&&b;
    return SuperType ::operator < (o);
  }
#undef SuperType
#undef ThisType
};

---