loon: CandHandle Class Reference

00041                          :
00042   fCandRefer(0)
00043 , fMother(0)
00044 , fLocked(kFALSE)
00045 , fViewableNotifier(0)
00046 {
00047    fsNAlloc++;
00048 }

00051                                            :
00052   TObject(ch)
00053 , fCandRefer(ch.fCandRefer)
00054 , fMother(0)
00055 , fLocked(kFALSE)
00056 , fViewableNotifier(0)
00057 {
00058    fsNAlloc++;
00059 }

00062                                    :
00063   fCandRefer(cb)
00064 , fMother(0)
00065 , fLocked(kFALSE)
00066 , fViewableNotifier(0)
00067 {
00068    fsNAlloc++;
00069 }

00073 {
00074    DropMotherLink();
00075    fsNAlloc--;
00076 }

00126 {
00127 
00128 // Prevent duplication of pre-existing redundant daughter if check TRUE.
00129   if (check && FindDaughter(&ch)) {
00130     MSG("Cand", Msg::kVerbose)
00131      << "Attempt to add redundant CandHandle to daughter list: ignored."
00132      << endl;
00133     return 0;
00134   }
00135   return GetOwnedCandBase()->AddDaughterLink(ch);   // Added CandHandle*
00136 }

00140 {
00141    if (IsCloneOf(ch)) return this;
00142    TIter iterdau = GetDaughterIterator();
00143    CandHandle *dau;
00144    while ((dau=(CandHandle *) iterdau())) {
00145      const CandHandle *chh = dau->CloneInTree(ch);
00146      if (chh != 0) return chh;
00147    }
00148    return 0;
00149 }

00153 {
00154    if (fMother == 0) return;                        // No mother to drop
00155 
00156 // Remove mother's daughter link to this
00157    if (!IsLocal()) fMother->GetCandBase()->fDaughters.Remove(this);
00158 
00159    fMother = (CandHandle *) 0;           // Set this mother link to zero
00160 }

00164 {
00165    return (new CandHandle(*this));
00166 }

00190 {
00191 
00192 // Returns const ptr to first selected CandHandle in daughter list.
00193 // If classname is a null ptr or blank string, no class selection is
00194 // done.  If classname is provided, the qualifying object must
00195 // InheritFrom() or be a classname.  The objname is optional, but,
00196 // if filled, will further qualify the selection by requiring
00197 // agreement with the GetName() method of the selected object.
00198 
00199    TString classtr("");
00200    if (classname)
00201      classtr.Append(TString(classname).Strip(TString::kBoth));
00202    TString objstr("");
00203    if (objname)
00204      objstr.Append(TString(objname).Strip(TString::kBoth));
00205 
00206    TIter chli(&GetCandBase()->fDaughters);
00207    CandHandle *ch;
00208 
00209    while ((ch = dynamic_cast<CandHandle *>(chli()))) {
00210 
00211 // First check whether ch InheritsFrom "classname"
00212      if (classtr.IsNull() || ch->InheritsFrom(classtr)) {
00213 
00214 // Then check whether ch name equals "objname"
00215        if (objstr.IsNull() || (objstr == ch->GetName()))
00216          return ch;
00217      }
00218    }
00219    return 0;
00220 }

00170 {
00171 
00172 // Finds the first daughter encountered with the same Candidate
00173 // object referenced, not the same CandHandle object.
00174 
00175    TIter chli(&GetCandBase()->fDaughters);
00176    CandHandle *chi;
00177 
00178    while ((chi = dynamic_cast<CandHandle *>(chli()))) {
00179 
00180 // CandHandle object == operator is defined to compare Candidates
00181      if (*chi == *ch) return chi;
00182 
00183    }
00184    return 0;
00185 }

00526 {
00527   // Format the Candidate (and Daughters) to a ostream
00528   // if option string contains:
00529   //    n    = include name
00530   //    t    = include title
00531   //    i    = include Uid's
00532   //    v[n] = verbosity level, v0 to suppresss data values 
00533   //    d[n] = include daughters to depth of [n] (infinite if no n)
00534   //           d0 means don't print daughters
00535 
00536   GetCandBase()->FormatToOStream(os,option);
00537   return GetCandBase()->FormatDaughtersToOStream(os,option);
00538 }

00224 {
00225    return GetCandBase()->GetAlgConfig();
00226 }

00230 {
00231    return GetCandBase()->GetArchUidInt();
00232 }

00236 {
00237    return fCandRefer();
00238 }

00242 {
00243    return fCandRefer();
00244 }

00248 {
00249    return GetCandBase()->fCandRecord;
00250 }

00110 {return fCandRefer;}

00098 {return fCandRefer;}

00254 {
00255    return GetCandBase()->GetCandUid();
00256 }

00260 {
00261    return GetCandBase()->GetDaughter(ndau);
00262 }

00266 {
00267    return GetCandBase()->GetDaughterIterator();
00268 }

00272 {
00273    return GetCandBase()->GetLocalHandle();
00274 }

00278 {
00279    if ((fMother == 0) && (GetLocalHandle() != 0) && !IsLocal()) {
00280      return GetLocalHandle()->GetMother();
00281    }
00282    return fMother;
00283 }

00067 {return fsNAlloc;}

00287 {
00288    return GetCandBase()->GetName();
00289 }

00293 {
00294    return GetCandBase()->GetNDaughters();
00295 }

00299 {
00300    return GetCandRefer().GetNRefers();
00301 }

00305 {
00306    if (IsLocked()) {
00307      MSG("Cand", Msg::kSynopsis) << endl
00308          << "Attempt to modify a Candidate through a locked CandHandle:"
00309         << endl << "Class = " << ClassName() << "  Name = " << GetName()
00310                 << endl << "This CandHandle is owned by the I/O system."
00311              << endl << "Please create your own CandHandle first using:"
00312                                  << endl << "(" << ClassName() << " *) "
00313                       << "mycandhandle = lockedcandhandle->DupHandle();"
00314       << endl << "Then modify the Candidate object through the new one."
00315                        << endl << "Your modification will be made to a "
00316            << "clone of the original Candidate object." << endl << endl;
00317    }
00318 
00319 // Experimental:  fsSlushyEnabled = kTRUE clones only Candidates read-in
00320    else if (CandHandle::IsSlushyEnabled()) return fCandRefer();
00321 
00322    assert(this != GetLocalHandle());           // Cannot own LocalHandle
00323    CandBase *cb = GetCandRefer().OwnRef();  // Exclusive ref to CandBase
00324 
00325 // Set CandRecord to that of mother, if any, and if not already set.
00326    if (GetMother() &&    // This CandHandle is a daughter (has a mother)
00327       (GetMother()->GetCandRecord() != cb->fCandRecord))
00328      cb->SetCandRecord(GetMother()->GetCandRecord());
00329 
00330    return cb;                               // Exclusive ref to CandBase
00331 }

00335 {
00336    return GetCandBase()->GetTitle();
00337 }

00341 {
00342    return GetCandBase()->GetUidInt();
00343 }

00072 {return fViewableNotifier;}

00347 {
00348    CandRecord *cr = GetCandBase()->fCandRecord;
00349    if (!cr) return 0;
00350    const CandHeader *ch = cr->GetCandHeader();
00351    return ch ? &ch->GetVldContext() : 0;
00352 }

00356 {
00357    return GetCandBase()->HasOverlapWith(*(ch.GetCandBase()));
00358 }

00362 {
00363    return GetCandUid().IsCloneOf(ch.GetCandUid());
00364 }

00368 {
00369    return GetCandBase()->IsComposite();
00370 }

00374 {
00375 
00376 // Overloads TObject::IsEqual method.
00377    if (TObject::IsEqual(rhs)) return true;     // Tests for same address
00378 
00379 // CandHandles refer to same CandBase address.
00380    const CandHandle *rch = dynamic_cast<const CandHandle*>(rhs);
00381    if (rch == 0) return false;
00382    if (this->GetCandBase() == rch->GetCandBase()) return true;
00383 
00384    return false;
00385 }

00389 {
00390 
00391 // IsEquivalent does deep comparison for templated Test... methods
00392 
00393 // Check for equivalent CandBases.
00394    const CandHandle *rch = dynamic_cast<const CandHandle*>(rhs);
00395    if (rch == NULL) {
00396     MSG("VCand", Msg::kDebug)
00397       << "CandHandle::IsEquivalent(): Comparison object not CandHandle."
00398                  << "  rhs->ClassName() = " << rhs->ClassName() << endl;
00399     return false;
00400   }
00401    if (this->IsEqual(rhs)) return true;      // Same address or CandBase
00402    if (this->GetCandBase()->IsEquivalent(rch->GetCandBase())) {
00403      return true;
00404    }
00405 
00406    return false;
00407 }

00411 {
00412    return (this == GetLocalHandle());
00413 }

00080 {return fLocked;}

00081 {return fsSlushyEnabled;}

00116 {
00117 
00118 // CandHandle object != operator compares Candidate addresses.
00119 // Pointer != just compares CandHandle addresses
00120   return !(*this == ch);
00121 }

00080 {
00081   if (IsLocked()) {
00082     MSG("Cand", Msg::kWarning) << endl
00083        << "Attempt to reset Candidate reference in a locked CandHandle:"
00084         << endl << "Class = " << ClassName() << "  Name = " << GetName()
00085                 << endl << "This CandHandle is owned by the I/O system."
00086                    << endl << "Please create your own CandHandle first."
00087          << endl << "Then reset the Candidate reference in the new one."
00088                                       << endl << "This attempt ignored."
00089                                                         << endl << endl;
00090     return *this;
00091   }
00092 
00093   if (this != &ch) {
00094 
00095 // Assign CandRefer
00096     if (fCandRefer != ch.GetCandRefer()) fCandRefer=ch.GetCandRefer();
00097 
00098 //gmi The following statement from original Babar code looks like a bug.
00099 //gmi Why should the mother link get zeroed if the CandBase is changed?
00100 //gmi fMother = (CandHandle *) 0;              // Mother link not copied
00101   }
00102   return *this;
00103 }

00107 {
00108 
00109 // CandHandle object == operator compares Candidate addresses.
00110 // Pointer == just compares CandHandle addresses.
00111   return (GetCandBase() == ch.GetCandBase());
00112 }

00520 {
00521   FormatToOStream(cout,option);
00522 }

00417 {
00418 
00419 // Removes the first daughter encountered with the same Candidate
00420 // object referenced, not the same CandHandle object.
00421    CandHandle *chexact = FindDaughter(ch);
00422    if (chexact) return GetOwnedCandBase()->RemoveDaughter(chexact);
00423    else return kFALSE;
00424 }

00428 {
00429   if (cr) {                          // Don't reset a CandRecord to zero
00430     if (cr != GetCandRecord()) {                      // Change of value
00431       if (GetCandRecord()) GetOwnedCandBase()->SetCandRecord(cr);//Reset
00432       else GetCandBase()->SetCandRecord(cr);   // Init non-zero for free
00433     }
00434   }
00435 }

00459 {
00460    fLocked = kTRUE;
00461 }

00465 {
00466    assert(ch != 0);                        // Can't set null mother link
00467    assert(fMother == 0);                  // Can't already have a mother
00468    assert(!IsLocal());               // Can't set mother for LocalHandle
00469    fMother = ch;                                  // Set the mother link
00470    fMother->GetCandBase()->fDaughters.Add(this);  // Add to ma's dghters
00471 }

00475 {
00476    GetOwnedCandBase()->SetName(name);
00477 }

00439 {
00440    if (tf == CandHandle::fsSlushyEnabled) {
00441      MSG("Cand", Msg::kSynopsis)
00442        << "CandHandle::fsSlushyEnabled unchanged from "
00443        << CandHandle::fsSlushyEnabled << endl
00444        << "by call to CandHandle::SetSlushyEnabled(" << tf << ")."
00445        << endl;
00446    }
00447    else {
00448      MSG("Cand", Msg::kSynopsis)
00449        << "CandHandle::fsSlushyEnabled changed from "
00450        << CandHandle::fsSlushyEnabled << " to " << tf
00451        << endl << "by call to CandHandle::SetSlushyEnabled(Bool_t)."
00452        << endl;
00453      CandHandle::fsSlushyEnabled = tf;
00454    }
00455 }

00481 {
00482    GetOwnedCandBase()->SetTitle(title);
00483 }

00089                                                {fViewableNotifier = vn;}

00487 {
00488   MSG("Cand", Msg::kDebug)
00489          << "**********Begin CandHandle::Trace(\"" << c << "\")" << endl
00490                   << "Information from CandHandle's CandBase: " << endl;
00491   GetCandBase()->Trace(c);
00492 
00493   if (GetMother()) {
00494     MSG("Cand", Msg::kDebug) <<
00495       "This CandHandle is in Daughter list of CandBase whose Trace is: "
00496                                                                 << endl;
00497     GetMother()->GetCandBase()->Trace("Mother's CandBase");
00498   }
00499 
00500   else {
00501     MSG("Cand", Msg::kDebug)
00502             << "Traces of CandHandle's CandBase Daughterlist: " << endl;
00503   }
00504 
00505   if (GetNDaughters()) {
00506     MSG("Cand", Msg::kDebug)
00507             << "Traces of CandHandle's CandBase Daughterlist: " << endl;
00508     TIter iterdau = GetDaughterIterator();
00509     CandHandle *dau;
00510     while ((dau = (CandHandle *) iterdau())) {
00511       dau->Trace("Daughter CandHandles");
00512     }
00513   }
00514   MSG("Cand", Msg::kDebug)
00515           << "**********End CandHandle::Trace(\"" << c << "\")" << endl;
00516 }


Public Member Functions
	CandHandle ()
	CandHandle (const CandHandle &ch)
	CandHandle (CandBase *cb)
virtual	~CandHandle ()
CandHandle &	operator= (const CandHandle &ch)
Bool_t	operator== (const CandHandle &ch) const
Bool_t	operator!= (const CandHandle &ch) const
const CandHandle *	AddDaughterLink (CandHandle &ch, Bool_t check=kTRUE)
const CandHandle *	CloneInTree (const CandHandle &ch) const
virtual CandHandle *	DupHandle () const
CandHandle *	FindDaughter (const CandHandle *ch) const
const CandHandle *	FindDaughter (const char classname=0, const char objname=0) const
const AlgConfig *	GetAlgConfig () const
UInt_t	GetArchUidInt () const
const CandBase *	GetCandBase () const
CandBase *	GetCandBase ()
CandRecord *	GetCandRecord () const
const CandHandle *	GetDaughter (Int_t ndau) const
TIter	GetDaughterIterator () const
const CandHandle *	GetLocalHandle () const
const CandHandle *	GetMother () const
const char *	GetName () const
Int_t	GetNDaughters () const
Int_t	GetNRefers () const
const char *	GetTitle () const
UInt_t	GetUidInt () const
ViewableNotifier *	GetViewableNotifier ()
const VldContext *	GetVldContext () const
Bool_t	HasOverlapWith (const CandHandle &ch) const
Bool_t	IsCloneOf (const CandHandle &ch) const
Bool_t	IsComposite () const
virtual Bool_t	IsEqual (const TObject *rhs) const
virtual Bool_t	IsEquivalent (const TObject *rhs) const
Bool_t	IsLocal () const
Bool_t	IsLocked () const
Bool_t	RemoveDaughter (CandHandle *ch)
void	SetCandRecord (CandRecord *cr)
void	SetName (const char *name)
void	SetLock ()
void	SetTitle (const char *title)
void	SetViewableNotifier (ViewableNotifier *vn=0)
virtual void	Trace (const char *c="") const
virtual void	Print (Option_t *option="nid3") const
virtual std::ostream &	FormatToOStream (std::ostream &os, Option_t *option="nid3") const
Static Public Member Functions
Int_t	GetNAlloc ()
Bool_t	IsSlushyEnabled ()
void	SetSlushyEnabled (Bool_t tf=kTRUE)
Protected Member Functions
CandBase *	GetOwnedCandBase ()
const CandRefer &	GetCandRefer () const
const CandUid &	GetCandUid () const
Private Member Functions
void	DropMotherLink ()
	Dont write out.
CandRefer &	GetCandRefer ()
void	SetMotherLink (CandHandle *ch)
Private Attributes
CandRefer	fCandRefer
CandHandle *	fMother
Bool_t	fLocked
ViewableNotifier *	fViewableNotifier
Static Private Attributes
Int_t	fsNAlloc = 0
Bool_t	fsSlushyEnabled = kFALSE
Friends
class	CandBase

CandHandle Class Reference

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation