/*
 * @(#) memptr.h - Memory object pointer template class library header.
 * (c) 1998 Ivan Maidanski <ivmai@chat.ru> http://ivmai.chat.ru
 * Freeware class library source. All rights reserved.
 **
 * Language: ISO/ANSI C++
 * Tested with: Microsoft Visual C++ (R) v4.2, Watcom C++ 16/32 v11.0
 * Last modified: 1998-08-25 13:55:00 GMT+04:00
 */

// No library source file

// class TPointer<TObject>;
// MEMPTR_REFCNT_TYPE

#ifndef _MEMPTR_H_INCLUDED
#define _MEMPTR_H_INCLUDED

#ifndef __cplusplus
#error This file is for use with C++
#endif

// common macros declaration section (may be overriden)

#ifndef MEMPTR_REFCNT_TYPE // type of same object references counter
#define MEMPTR_REFCNT_TYPE unsigned
#endif

// special compiler directives

#ifdef _MSC_VER
#pragma warning(disable: 4284) // "bad return type for operator->()"
#pragma warning(disable: 4514) // "unreferenced inline function removed"
#endif

// declaration section

template <class TObject>
class TPointer // memory object typed "smart" (with reference count) pointer
{
 public: // constructors, destructor & copiers
  TPointer();
  TPointer(const TObject &);
  TPointer(const TPointer<TObject> &);
  ~TPointer();
  TPointer<TObject> &operator=(const TObject &);
  TPointer<TObject> &operator=(const TPointer<TObject> &);
 public: // object (data) access
  operator const TObject *() const;
  operator TObject *() const;
  TObject *operator->() const;
  TObject &operator*() const;
 public: // reference count manipulators
  void Delete();
  MEMPTR_REFCNT_TYPE RefCount() const;
 public: // comparison
  int operator!() const;
  int operator==(const TPointer<TObject> &) const;
  int operator!=(const TPointer<TObject> &) const;
 public: // exceptions
  class TError {};
  class TOutOfMemoryError : public TError {};
  class TAccessNullRefError : public TError {};
  class TNoAvailRefError : public TError {};
 protected: // own class declaration
  class TContainer
  {
   public:
    TContainer(const TObject &Object) : Data(Object), RefCnt(1) {}
   public:
    TObject Data;
    MEMPTR_REFCNT_TYPE RefCnt;
  };
 private: // internal data fields
  TContainer *PContainer;
};

// template inline methods implementaion section

template <class TObject>
inline TPointer<TObject>::TPointer() :
 PContainer(0)
{
}

template <class TObject>
inline TPointer<TObject>::~TPointer()
{
 Delete();
}

template <class TObject>
inline TPointer<TObject>::operator const TObject *() const
{
 return PContainer? &PContainer->Data : 0;
}

template <class TObject>
inline TPointer<TObject>::operator TObject *() const
{
 return PContainer? &PContainer->Data : 0;
}

template <class TObject>
inline TObject *TPointer<TObject>::operator->() const
{
 return PContainer? &PContainer->Data : 0;
}

template <class TObject>
inline TObject &TPointer<TObject>::operator*() const
{
 if (!PContainer)
  throw TAccessNullRefError();
 return PContainer->Data;
}

template <class TObject>
inline MEMPTR_REFCNT_TYPE TPointer<TObject>::RefCount() const
{
 return PContainer? PContainer->RefCnt : 0;
}

template <class TObject>
inline int TPointer<TObject>::operator!() const
{
 return !PContainer;
}

template <class TObject>
inline int TPointer<TObject>::operator==
            (const TPointer<TObject> &Pointer) const
{
 return PContainer==Pointer.PContainer;
}

template <class TObject>
inline int TPointer<TObject>::operator!=
            (const TPointer<TObject> &Pointer) const
{
 return PContainer!=Pointer.PContainer;
}

// template "out-of-line" methods implementaion section

template <class TObject>
TPointer<TObject>::TPointer(const TObject &Object) :
 PContainer(0)
{
 PContainer=new TContainer(Object);
 if (!PContainer)
  throw TOutOfMemoryError();
}

template <class TObject>
TPointer<TObject>::TPointer(const TPointer<TObject> &Pointer) :
 PContainer(Pointer.PContainer)
{
 if (PContainer && ++PContainer->RefCnt<=0)
 {
  --PContainer->RefCnt;
  PContainer=0;
  throw TNoAvailRefError();
 }
}

template <class TObject>
TPointer<TObject> &TPointer<TObject>::operator=(const TObject &Object)
{
 TContainer *PNewContainer=new TContainer(Object);
 if (!PNewContainer)
  throw TOutOfMemoryError();
 TContainer *POldContainer=PContainer;
 PContainer=PNewContainer;
 if (POldContainer && !--POldContainer->RefCnt)
  delete POldContainer;
 return *this;
}

template <class TObject>
TPointer<TObject> &TPointer<TObject>::operator=
                    (const TPointer<TObject> &Pointer)
{
 if (PContainer!=Pointer.PContainer)
 {
  if (Pointer.PContainer && ++Pointer.PContainer->RefCnt<=0)
  {
   --Pointer.PContainer->RefCnt;
   throw TNoAvailRefError();
  }
  TContainer *POldContainer=PContainer;
  PContainer=Pointer.PContainer;
  if (POldContainer && !--POldContainer->RefCnt)
   delete POldContainer;
 }
 return *this;
}

template <class TObject>
void TPointer<TObject>::Delete()
{
 TContainer *POldContainer=PContainer;
 PContainer=0;
 if (POldContainer && !--POldContainer->RefCnt)
  delete POldContainer;
}

#endif