wzsafepointer.hxx

Delaunay三角形的网格剖分程序

#ifndef WZSAFEPOINTER_HXX
#define WZSAFEPOINTER_HXX

#include "wz.hxx"

template<class T> class wzProxy;

// wzProxy<T> behaves like T*;
// requires for T a base class or implicit conversion to
// class wzProxyTarget;
// class wzAccessControl;
// class wzProxyBase;

class wzProxyBase{
protected:
friend class wzProxyTarget;
	wzProxyBase(void* p):P(p){;}
public:
	void* P;
};

template<class T> class wzProxy{
  T* P;
public:
  T* operator->() const			{return P;}
  operator T*() const			{return P;}
  T& operator*() const			{return *P;}
  wzBoolean operator==(const wzProxy<T>& p) const	{return P==p.P;}
  wzBoolean operator!=(const wzProxy<T>& p) const	{return P!=p.P;}
  //  void	extractAndProtect(void** adr)	{*adr=(void*)P; P=0;}
  //  void  insertAndUnprotect(void* adr);
  wzProxy<T>& operator=(const wzProxy<T>& p);
  wzProxy():P(0){;}
  wzProxy(T* p);
  wzProxy(wzProxyBase p):P((T*) p.P){;}
  wzProxy(const wzProxy<T>& x);
  ~wzProxy();
};

class wzProxyHangingError: public wzError{
public: wzProxyHangingError();
};

class wzProxyLockError: public wzError{
public: wzProxyLockError();
};

class wzAccessControl{
        wzInteger C;
public:
	void 		lock()     	{C = -1;}
	void 		unlock()   	{C = 0;}
	void 		access()   	{C++;}
        void 		release()	{C--;}
	wzBoolean	free()		const {return C==0;}
        wzBoolean       used()		const {return C!=0;}
        wzBoolean       accessed()	const {return C >0;}
        wzBoolean       locked()	const {return C <0;}
        wzBoolean       unlocked()	const {return C>=0;}
        wzAccessControl():C(0){;}
};

class wzProxyTarget{
  wzIndex C;
public:
  wzInteger     accessCount(){return C>>2;}
  //  void          lockPointerAccess()           {if(!(C&1)) C += 1;}
  //  void          unlockPointerAccess()   	{if(  C&1 ) C -= 1;}
  wzProxyTarget():C(0){;}
// protected to friend classes wzProxy<*>
  void		checkPointerAccess() const {if(C&1){return;}}//throw wzProxyLockError();}}
  wzBoolean     noPointerAccess()    const 	{return !(C>>1);}
  void          makePointerAccess()     	{C += 4;}
  void          releasePointerAccess()  	{C -= 4;}
  wzProxyBase operator&() const
  {if(C&1) 	{throw wzProxyLockError();}
   if(C==0)	((wzProxyTarget *)this)->C  = 6;
   else		((wzProxyTarget *)this)->C += 4;
   return wzProxyBase((void*)this);
  }
protected: // allows these operations for derived classes
  wzProxyTarget& operator=
  (const wzProxyTarget& x){return *this;}
  wzProxyTarget
  (const wzProxyTarget& x):C(0){;}
  ~wzProxyTarget()
  {if(C>>2)  {throw wzProxyHangingError();}}
};

template<class T> inline wzProxy<T>&
	wzProxy<T>::operator=(const wzProxy<T>& p)
{
 if(P){P->releasePointerAccess(); if(P->noPointerAccess()) delete P;}
 P=p.P; if(P){P->checkPointerAccess(); P->makePointerAccess();}
 return *this;
}


template<class T> inline wzProxy<T>::wzProxy(T* p)
:P(p)
{if(P){P->checkPointerAccess(); P->makePointerAccess();}}

template<class T> inline wzProxy<T>::wzProxy
        			(const wzProxy<T>& x)
:P(x.P)
{if(P){P->checkPointerAccess(); P->makePointerAccess();}}

template<class T> inline wzProxy<T>::~wzProxy()
{if(P){ P->releasePointerAccess(); if(P->noPointerAccess()) delete P;}}

/*
template<class T> inline void wzProxy<T>::insertAndUnprotect(void* adr)
{*this=0; P=adr;}
*/
#endif