Object.cxx

Go to the documentation of this file.

// $Id: Object.cxx 4482 2020-04-15 14:47:18Z 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.                       *
 ************************************************************/
 
#include "dabc/Object.h"
 
#include <cstdlib>
#include <fnmatch.h>
 
#include "dabc/Manager.h"
#include "dabc/ReferencesVector.h"
 
unsigned dabc::Object::gNumInstances = 0;
unsigned dabc::Object::gNumCreated = 0;
 
namespace dabc {
 
 
   const char* xmlDeviceNode        = "Device";
   const char* xmlThreadNode        = "Thread";
   const char* xmlMemoryPoolNode    = "MemoryPool";
   const char* xmlModuleNode        = "Module";
   const char* xmlConnectionNode    = "Connection";
 
   const char* xmlQueueAttr         = "queue";
   const char* xmlBindAttr          = "bind";
   const char* xmlSignalAttr        = "signal";
   const char* xmlRateAttr          = "rate";
   const char* xmlLoopAttr          = "loop";
   const char* xmlInputQueueSize    = "InputQueueSize";
   const char* xmlOutputQueueSize   = "OutputQueueSize";
   const char* xmlInlineDataSize    = "InlineDataSize";
 
   const char* xmlPoolName          = "PoolName";
   const char* xmlWorkPool          = "Pool";
   const char* xmlFixedLayout       = "FixedLayout";
   const char* xmlCleanupTimeout    = "CleanupTimeout";
   const char* xmlBufferSize        = "BufferSize";
   const char* xmlNumBuffers        = "NumBuffers";
   const char* xmlAlignment         = "Alignment";
   const char* xmlShowInfo          = "ShowInfo";
 
   const char* xmlNumInputs         = "NumInputs";
   const char* xmlNumOutputs        = "NumOutputs";
   const char* xmlInputPrefix       = "Input";
   const char* xmlInputMask         = "Input%u";
   const char* xmlOutputPrefix      = "Output";
   const char* xmlOutputMask        = "Output%u";
   const char* xmlUseAcknowledge    = "UseAcknowledge";
   const char* xmlFlushTimeout      = "FlushTimeout";
   const char* xmlConnTimeout       = "ConnTimeout";
 
   const char* xmlMcastAddr         = "McastAddr";
   const char* xmlMcastPort         = "McastPort";
   const char* xmlMcastRecv         = "McastRecv";
 
   const char* xmlProtocol          = "Protocol";
   const char* xmlHostName          = "HostName";
   const char* xmlFileName          = "FileName";
   const char* xmlFileNumber        = "FileNumber";
   const char* xmlFileSizeLimit     = "FileSizeLimit";
   const char* xml_maxsize          = "maxsize";
   const char* xml_number           = "number";
   const char* xml_flush            = "flush";
 
   const char* typeThread           = "dabc::Thread";
   const char* typeDevice           = "dabc::Device";
   const char* typeSocketDevice     = "dabc::SocketDevice";
   const char* typeSocketThread     = "dabc::SocketThread";
   const char* typeApplication      = "dabc::Application";
 
 
#ifdef DABC_EXTRA_CHECKS
   PointersVector gObjectGarbageCollector;
   Mutex          gObjectGarbageMutex;
#endif
 
}
 
dabc::Object::Object(const std::string &name, unsigned flags) :
   fObjectFlags(flags),
   fObjectParent(),
   fObjectName(name),
   fObjectMutex(0),
   fObjectRefCnt(0),
   fObjectChilds(0),
   fObjectBlock(0)
{
   DOUT5("Created object %s %p", GetName(), this);
 
   Constructor();
}
 
dabc::Object::Object(Reference parent, const std::string &name, unsigned flags) :
   fObjectFlags(flags),
   fObjectParent(parent),
   fObjectName(name),
   fObjectMutex(0),
   fObjectRefCnt(0),
   fObjectChilds(0),
   fObjectBlock(0)
{
   DOUT5("Object created %s %p", GetName(), this);
 
   Constructor();
}
 
 
dabc::Object::Object(const ConstructorPair& pair, unsigned flags) :
   fObjectFlags(flags),
   fObjectParent(pair.parent),
   fObjectName(pair.name),
   fObjectMutex(0),
   fObjectRefCnt(0),
   fObjectChilds(0),
   fObjectBlock(0)
{
   DOUT5("Object created %s %p", GetName(), this);
 
   Constructor();
}
 
 
dabc::Object::~Object()
{
   Destructor();
 
   DOUT5("Object destroyed %s %p", GetName(), this);
}
 
void dabc::Object::SetOwner(bool on)
{
   LockGuard lock(fObjectMutex);
   SetFlag(flIsOwner, on);
}
 
void dabc::Object::SetAutoDestroy(bool on)
{
   LockGuard lock(fObjectMutex);
   SetFlag(flAutoDestroy, on);
}
 
 
bool dabc::Object::IsOwner() const
{
   LockGuard lock(fObjectMutex);
   return GetFlag(flIsOwner);
}
 
bool dabc::Object::IsLogging() const
{
   LockGuard lock(fObjectMutex);
   return GetFlag(flLogging);
}
 
bool dabc::Object::IsChildsHidden() const
{
   LockGuard lock(fObjectMutex);
   return GetFlag(flChildsHidden);
}
 
bool dabc::Object::IsTopXmlLevel() const
{
   LockGuard lock(fObjectMutex);
   return GetFlag(flTopXmlLevel);
}
 
bool dabc::Object::IsHidden() const
{
   LockGuard lock(fObjectMutex);
   return GetFlag(flHidden);
}
 
void dabc::Object::SetLogging(bool on)
{
   LockGuard lock(fObjectMutex);
   return SetFlag(flLogging, on);
}
 
bool dabc::Object::IsName(const char* str, int len) const
{
   if ((len==0) || (str==0)) return false;
   if (len<0) return fObjectName.compare(str) == 0;
   return ((int) fObjectName.length()==len) && (fObjectName.compare(0, len, str,len) == 0);
}
 
void dabc::Object::Constructor()
{
   gNumInstances++;
 
   // use non-recursive mutexes to see faster deadlock problems
   // FIXME: should we use recursive in final version?
 
   if (!GetFlag(flNoMutex))
      fObjectMutex = new Mutex(false);
 
   SetState(stNormal);
 
   fObjectParent.AddChild(this);
}
 
void dabc::Object::Destructor()
{
   #ifdef DABC_EXTRA_CHECKS
   {
      LockGuard lock(gObjectGarbageMutex);
      gObjectGarbageCollector.remove(this);
   }
   #endif
 
   Mutex* m = 0;
   bool delchilds = false;
 
   {
      LockGuard lock(fObjectMutex);
 
      if ((GetState() != stDestructor) && (fObjectRefCnt!=0)) {
         EOUT("Object %p %s deleted not via Destroy method refcounter %u", this, GetName(), fObjectRefCnt);
      }
 
      SetState(stDestructor);
 
      if (fObjectRefCnt!=0) {
         EOUT("!!!!!!!!!!!! Destructor called when refcounter %u obj:%s %p", fObjectRefCnt, GetName(), this);
//         Object* obj = (Object*) 29387898;
//         delete obj;
      }
 
      if (fObjectChilds!=0) {
 
         if (fObjectChilds->GetSize() > 0)
            EOUT("!!!!!!! CHILDS %u ARE NOT DELETED completely obj:%s %p", fObjectChilds->GetSize(), GetName(), this);
 
         if (fObjectBlock > 0)
            EOUT("!!!! CHILDS ARE STILL BLOCKED %d!!!!!!!", fObjectBlock);
 
         delchilds = true;
      }
 
      m = fObjectMutex;
      fObjectMutex = 0;
   }
 
   if (delchilds) RemoveChilds();
 
   // release reference on parent, remove from child should be already done
   fObjectParent.Release();
 
   // destroy mutex
   delete m; m=0;
 
   gNumInstances--;
}
 
bool dabc::Object::IncReference(bool withmutex)
{
   dabc::LockGuard lock(withmutex ? fObjectMutex : 0);
 
   if (GetState() == stDestructor) {
      EOUT("OBJ:%p %s Inc reference during destructor", this, GetName());
      return false;
//         EOUT("Obj:%p %s Class:%s IncReference %u inside destructor :(",
//               this, GetName(), ClassName(), fObjectRefCnt);
   }
 
   fObjectRefCnt++;
 
   if (GetFlag(flLogging))
      DOUT0("Obj:%s %p Class:%s IncReference +----- %u thrd:%s", GetName(), this, ClassName(), fObjectRefCnt, dabc::mgr.CurrentThread().GetName());
 
   return true;
}
 
void dabc::Object::SetCleanupBit()
{
   dabc::LockGuard lock(fObjectMutex);
   SetFlag(flCleanup, true);
}
 
bool dabc::Object::_IsNormalState()
{
   return GetState() == stNormal;
}
 
 
bool dabc::Object::IsNormalState()
{
   dabc::LockGuard lock(fObjectMutex);
 
   return _IsNormalState();
}
 
 
bool dabc::Object::DecReference(bool ask_to_destroy, bool do_decrement, bool from_thread)
{
   // check destroyment before we lock the mutex
   // if method returns true, object destructor should follow
 
   bool viathrd = false;
 
   {
      dabc::LockGuard lock(fObjectMutex);
 
//      if (GetFlag(flLogging)) {
//           DOUT0("Call DecReference for object %p %s refcnt = %d, ask_to_destroy %s do_decrement %s state %d from_thread %s", this, GetName(), fObjectRefCnt, DBOOL(ask_to_destroy), DBOOL(do_decrement), GetState(), DBOOL(from_thread));
//      }
 
//      if (GetFlag(flLogging))
//         DOUT0("Obj:%s %p  Class:%s DecReference %u destroy %s dodec %s state %d numchilds %u flags %x",
//               GetName(), this, ClassName(),
//               fObjectRefCnt, DBOOL(ask_to_destroy), DBOOL(do_decrement), GetState(),
//               (fObjectChilds ? fObjectChilds->GetSize() : 0), fObjectFlags);
 
      if (do_decrement) {
 
         if (fObjectRefCnt==0) {
            EOUT("Obj %p name:%s class:%s Reference counter is already 0", this, GetName(), ClassName());
            throw dabc::Exception(ex_Object, "Reference counter is 0 - cannot decrease", GetName());
            return false;
         }
 
         // if (IsLogging()) DOUT0("Dec object refcounter in 389");
         fObjectRefCnt--;
 
         if (GetFlag(flLogging))
            DOUT0("Obj:%s %p Class:%s DecReference ----+- %u thrd:%s", GetName(), this, ClassName(), fObjectRefCnt, dabc::mgr.CurrentThread().GetName());
      }
 
      switch (GetState()) {
         case stConstructor:
            EOUT("Object %s is not yet constructed - most probably, big failure", GetName());
            return false;
 
         case stNormal:
            // if autodestroy flag specified, object will be destroyed when no more external references are existing
 
            // if (GetFlag(flAutoDestroy) && (fObjectRefCnt <= (int)(fObjectChilds ? fObjectChilds->GetSize() : 0))) ask_to_destroy = true;
            if (GetFlag(flAutoDestroy) && (fObjectRefCnt == 0)) ask_to_destroy = true;
 
            if (do_decrement && (fObjectChilds!=0) && ((unsigned) fObjectRefCnt == fObjectChilds->GetSize()) && GetFlag(flAutoDestroy)) {
               ask_to_destroy = true;
               // DOUT0("One could destroy object %s %p anyhow numrefs %u numchilds %u", GetName(), this, fObjectRefCnt, fObjectChilds->GetSize());
            }
 
            if (!ask_to_destroy) return false;
            viathrd = GetFlag(flHasThread);
            break;
 
         // we are waiting for the thread, only thread call can unblock
         case stWaitForThread:
            if (!from_thread) {
               DOUT2("Object %p %s tried to destroy not from thread - IGNORE", this, GetName());
               return false;
            }
            break;
 
         // recursive call, ignore it
         case stDoingDestroy:
            return false;
 
         // if object already so far, it can be destroyed when no references remained
         case stWaitForDestructor:
            if (fObjectRefCnt == 0) {
               if (_DoDeleteItself()) return false;
 
               // once return true, never do it again
               // returning true means that destructor will be immediately call
               SetState(stDestructor);
 
               return true;
            }
 
            #ifdef DABC_EXTRA_CHECKS
            {
              LockGuard lock(gObjectGarbageMutex);
              if (!gObjectGarbageCollector.has_ptr(this))
                 gObjectGarbageCollector.push_back(this);
            }
            #endif
            return false;
 
         // in principal error, we are inside destructor
         case stDestructor:
            return false;
      }
 
      if (viathrd) {
         SetState(stWaitForThread);
         // we delegate reference counter to the thread
         fObjectRefCnt++;
         if (GetFlag(flLogging))
            DOUT0("Obj:%s %p Class:%s IncReference --+--- %u", GetName(), this, ClassName(), fObjectRefCnt);
      } else {
         SetState(stDoingDestroy);
      }
   }
 
   if (viathrd) {
      if (DestroyByOwnThread()) return false;
 
      // it means thread do not want to destroy us, let do it normal way
      dabc::LockGuard lock(fObjectMutex);
      SetState(stDoingDestroy);
      // thread reject destroyment, therefore refcounter can be decreased
      // if (IsLogging()) DOUT0("Dec object refcounter in 459");
      fObjectRefCnt--;
 
      if (GetFlag(flLogging))
         DOUT0("Obj:%s %p Class:%s DecReference -----+ %u", GetName(), this, ClassName(), fObjectRefCnt);
   }
 
 
   if (IsLogging()) DOUT0("Calling object %p cleanup from_thrd=%s do_decrement=%s", this, DBOOL(from_thread), DBOOL(do_decrement));
 
   // Main point of all destroyment - call cleanup in correct place
   ObjectCleanup();
 
//   if (IsLogging()) DOUT0("Did object cleanup");
 
   if (IsLogging())
      DOUT0("DecRefe after cleanup %p cleanup %s mgr %p", this, DBOOL(GetFlag(flCleanup)), dabc::mgr());
 
   {
 
      LockGuard guard(fObjectMutex);
 
      if (GetFlag(flCleanup) && dabc::mgr()) {
         // cleanup will be done by manager via reference
         fObjectRefCnt++;
         SetState(stWaitForDestructor);
         if (GetFlag(flLogging))
            DOUT0("Obj:%s %p Class:%s IncReference ---+-- %u", GetName(), this, ClassName(), fObjectRefCnt);
      } else
      if (fObjectRefCnt==0) {
         // no need to deal with manager - can call destructor immediately
         DOUT3("Obj:%p can be destroyed", this);
         if (_DoDeleteItself()) {
            SetState(stWaitForDestructor);
            return false;
         }
         SetState(stDestructor);
         return true;
      } else {
         SetState(stWaitForDestructor);
         #ifdef DABC_EXTRA_CHECKS
         {
            LockGuard lock(gObjectGarbageMutex);
            if (!gObjectGarbageCollector.has_ptr(this))
               gObjectGarbageCollector.push_back(this);
         }
         #endif
         return false;
      }
   }
 
   // special case - we already increment reference counter
   Reference ref;
   ref.fObj = this;
   if (dabc::mgr()->DestroyObject(ref)) return false;
 
   // here reference will be released if manager does not accept destroyment
 
   LockGuard guard(fObjectMutex);
 
   if (fObjectRefCnt==0) {
      // no need to deal with manager - can call destructor immediately
      if (_DoDeleteItself()) {
         SetState(stWaitForDestructor);
         return false;
      }
 
      DOUT3("Obj:%p can be destroyed", this);
      SetState(stDestructor);
      return true;
   }
 
   return false;
}
 
bool dabc::Object::DestroyCalledFromOwnThread()
{
   return DecReference(true, true, true);
}
 
void dabc::Object::DeleteThis()
{
   if (IsLogging())
      DOUT1("OBJ:%p %s DELETETHIS cnt %u", this, GetName(), fObjectRefCnt);
 
   {
      LockGuard lock(fObjectMutex);
 
      if (GetState()!=stNormal) {
//         EOUT("Object %p already on the way to destroyment - do not harm it", this);
         return;
      }
 
      // this flag force object to be cleanup via manager
      SetFlag(flCleanup, true);
   }
 
   Destroy(this);
}
 
 
 
 
void dabc::Object::ObjectCleanup()
{
   RemoveChilds();
 
   if (IsLogging()) {
      DOUT0("Obj:%p %s refcnt %u Before remove from parent %p", this, GetName(), fObjectRefCnt, fObjectParent());
   }
 
   // Than we remove reference on the object from parent
   if (!fObjectParent.null())
      fObjectParent()->RemoveChild(this, false);
 
   if (!fObjectParent.null()) {
      EOUT("Parent still not yet cleaned !!!!");
      fObjectParent.Release();
   }
 
   if (IsLogging()) {
      DOUT0("Obj:%p %s refcnt %u after remove from parent", this, GetName(), fObjectRefCnt);
   }
 
   DOUT3("Obj:%s Class:%s Finish cleanup numrefs %u", GetName(), ClassName(), NumReferences());
 
}
 
unsigned dabc::Object::NumReferences()
{
   dabc::LockGuard lock(fObjectMutex);
 
   return fObjectRefCnt;
}
 
 
bool dabc::Object::AddChild(Object* child, bool withmutex) throw()
{
   return AddChildAt(child, (unsigned) -1, withmutex);
}
 
bool dabc::Object::AddChildAt(Object* child, unsigned pos, bool withmutex)
{
   if (child==0) return false;
 
   if (!child->fObjectParent.null() && (child->GetParent() != this)) {
      EOUT("Cannot add child from other parent directly - first remove from old");
      throw dabc::Exception(ex_Object, "Cannot add child from other parent", GetName());
      return false;
   }
 
   Reference ref(child);
 
   LockGuard guard(withmutex ? fObjectMutex : 0);
 
   if (child->fObjectParent.null()) {
      child->fObjectParent.fObj = this; // not very nice, but will work
      fObjectRefCnt++;
   }
 
   // if object is owner of all childs, any child will get autodestroy flag
   if (GetFlag(flIsOwner)) child->SetAutoDestroy(true);
 
   if (fObjectChilds==0) fObjectChilds = new ReferencesVector;
 
   if (pos == (unsigned) -1)
      fObjectChilds->Add(ref);
   else
      fObjectChilds->AddAt(ref, pos);
 
   _ChildsChanged();
 
   return true;
}
 
bool dabc::Object::RemoveChild(Object* child, bool cleanup) throw()
{
   if (child==0) return false;
 
   if (child->fObjectParent() != this) return false;
 
   int cnt = 1000000;
 
   bool isowner = false;
 
   dabc::Reference childref;
 
   while (--cnt>0) {
      LockGuard guard(fObjectMutex);
 
      if (fObjectChilds==0) return false;
 
      if (fObjectBlock>0) continue;
 
      isowner = GetFlag(flIsOwner);
 
      if (fObjectChilds->ExtractRef(child, childref)) {
         // IMPORTANT: parent reference can be released only AFTER childs are decreased,
         // otherwise reference will try to destroy parent
         // IMPORTANT: we are under object mutex and can do anything
 
         _ChildsChanged();
 
         if (child->fObjectParent.fObj==this) {
            child->fObjectParent.fObj = 0; // not very nice, but will work
            if (fObjectRefCnt>1) {
               fObjectRefCnt--;
            } else {
               fObjectRefCnt = 0;
               if (fObjectChilds->GetSize() > 0)
                  DOUT0("Object %p %s refcnt==0 when numchild %u", this, GetName(), fObjectChilds->GetSize());
            }
         }
         break;
      }
 
      EOUT("Not able to extract child reference!!!");
      exit(333);
   }
 
   if (cleanup && isowner) childref.Destroy();
                      else childref.Release();
 
   #ifdef DABC_EXTRA_CHECKS
   if (cnt < 999990)
      DOUT0("Object %s Retry %d time before childs were unblocked", GetName(), 1000000-cnt);
   #endif
 
   if (cnt==0) {
      EOUT("HARD error!!!! - For a long time fObjectBlock=%d is blocked in object %p %s", fObjectBlock, this, GetName());
      exit(055);
   }
 
   return true;
}
 
bool dabc::Object::RemoveChildAt(unsigned n, bool cleanup) throw()
{
   return RemoveChild(GetChild(n), cleanup);
}
 
unsigned dabc::Object::NumChilds() const
{
   LockGuard guard(fObjectMutex);
 
   return fObjectChilds ? fObjectChilds->GetSize() : 0;
}
 
dabc::Object* dabc::Object::GetChild(unsigned n) const
{
   LockGuard guard(fObjectMutex);
 
   return fObjectChilds==0 ? 0 : fObjectChilds->GetObject(n);
}
 
dabc::Reference dabc::Object::GetChildRef(unsigned n) const
{
   LockGuard guard(fObjectMutex);
 
   Object* obj = (fObjectChilds==0) ? 0 : fObjectChilds->GetObject(n);
 
   if (obj==0) return Reference();
 
   IntGuard block(fObjectBlock);
 
   UnlockGuard unlock(fObjectMutex);
 
   return dabc::Reference(obj);
 
   // here will be mutex locked, fObjectBlock counter decremented and finally mutex unlocked again
}
 
bool dabc::Object::GetAllChildRef(ReferencesVector* vect) const
{
   if (vect==0) return false;
 
   LockGuard guard(fObjectMutex);
 
   if (fObjectChilds==0) return true;
 
   PointersVector ptrs;
 
   for (unsigned n=0; n<fObjectChilds->GetSize(); n++)
      ptrs.push_back(fObjectChilds->GetObject(n));
 
   IntGuard block(fObjectBlock);
 
   UnlockGuard unlock(fObjectMutex);
 
   for (unsigned n=0;n<ptrs.size();n++) {
      Reference ref((Object*)ptrs[n]);
      vect->Add(ref);
   }
 
   return true;
 
   // here will be mutex locked, fObjectBlock counter decremented and finally mutex unlocked again
 
}
 
 
dabc::Object* dabc::Object::FindChild(const char* name) const
{
   return FindChildRef(name, false)();
}
 
dabc::Reference dabc::Object::FindChildRef(const char* name, bool force) const throw()
{
   Reference ref(const_cast<Object*> (this));
 
   return SearchForChild(ref, name, true, force);
}
 
dabc::Reference dabc::Object::SearchForChild(Reference& ref, const char* name, bool firsttime, bool force) throw()
{
   if (ref.null()) return ref;
 
   if ((name==0) || (strlen(name)==0)) return ref;
 
   if (*name=='/') {
      if (firsttime) {
         while (ref()->GetParent()!=0)
            ref = Reference(ref()->GetParent());
         return SearchForChild(ref, name+1, false, force);
      } else {
         // skip all slashes in the beginning
         while (*name=='/') name++;
         if (*name==0) return ref;
      }
   }
 
   int len = strlen(name);
 
   if ((len>=2) && (name[0]=='.') && (name[1] == '.')) {
      if (len==2) return Reference(ref()->GetParent());
 
      if (name[2]=='/') {
         ref = Reference(ref()->GetParent());
         return SearchForChild(ref, name + 3, false, force);
      }
   }
 
   if ((len>=1) && (name[0]=='.')) {
      if (len==1) return ref;
      if (name[1]=='/')
         return SearchForChild(ref, name + 2, false, force);
   }
 
   const char* ptok = name;
   while (*ptok!=0) {
      if (*ptok == '/') break;
      ptok++;
   }
 
   Reference newref;
 
   {
      LockGuard guard(ref()->fObjectMutex);
 
      dabc::Object *obj = (ref()->fObjectChilds==nullptr) ? nullptr : ref()->fObjectChilds->FindObject(name, ptok-name);
 
      // create new object under parent mutex - no one can create double entries simultaneously
      if ((obj==0) && force) {
         obj = ref()->CreateInstance(std::string(name, ptok-name));
         ref()->AddChild(obj, false);
      }
 
      if (obj!=0) {
         IntGuard block(ref()->fObjectBlock);
 
         UnlockGuard unlock(ref()->fObjectMutex);
 
         // make reference outside parent mutex
         newref = dabc::Reference(obj);
      }
   }
 
   ref << newref;
 
   if (*ptok==0) return ref;
 
   return SearchForChild(ref, ptok+1, false, force);
}
 
 
dabc::Reference dabc::Object::GetFolder(const std::string &name, bool force) throw()
{
   Reference ref(this);
 
   return SearchForChild(ref, name.c_str(), true, force);
}
 
bool dabc::Object::RemoveChilds(bool cleanup)
{
   ReferencesVector* del_vect = 0;
 
   int cnt = 1000000;
 
   bool isowner = false;
 
   while (--cnt>0) {
      LockGuard guard(fObjectMutex);
 
      // nothing to do
      if (fObjectChilds==0) return true;
 
      if (fObjectBlock>0) continue;
 
      isowner = GetFlag(flIsOwner);
      del_vect = fObjectChilds;
      fObjectChilds = 0;
      break;
   }
 
   #ifdef DABC_EXTRA_CHECKS
   if (cnt < 999990)
      DOUT0("Object %s Retry %d times before childs were unblocked", 1000000-cnt);
   #endif
 
   if (cnt==0) {
      EOUT("HARD error!!!! - For a long time fObjectBlock=%d is blocked in object %p %s", fObjectBlock, this, GetName());
      exit(055);
   }
 
   if (IsLogging())
      DOUT1("Obj:%s Deleting childs:%u", GetName(), del_vect ? del_vect->GetSize() : 0);
 
   if (del_vect) {
 
      // ensure that object do not longer reference parent
      for (unsigned n=0;n<del_vect->GetSize();n++) {
         Object* obj = del_vect->GetObject(n);
         if (obj) obj->fObjectParent.Release();
      }
 
      del_vect->Clear(isowner && cleanup);
      delete del_vect;
   }
 
   return true;
}
 
void dabc::Object::SetName(const char *name)
{
   LockGuard guard(fObjectMutex);
 
   if (fObjectRefCnt>0) {
      EOUT("Cannot change object name when reference counter %d is not zero!!!", fObjectRefCnt);
      throw dabc::Exception(ex_Object, "Cannot change object name when refcounter is not zero", GetName());
   }
 
   fObjectName = name;
}
 
 
void dabc::Object::SetNameDirect(const char* name)
{
   LockGuard guard(fObjectMutex);
 
   fObjectName = name;
}
 
 
void dabc::Object::Destroy(Object* obj) throw()
{
   if (obj==0) return;
 
   if (obj->DecReference(true, false))
      delete obj;
}
 
bool dabc::Object::Find(ConfigIO &cfg)
{
   return GetParent()==0 ? false : cfg.FindItem(GetName());
}
 
dabc::Object::ConstructorPair dabc::Object::MakePair(Reference prnt, const std::string &fullnamearg, bool withmanager)
{
   if (fullnamearg.empty() && prnt.null())
      return ConstructorPair();
 
   const char* fullname = fullnamearg.empty() ? "---" : fullnamearg.c_str();
   bool isrootfolder(false), isskipparent(false);
   while (*fullname=='/') {
      isrootfolder = true;
      fullname++;
   }
 
   if (!isrootfolder && (*fullname=='#')) {
      fullname++;
      isskipparent = true;
   }
 
   if (prnt.null() && withmanager && !isskipparent) {
      if (prnt.null()) prnt = dabc::mgr;
   }
 
   const char* slash = strrchr(fullname, '/');
 
   ConstructorPair pair;
 
   if (slash!=0) {
      pair.name = slash+1;
      std::string path = std::string(fullname, slash - fullname);
      if (!prnt.null())
         prnt = prnt()->FindChildRef(path.c_str(), true);
   } else {
      pair.name = fullname;
   }
 
   if (!isskipparent)
      pair.parent = prnt;
 
   return pair;
}
 
dabc::Object::ConstructorPair dabc::Object::MakePair(Object* prnt, const std::string &fullname, bool withmanager)
{
   return dabc::Object::MakePair(Reference(prnt), fullname, withmanager);
}
 
dabc::Object::ConstructorPair dabc::Object::MakePair(const std::string &fullname, bool withmanager)
{
   return dabc::Object::MakePair(Reference(), fullname, withmanager);
}
 
 
bool dabc::Object::IsParent(Object* obj) const
{
   if (obj==0) return false;
 
   Object* prnt = GetParent();
 
   while (prnt!=0) {
      if (prnt==obj) return true;
      prnt = prnt->GetParent();
   }
   return false;
}
 
 
bool dabc::Object::IsNameMatch(const std::string &mask) const
{
   return NameMatch(fObjectName, mask);
}
 
bool dabc::Object::NameMatch(const std::string &name, const std::string &mask)
{
   if ((mask.length()==0) || (name.length()==0))
      return name.length()==mask.length();
 
   size_t lastsepar(0), separ = mask.find_first_of(';',lastsepar);
 
   if (separ!=std::string::npos) {
      do {
        // FIXME!!!! code missing
 
 
 
      } while (lastsepar!=std::string::npos);
   }
 
 
   if (mask.find_first_of("*?") == std::string::npos) return name == mask;
 
   if (mask == "*") return true;
 
   return fnmatch(mask.c_str(), name.c_str(), FNM_NOESCAPE)==0;
}
 
bool dabc::Object::NameMatchM(const std::string &name, const std::string &mask)
{
   size_t separ = mask.find_first_of(':');
 
   if (separ==std::string::npos) return NameMatch(name, mask);
 
   size_t lastsepar = 0;
 
   do {
 
      std::string submask;
 
      if (separ==std::string::npos)
         submask = mask.substr(lastsepar);
      else
      if (separ>lastsepar)
         submask = mask.substr(lastsepar, separ-lastsepar);
 
      if (!submask.empty())
         if (NameMatch(name, submask)) return true;
 
      lastsepar = separ;
      if (separ!=std::string::npos) {
         lastsepar++;
         separ = mask.find_first_of(':', lastsepar);
      }
 
   } while (lastsepar!=std::string::npos);
 
   return false;
}
 
 
void dabc::Object::FillFullName(std::string &fullname, Object* upto, bool exclude_top_parent) const
{
   if ((GetParent()!=0) && (GetParent() != upto)) {
      GetParent()->FillFullName(fullname, upto, exclude_top_parent);
      fullname.append("/");
   }
 
   if (GetParent()==0) {
      if (exclude_top_parent) return;
      fullname.append("/");
   }
   fullname.append(GetName());
}
 
 
std::string dabc::Object::ItemName(bool compact) const
{
   std::string res;
   if (IsParent(dabc::mgr()))
      dabc::mgr()->FillItemName(this, res, compact);
   else
      FillFullName(res, 0);
 
   return res;
}
 
 
// ============================================================================
// FIXME: old code, should be adjusted
 
 
void dabc::Object::Print(int lvl)
{
   LockGuard guard(ObjectMutex());
   dabc::lgr()->Debug(lvl, "file", 1, "func", dabc::format("Object: %s Class:%s", GetName(), ClassName()).c_str());
}
 
 
void dabc::Object::InspectGarbageCollector()
{
#ifdef DABC_EXTRA_CHECKS
   LockGuard lock(gObjectGarbageMutex);
 
   DOUT0("GarbageCollector: there are %u objects in collector now", gObjectGarbageCollector.size());
 
   for (unsigned n=0;n<gObjectGarbageCollector.size();n++) {
      Object* obj = (Object*) gObjectGarbageCollector.at(n);
      DOUT0("   obj:%p name:%s class:%s refcnt:%u", obj, obj->GetName(), obj->ClassName(), obj->fObjectRefCnt);
   }
 
#endif
 
}
 
 
 
#ifdef DABC_EXTRA_CHECKS
 
#include <list>
#include <cstdio>
#include <map>
 
void dabc::Object::DebugObject(const char* classname, Object* instance, int kind)
{
 
   typedef std::list<dabc::Object*> obj_list;
   typedef std::map<std::string,obj_list> full_map;
   typedef std::map<std::string,int> counts_map;
 
 
   static counts_map cnts;
   static full_map objs;
   static dabc::Mutex mutex(true);
 
   dabc::LockGuard lock(mutex);
 
   if (classname == 0) {
      printf("NUM ENTRIES = %u\n", (unsigned) cnts.size());
      for (counts_map::iterator iter = cnts.begin(); iter != cnts.end(); iter++) {
         printf("   CLASS = %s  NUM = %d \n", iter->first.c_str(), iter->second);
 
         full_map::iterator iter2 = objs.find(iter->first);
         if (iter2!=objs.end())
            for (obj_list::iterator iter3 = iter2->second.begin(); iter3 != iter2->second.end(); iter3++)
               printf("      OBJ:%p NAME = %s\n", *iter3, (*iter3)->GetName());
      }
   } else {
      std::string name(classname);
      if (kind<0) cnts[name]--;
             else cnts[name]++;
 
      if (kind==10) objs[name].push_back(instance); else
      if (kind==-10) objs[name].remove(instance);
   }
}
 
#endif