---

refclass.h

Go to the documentation of this file.

#ifndef _REFCLASS_H_
#define _REFCLASS_H_
static int _refclass_global_int_yo;
#define REFASSERT(X) if (!(X)){_refclass_global_int_yo=*(int*)0;}else{;}
#ifdef _WIN32
#pragma warning (4:4786)
#endif

template <class T, class Arg> class TRef: public T {
public:
    mutable int refcount;
    TRef (const Arg & a):T(a){refcount=0;}
    T* operator -> () {return this;}
    const T* operator -> ()const {return this;}
    const T* operator *()const {return this;}
    T* operator *(){return this;}
    void Deallocate() {}
  
};

#define INSTANTIATE_REFCLASS(T,Arg,TStar) RefClass<T,Arg,TStar>::TMap RefClass <T,Arg,TStar>::hmap;RefClass<T,Arg,TStar>::TMap RefClass <T,Arg,TStar>::NiL;

#define INSTANTIATE_DEFAULT_REFCLASS(T,Arg) RefClass<T,Arg>::TMap RefClass <T,Arg>::hmap; RefClass<T,Arg>::TMap RefClass <T,Arg>::NiL;

#define INSTANTIATE_TSUB(T,Arg) T * (*TSub<T,Arg>::construct_T) (const Arg & a) = TSub<T,Arg>::construct_T= &TSub<T,Arg>::Default_T_Construct;

template <class T, class Arg> class TSub {
 public:
    T * t;
    mutable int refcount;
    static T* Default_T_Construct (const Arg &a) {return new T (a);}
    static T *(*construct_T)(const Arg &a);
    TSub (const Arg & a) {
        t = (*construct_T)(a);
        refcount=0;
    }
    void Deallocate() {
        if (t){
            delete t;
            t=0;
        }
    }
    T* operator -> () {return t;}
    const T* operator -> ()const {return t;}
    const T* operator *()const {return t;}
    T* operator *(){return t;}
    bool operator == (const TSub <T,Arg> & a) const{
        return t==*a;
    }
    bool operator <(const TSub <T,Arg> & a) const{
        return t<*a;
    }
};

template <class T, class Arg, class TStar = TRef<T,Arg> > class RefClass {
    typedef TStar Tstar;
  typedef std::map<Arg,TStar> TMap;
    void TConstruct (const Arg & a) {
        t = hmap.find (a);
        if (t==hmap.end()) {
            t=hmap.insert(TMap::value_type(a,TStar (a))).first;
        }
        IncRef();
    }
protected:
    typename TMap::iterator t;
    static TMap NiL;//always empty;

    static TMap hmap;
    void DestroyObject (){
        DecRef();
        if ((*t).second.refcount==0) {
            (*t).second.Deallocate();
            hmap.erase(t);
            setNull(); //we don't need to change the object this is pointing to unless no one refs it :-)
        }
    }
    void IncRef()const {(*t).second.refcount++;}
    void DecRef()const{
        (*t).second.refcount--; 
        REFASSERT((*t).second.refcount>=0);
    }
    enum SPECIALARG {NOTATHANG};
    RefClass (SPECIALARG dummy,SPECIALARG d){t=NiL.begin();}
    bool isNull() const{return t==NiL.begin();}
    void setNull() {t = NiL.begin();}
 public:
    Arg GetKey()const {return (*t).first;}
    int getRefCount() const {return (*t).second.refcount;}
    RefClass (const Arg& a) {
        TConstruct(a);
    }
    RefClass () {
        TConstruct (Arg());
    }
    RefClass (const RefClass<T,Arg,TStar> & r) {r.IncRef(); t = r.t;}
    RefClass<T,Arg,TStar> & operator = (const RefClass<T,Arg,TStar> & r) {r.IncRef();DestroyObject();t=r.t;return *this;}
    ~RefClass () {DestroyObject();}
    T  * Get () {REFASSERT (!isNull());return *((*t).second);}
    const T* Get () const {REFASSERT (!isNull());return *((*t).second);}
    T  * operator *() {return Get();}
    const T* operator * () const {return Get();}
    T  * operator -> () {return Get();}
    const T* operator -> () const {return Get();}
    bool operator < (const RefClass<T,Arg,TStar> & r) const {return (*t).second<(*r.t).second;}
    bool operator == (const RefClass<T,Arg,TStar> & r) const{return (*t).second==(*r.t).second;}
    void Debug () const{printf ("0x%x refcount %d content: %s\n",&((*t).second),(*t).second.refcount,(*t).second->print().c_str());}
};
#endif

---