Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
ProcFileElements.C File Reference

Detailed Description

Class to hold information about the processed elements of a file.

#include "TCollection.h"
//_______________________________________________________________________
Int_t ProcFileElements::ProcFileElement::Compare(const TObject *o) const
{
// Compare this element with 'e'.
// Return
// -1 this should come first
// 0 same
// 1 e should come first
const ProcFileElements::ProcFileElement *e =
dynamic_cast<const ProcFileElements::ProcFileElement *>(o);
if (!e) return -1;
if (fFirst == e->fFirst) {
// They start at the same point
return 0;
} else if (fFirst < e->fFirst) {
// This starts first
return -1;
} else {
// e starts first
return 1;
}
}
//_______________________________________________________________________
Int_t ProcFileElements::ProcFileElement::Overlapping(ProcFileElement *e)
{
// Check overlapping status of this element with 'e'.
// Return
// -1 not overlapping
// 0 adjacent
// 1 overlapping
if (!e) return -1;
if (fFirst == 0 && fLast == -1) {
// We cover the full range, so we overlap
return 1;
}
if (fFirst < e->fFirst) {
if (fLast >= 0) {
if (fLast < e->fFirst - 1) {
// Disjoint
return -1;
} else {
// We somehow overlap
if (fLast == e->fFirst - 1) {
// Just adjacent
return 0;
} else {
// Real overlap
return 1;
}
}
} else {
// Always overlapping
return 1;
}
} else if (fFirst == e->fFirst) {
// Overlapping or adjacent
if (fFirst == fLast || e->fFirst == e->fLast) return 0;
return 1;
} else {
// The other way around
if (e->fLast >= 0) {
if (e->fLast < fFirst - 1) {
// Disjoint
return -1;
} else {
// We somehow overlap
if (e->fLast == fFirst - 1) {
// Just adjacent
return 0;
} else {
// Real overlap
return 1;
}
}
} else {
// Always overlapping
return 1;
}
}
// Should never be here
Warning("Overlapping", "should never be here!");
return -1;
}
//_______________________________________________________________________
Int_t ProcFileElements::ProcFileElement::MergeElement(ProcFileElement *e)
{
// Merge this element with element 'e'.
// Return -1 if it cannot be done, i.e. thei are disjoint; 0 otherwise
// Check if it can be done
if (Overlapping(e) < 0) return -1;
// Ok, we can merge: set the lower bound
if (e->fFirst < fFirst) fFirst = e->fFirst;
// Set the upper bound
if (fLast == -1 || e->fLast == -1) {
fLast = -1;
} else {
if (fLast < e->fLast) fLast = e->fLast;
}
// Done
return 0;
}
//_______________________________________________________________________
void ProcFileElements::ProcFileElement::Print(Option_t *) const
{
// Print range of this element
Printf("\tfirst: %lld\t last: %lld", fFirst, fLast);
}
//_______________________________________________________________________
Int_t ProcFileElements::Add(Long64_t fst, Long64_t lst)
{
// Add a new element to the list
// Return 1 if a new element has been added, 0 if it has been merged
// with an existing one, -1 in case of error
if (!fElements) fElements = new TSortedList;
if (!fElements) {
Error("Add", "could not create internal list!");
return -1;
}
// Create (temporary element)
ProcFileElements::ProcFileElement *ne =
new ProcFileElements::ProcFileElement(fst, lst);
// Check if if it is adjacent or overlapping with an existing one
TIter nxe(fElements);
ProcFileElements::ProcFileElement *e = nullptr;
while ((e = (ProcFileElements::ProcFileElement *)nxe())) {
if (e->MergeElement(ne) == 0) break;
}
Int_t rc = 0;
// Remove and re-add the merged element to sort correctly its possibly new position
if (e) {
fElements->Remove(e);
fElements->Add(e);
} else {
// Add the new element
fElements->Add(ne);
rc = 1;
}
// Make sure that all what can be merged is merged (because of the order, some elements
// which could be merged are not merged, making the determination of fFirst and fLast below
// to give incorrect values)
ProcFileElements::ProcFileElement *ep = nullptr, *en = nullptr;
TObjLink *olp = fElements->FirstLink(), *oln = nullptr;
while (olp && (ep = (ProcFileElements::ProcFileElement *) olp->GetObject())) {
oln = olp->Next();
while (oln) {
if ((en = (ProcFileElements::ProcFileElement *) oln->GetObject())) {
if (ep->MergeElement(en) == 0) {
fElements->Remove(en);
delete en;
}
}
oln = oln->Next();
}
olp = olp->Next();
}
// New overall ranges
if ((e = (ProcFileElements::ProcFileElement *) fElements->First())) fFirst = e->fFirst;
if ((e = (ProcFileElements::ProcFileElement *) fElements->Last())) fLast = e->fLast;
// Done
return rc;
}
//_______________________________________________________________________
void ProcFileElements::Print(Option_t *) const
{
// Print info about this processed file
Printf("--- ProcFileElements ----------------------------------------");
Printf(" File: %s", fName.Data());
Printf(" # proc elements: %d", fElements ? fElements->GetSize() : 0);
TIter nxe(fElements);
ProcFileElements::ProcFileElement *e = nullptr;
while ((e = (ProcFileElements::ProcFileElement *)nxe())) { e->Print(); }
Printf(" Raw overall range: [%lld, %lld]", fFirst, fLast);
Printf("-------------------------------------------------------------");
}
//_______________________________________________________________________
Int_t ProcFileElements::Merge(TCollection *li)
{
// Merge this object with those in the list
// Return number of elements added
if (!li) return -1;
if (li->GetSize() <= 0) return 0;
Int_t nadd = 0;
TIter nxo(li);
ProcFileElements *pfe = nullptr;
while ((pfe = (ProcFileElements *) nxo())) {
if (strcmp(GetName(), pfe->GetName()))
Warning("Merge", "merging objects of different name! ('%s' != '%s')",
GetName(), pfe->GetName());
TIter nxe(pfe->GetListOfElements());
ProcFileElements::ProcFileElement *e = nullptr;
while ((e = (ProcFileElements::ProcFileElement *)nxe())) {
Int_t rc = Add(e->fFirst, e->fLast);
if (rc == 1) nadd++;
}
}
// Done
return nadd;
}
Class to hold information about the processed elements of a file.
#define SafeDelete(p)
Definition RConfig.hxx:542
#define e(i)
Definition RSha256.hxx:103
int Int_t
Definition RtypesCore.h:45
long long Long64_t
Definition RtypesCore.h:80
const char Option_t
Definition RtypesCore.h:66
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition TError.cxx:185
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
Definition TError.cxx:229
void Printf(const char *fmt,...)
Formats a string in a circular formatting buffer and prints the string.
Definition TString.cxx:2503
T1 fFirst
Definition X11Events.mm:86
Collection abstract base class.
Definition TCollection.h:65
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Mother of all ROOT objects.
Definition TObject.h:41
A sorted doubly linked list.
Definition TSortedList.h:28
TMatrixT< Element > & Add(TMatrixT< Element > &target, Element scalar, const TMatrixT< Element > &source)
Modify addition: target += scalar * source.
Author
Gerardo Ganis (gerar.nosp@m.do.g.nosp@m.anis@.nosp@m.cern.nosp@m..ch)

Definition in file ProcFileElements.C.