uobject.hpp

/* ==================================================== ======== ======= *
*
*  uobject.hpp
*  Ubit Project
*  Part of the Ubit Toolkit: A Brick Construction Game Model for Creating GUIs
*  (C) 1999-2006 EricLecolinet / ENST Paris / http://www.enst.fr/~elc/ubit
*
* ***********************************************************************
* COPYRIGHT NOTICE : 
* THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY AND WITHOUT EVEN THE 
* IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 
* YOU CAN REDISTRIBUTE IT AND/OR MODIFY IT UNDER THE TERMS OF THE GNU 
* GENERAL PUBLIC LICENSE AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
* EITHER VERSION 2 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
* SEE FILES 'COPYRIGHT' AND 'COPYING' FOR MORE DETAILS.
* ***********************************************************************
* ==================================================== [(c)Elc] ======= *
* ==================================================== ======== ======= */

#ifndef _uobject_hpp_
#define _uobject_hpp_
//pragma ident  "@(#)uobject.hpp        ubit:05.05.00"
#include <ubit/udefs.hpp>
namespace ubit {

class UObject {
public:
  static const char* getVersion();

  const char* getTypeName() const;
  virtual const UStr& getClassName() const;
  virtual const UClass& getClass() const {return classid();}
  /* virtual function that returns the Ubit Class of this object (see details!).
    * this function MUST be redefined by ALL UObject subclassses. This can be done
    * by inserting one of the UCLASS, UELEMENT_CLASS or UATTRIBUTE_CLASS macros
    * in the class declaration (see examples in UObject subclasses)
    * @see: classid(), UClass.
    */
  
  static const UClass& classid();
  /* static function that returns the UClass of this class (see details!).
    * this function MUST be redefined by ALL UObject subclassses. This can be done
    * by inserting one of the UCLASS, UELEMENT_CLASS or UATTRIBUTE_CLASS macros
    * in the class declaration (see examples in UObject subclasses)    
    * @see: getClass(), UClass.
    */
  
  virtual UBrick* brickCast()  {return null;}
  virtual UProp*  propCast()   {return null;}
  virtual UData*  dataCast()   {return null;}
  virtual UStr*   strCast()    {return null;}
  virtual UCall*  callCast()   {return null;}
  virtual UGroup* groupCast()  {return null;}
  virtual UBox*   boxCast()    {return null;}
  virtual UWin*   winCast()    {return null;}
  virtual UMenu* menuCast()    {return null;}
  
  void addPtr() const {++ptrcount;}
  
  void removePtr() const;
  
  int getPtrCount() const {return ptrcount;}  

  virtual bool canPtrDelete() const;   // MUST be virtual!

  static void deferenceError(const void*);

  UObject() {ptrcount = 0;}  

  UObject(const UObject&) {ptrcount = 0;}  

  UObject& operator=(const UBrick&) {ptrcount = 0; return *this;} 

  virtual ~UObject() {ptrcount = -1;}
  //NB: prtrcount<0 means that the object has been destructed

private:
  friend class UBrick;
  mutable int ptrcount;      
};

/* ==================================================== [Elc] ======= */
/* ==================================================== ===== ======= */
/* uptr<> template : Ubit Smart Pointer.
*
* Smart Pointers make it possible to handle objects created in the heap
* in a safe way. An object pointed by a uptr<> :
*  - is NOT destroyed when its parents are destroyed (if this object can have parents)
*  - is AUTOMATICALLY destroyed when the last uptr to this object is removed
*  - CAN'T be destroyed by using the 'delete' primitive ('delete' is dangerous
 *    because other pointers may reference the deleted object; hence methods
 *    such as UGroup::remove() should be uesed instead of 'delete')
*
*  @see: UBrick.
*
* Example:
*  <pre><tt>
*    uptr<UStr> p1 = new UStr("111");
*    uptr<UStr> p2 = ustr("222");
*
*    *p1 = *p2;        // copies the *content* of p2 into p1 (but p1
*                      // (and p2 still point to different objects)
*
*    p1 = p2;          // p1 now points to the same object as p2
*                      // the object that was formerly pointed by p1 is deleted
*                      // as there is no other reference to it
*
*    p1->append("xyz") // the content of the object pointed by p1 is changed
*
*    cerr << *p1;      // writes the content of the object: 222xyz
*    cerr << &p1;      // writes the address of the object
*
*    p1 = null;        // p1 now points to null. the object that 
*                      // was pointed by p1 is deleted
* </tt></pre>
*/
template <class CC> class uptr {
public:
  uptr()         {obj = null;}
  uptr(CC& _obj) {obj = &_obj; obj->addPtr();}
  uptr(CC* _obj) {obj = _obj; if(obj) obj->addPtr();}
  
  uptr(const uptr<CC>& ref2) {obj = ref2.obj; if(obj) obj->addPtr();}
  
  ~uptr() {if (obj) obj->removePtr();}
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  uptr<CC>& operator=(CC& _obj) {
    if(obj) obj->removePtr(); obj = &_obj; if(obj) obj->addPtr(); return *this;
  }
  uptr<CC>& operator=(CC* _obj) {
    if(obj) obj->removePtr(); obj = _obj; if(obj) obj->addPtr(); return *this;
  }
  
  uptr<CC>& operator=(const uptr<CC>& p2) {
    if(obj) obj->removePtr(); obj = p2.obj; if(obj) obj->addPtr(); return *this;
  }
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  operator CC*() const {return obj;}
  
  CC* operator&() const {return obj;}
  
  CC& operator*() const {
    if (!obj) UObject::deferenceError(this);
    return *obj;
  }
  
  CC* operator->() const {
    if (!obj) UObject::deferenceError(this);
    return obj;
  }
  
private:
  CC* obj;
  CC& operator[](int);  // [] meaningless and forbidden.
};


}
#endif
/* ==================================================== [TheEnd] ======= */
/* ==================================================== [(c)Elc] ======= */

---