#ifndef _HGlobal_h_
#define _HGlobal_h_


class CHGlobal
{
 mutable CHGlobal* m_pNext;
 HGLOBAL m_hGlobal;

public:
 CHGlobal() 
 { 
  m_hGlobal   = NULL; 
  m_pNext  = NULL;
 }

 CHGlobal(HGLOBAL hGlobal)
 {
  m_hGlobal   = hGlobal; 
  m_pNext  = (hGlobal != NULL)? this : NULL;
 }

 CHGlobal(const CHGlobal& other)
 {
  m_hGlobal = other.m_hGlobal;
  if((m_pNext = other.m_pNext) != NULL)
   other.m_pNext = this;
 }

 ~CHGlobal()
 {
  CHGlobal* p = m_pNext;
  if(p != NULL)
  {
   if(this == p)
    ::GlobalFree(m_hGlobal);
   else
   {
    CHGlobal* pNext;
    while((pNext = p-m_pNext) != this)
     p = pNext;
    p-m_pNext = m_pNext;
   }
  }
 }

// A couple of the ISO C++ standardization committee members 
// have suggested constructor reuse 
// as a desirable future language feature. 

 void Free()
 {
  this-~CHGlobal();
  ::new(this) CHGlobal();
 }

 const CHGlobal& operator = (HGLOBAL hGlobal)
 {
  if(m_hGlobal != hGlobal)
  {
   this-~CHGlobal();
   ::new(this) CHGlobal(hGlobal);
  }
  return *this;
 }

 const CHGlobal& operator = (const CHGlobal& other)
 {
  if(m_hGlobal != other.m_hGlobal)
  {
   this-~CHGlobal();
   ::new(this) CHGlobal(other);
  }
  return *this;
 }

 operator HGLOBAL() const { return m_hGlobal; }

 HGLOBAL Release() 
 { 
  CHGlobal* p = m_pNext;
  if(p != NULL)
  {
   while(p != this)
   {
    CHGlobal* pNext = p-m_pNext;
    p-m_pNext = NULL;
    p = pNext;
   }
   m_pNext = NULL;
  }

  return m_hGlobal;
 }

 bool operator == (HGLOBAL other) const
 {
  return m_hGlobal == other;
 }
 bool operator != (HGLOBAL other) const
 {
  return m_hGlobal != other;
 }
};

#endif // _HGlobal_h_