Reference.h

Go to the documentation of this file.

// $Id: Reference.h 4508 2020-05-26 07:55:59Z linev $
 
/************************************************************
 * The Data Acquisition Backbone Core (DABC)                *
 ************************************************************
 * Copyright (C) 2009 -                                     *
 * GSI Helmholtzzentrum fuer Schwerionenforschung GmbH      *
 * Planckstr. 1, 64291 Darmstadt, Germany                   *
 * Contact:  http://dabc.gsi.de                             *
 ************************************************************
 * This software can be used under the GPL license          *
 * agreements as stated in LICENSE.txt file                 *
 * which is part of the distribution.                       *
 ************************************************************/
 
#ifndef DABC_Reference
#define DABC_Reference
 
#include <string>
 
namespace dabc {
 
   class Command;
   class ReferencesVector;
   class Object;
   class Mutex;
 
   class Reference {
 
      friend class Object;
      friend class Command;
 
      protected:
 
         Object*    fObj;       
 
         Mutex* ObjectMutex() const;
 
         void Assign(const Reference & src);
 
         bool AcquireRefWithoutMutex(Reference& ref);
 
         template<class T>
         bool verify_object(Object* src, T* &tgt) { return (tgt=dynamic_cast<T*>(src))!=0; }
 
      public:
 
         Reference(Object* obj = nullptr);
 
         Reference(const Reference& src) throw();
 
         virtual ~Reference();
 
         void SetAutoDestroy(bool on = true);
 
         void SetObject(Object* obj, bool withmutex = true);
 
         unsigned NumReferences() const;
 
         void Release() throw();
 
         Reference Take();
 
         void Destroy() throw();
 
         inline Object* GetObject() const { return fObj; }
 
         Object* GetParent() const;
 
         Reference GetParentRef() const { return dabc::Reference(GetParent()); }
 
         const char* GetName() const;
 
         const char* ClassName() const;
 
         bool IsName(const char* name) const;
 
         inline Object* operator()() const { return fObj; }
 
         inline bool null() const { return GetObject() == nullptr; }
 
         inline bool operator!() const { return null(); }
 
         bool AddChild(Object* obj);
 
         unsigned NumChilds() const;
 
         Reference GetChild(unsigned n) const;
 
         bool GetAllChildRef(ReferencesVector* vect) const;
 
         Reference FindChild(const char* name) const;
 
         bool RemoveChild(const char* name, bool cleanup = true);
 
         bool RemoveChilds(bool cleanup = true);
 
         Reference& operator=(const Reference& src) throw();
 
         Reference& operator=(Object* obj) throw();
 
         Reference& operator<<(Reference& src) throw();
 
         inline bool operator==(const Reference& src) const { return GetObject() == src(); }
 
         inline bool operator!=(const Reference& src) const { return GetObject() != src(); }
 
         inline bool operator==(Object* obj) const { return GetObject() == obj; }
 
         inline bool operator!=(Object* obj) const { return GetObject() != obj; }
 
         void Print(int lvl=0, const char* from = 0) const;
 
         Reference GetFolder(const std::string &name, bool force = false) throw();
 
         std::string ItemName(bool compact = true) const;
 
         std::string RelativeName(const dabc::Reference& topitem);
   };
}
 
 
#define DABC_REFERENCE(RefClass, ParentClass, T) \
      public: \
 \
         RefClass(T* obj = 0) throw() : ParentClass(obj) {} \
 \
         RefClass(const RefClass& src) throw() : ParentClass(src) {} \
 \
         RefClass(const Reference& src) throw() : ParentClass() \
            { T* res(0); if (verify_object(src(),res)) { Assign(src); } } \
 \
         inline T* GetObject() const { return (T*) ParentClass::GetObject(); } \
 \
         inline T* operator()() const { return (T*) ParentClass::GetObject(); } \
 \
         RefClass& operator=(const RefClass& src) throw() { ParentClass::operator=(src); return *this; } \
 \
         RefClass& operator=(const Reference& src) throw() \
         { \
            Release(); T* res(0); \
            if (verify_object(src(),res)) Assign(src);  \
            return *this; \
         } \
 \
         RefClass& operator=(dabc::Object* obj) throw() \
         { \
            Release(); T* res(0); \
            if (verify_object(obj,res)) { RefClass ref((T*)obj); *this << ref; } \
            return *this; \
         } \
 \
         RefClass& operator<<(Reference& src) throw() \
         { \
            T* res(0); \
            if (verify_object(src(),res)) dabc::Reference::operator<<(src); \
               else { Release(); src.Release(); } \
            return *this; \
         }
 
 
#endif