*****************************************************************************/
#include "RooFit.h"
#include "TObjString.h"
#include "TObjString.h"
#include "RooAbsArg.h"
#include "RooArgSet.h"
#include "RooArgProxy.h"
#include "RooSetProxy.h"
#include "RooListProxy.h"
#include "RooAbsData.h"
#include "RooAbsCategoryLValue.h"
#include "RooAbsRealLValue.h"
#include "RooTrace.h"
#include "RooStringVar.h"
#include <string.h>
#include <iomanip>
#include <fstream>
#if (__GNUC__==3&&__GNUC_MINOR__==2&&__GNUC_PATCHLEVEL__==3)
char* operator+( streampos&, char* );
#endif
ClassImp(RooAbsArg)
;
Bool_t RooAbsArg::_verboseDirty(kFALSE) ;
Bool_t RooAbsArg::_inhibitDirty(kFALSE) ;
Int_t RooAbsArg::_nameLength(0) ;
RooAbsArg::RooAbsArg() :
TNamed(),
_attribList(),
_deleteWatch(kFALSE),
_operMode(Auto)
{
_clientShapeIter = _clientListShape.MakeIterator() ;
_clientValueIter = _clientListValue.MakeIterator() ;
RooTrace::create(this) ;
}
RooAbsArg::RooAbsArg(const char *name, const char *title) :
TNamed(name,title),
_deleteWatch(kFALSE),
_valueDirty(kTRUE),
_shapeDirty(kTRUE),
_operMode(Auto)
{
_clientShapeIter = _clientListShape.MakeIterator() ;
_clientValueIter = _clientListValue.MakeIterator() ;
RooTrace::create(this) ;
}
RooAbsArg::RooAbsArg(const RooAbsArg& other, const char* name)
: TNamed(other.GetName(),other.GetTitle()),
RooPrintable(other),
_deleteWatch(other._deleteWatch),
_operMode(Auto)
{
if (name) SetName(name) ;
TObject* obj ;
TIterator* aIter = other._attribList.MakeIterator() ;
while ((obj=aIter->Next())) {
_attribList.Add(new TObjString(obj->GetName())) ;
}
delete aIter ;
TIterator* sIter = other._serverList.MakeIterator() ;
RooAbsArg* server ;
Bool_t valueProp, shapeProp ;
while ((server = (RooAbsArg*) sIter->Next())) {
valueProp = server->_clientListValue.FindObject((TObject*)&other)?kTRUE:kFALSE ;
shapeProp = server->_clientListShape.FindObject((TObject*)&other)?kTRUE:kFALSE ;
addServer(*server,valueProp,shapeProp) ;
}
delete sIter ;
_clientShapeIter = _clientListShape.MakeIterator() ;
_clientValueIter = _clientListValue.MakeIterator() ;
setValueDirty() ;
setShapeDirty() ;
setAttribute(Form("CloneOf(%08x)",&other)) ;
RooTrace::create(this) ;
}
RooAbsArg::~RooAbsArg()
{
TIterator* serverIter = _serverList.MakeIterator() ;
RooAbsArg* server ;
while ((server=(RooAbsArg*)serverIter->Next())) {
removeServer(*server,kTRUE) ;
}
delete serverIter ;
TIterator* clientIter = _clientList.MakeIterator() ;
RooAbsArg* client = 0;
Bool_t first(kTRUE) ;
while ((client=(RooAbsArg*)clientIter->Next())) {
client->setAttribute("ServerDied") ;
TString attr("ServerDied:");
attr.Append(GetName());
attr.Append(Form("(%x)",this)) ;
client->setAttribute(attr.Data());
client->removeServer(*this,kTRUE);
if (_verboseDirty || deleteWatch()) {
if (deleteWatch() && first) {
cout << "RooAbsArg::dtor(" << GetName() << "," << this << ") DeleteWatch: object is being destroyed" << endl ;
first = kFALSE ;
}
cout << fName << "::" << ClassName() << ":~RooAbsArg: dependent \""
<< client->GetName() << "\" should have been deleted first" << endl ;
}
}
delete clientIter ;
_attribList.Delete() ;
delete _clientShapeIter ;
delete _clientValueIter ;
RooTrace::destroy(this) ;
}
Bool_t RooAbsArg::isCloneOf(const RooAbsArg& other) const
{
return (getAttribute(Form("CloneOf(%08x)",&other)) ||
other.getAttribute(Form("CloneOf(%08x)",this))) ;
}
void RooAbsArg::setAttribute(const Text_t* name, Bool_t value)
{
TObject* oldAttrib = _attribList.FindObject(name) ;
if (value) {
if (!oldAttrib) {
TObjString* nameObj = new TObjString(name) ;
_attribList.Add(nameObj) ;
}
} else {
if (oldAttrib) {
_attribList.Remove(oldAttrib) ;
}
}
}
Bool_t RooAbsArg::getAttribute(const Text_t* name) const
{
return _attribList.FindObject(name)?kTRUE:kFALSE ;
}
void RooAbsArg::addServer(RooAbsArg& server, Bool_t valueProp, Bool_t shapeProp)
{
if (_verboseDirty) {
cout << "RooAbsArg::addServer(" << GetName() << "): adding server " << server.GetName()
<< "(" << &server << ") for " << (valueProp?"value ":"") << (shapeProp?"shape":"") << endl ;
}
_serverList.Add(&server) ;
server._clientList.Add(this) ;
if (valueProp) server._clientListValue.Add(this) ;
if (shapeProp) server._clientListShape.Add(this) ;
}
void RooAbsArg::addServerList(RooAbsCollection& serverList, Bool_t valueProp, Bool_t shapeProp)
{
RooAbsArg* arg ;
TIterator* iter = serverList.createIterator() ;
while ((arg=(RooAbsArg*)iter->Next())) {
addServer(*arg,valueProp,shapeProp) ;
}
delete iter ;
}
void RooAbsArg::removeServer(RooAbsArg& server, Bool_t force)
{
if (_verboseDirty) {
cout << "RooAbsArg::removeServer(" << GetName() << "): removing server "
<< server.GetName() << "(" << &server << ")" << endl ;
}
if (!force) {
_serverList.Remove(&server) ;
server._clientList.Remove(this) ;
server._clientListValue.Remove(this) ;
server._clientListShape.Remove(this) ;
} else {
_serverList.RemoveAll(&server) ;
server._clientList.RemoveAll(this) ;
server._clientListValue.RemoveAll(this) ;
server._clientListShape.RemoveAll(this) ;
}
}
void RooAbsArg::replaceServer(RooAbsArg& oldServer, RooAbsArg& newServer, Bool_t propValue, Bool_t propShape)
{
Int_t count = _serverList.refCount(&oldServer) ;
removeServer(oldServer,kTRUE) ;
while(count--) {
addServer(newServer,propValue,propShape) ;
}
}
void RooAbsArg::changeServer(RooAbsArg& server, Bool_t valueProp, Bool_t shapeProp)
{
if (!_serverList.FindObject(&server)) {
cout << "RooAbsArg::changeServer(" << GetName() << "): Server "
<< server.GetName() << " not registered" << endl ;
return ;
}
if (!server._clientList.FindObject(this)) {
cout << "RooAbsArg::changeServer(" << GetName() << "): Server "
<< server.GetName() << " doesn't have us registered as client" << endl ;
return ;
}
Int_t vcount = server._clientListValue.refCount(this) ;
Int_t scount = server._clientListShape.refCount(this) ;
server._clientListValue.RemoveAll(this) ;
server._clientListShape.RemoveAll(this) ;
if (valueProp) {
while (vcount--) server._clientListValue.Add(this) ;
}
if (shapeProp) {
while(scount--) server._clientListShape.Add(this) ;
}
}
void RooAbsArg::leafNodeServerList(RooAbsCollection* list, const RooAbsArg* arg) const
{
treeNodeServerList(list,arg,kFALSE,kTRUE) ;
}
void RooAbsArg::branchNodeServerList(RooAbsCollection* list, const RooAbsArg* arg) const
{
treeNodeServerList(list,arg,kTRUE,kFALSE) ;
}
void RooAbsArg::treeNodeServerList(RooAbsCollection* list, const RooAbsArg* arg, Bool_t doBranch, Bool_t doLeaf, Bool_t valueOnly) const
{
if (!arg) {
if (list->getHashTableSize()==0) {
list->setHashTableSize(1000) ;
}
arg=this ;
}
if ((doBranch&&doLeaf) ||
(doBranch&&arg->isDerived()) ||
(doLeaf&&!arg->isDerived())) {
list->add(*arg,kTRUE) ;
}
if (arg->isDerived()) {
RooAbsArg* server ;
TIterator* sIter = arg->serverIterator() ;
while ((server=(RooAbsArg*)sIter->Next())) {
Bool_t isValueServer = server->_clientListValue.FindObject((TObject*)arg)?kTRUE:kFALSE ;
if (valueOnly && !isValueServer) continue ;
treeNodeServerList(list,server,doBranch,doLeaf) ;
}
delete sIter ;
}
}
RooArgSet* RooAbsArg::getParameters(const RooAbsData* set) const
{
return getParameters(set?set->get():0) ;
}
RooArgSet* RooAbsArg::getParameters(const RooArgSet* nset) const
{
RooArgSet parList("parameters") ;
RooArgSet leafList("leafNodeServerList") ;
treeNodeServerList(&leafList,0,kFALSE,kTRUE,kFALSE) ;
TIterator* sIter = leafList.createIterator() ;
RooAbsArg* arg ;
while ((arg=(RooAbsArg*)sIter->Next())) {
if ((!nset || !arg->dependsOn(*nset)) && arg->isLValue()) {
parList.add(*arg) ;
}
}
delete sIter ;
RooArgSet branchList ;
branchNodeServerList(&branchList) ;
RooAbsArg* branch ;
TIterator* bIter = branchList.createIterator() ;
while((branch=(RooAbsArg*)bIter->Next())) {
branch->getParametersHook(nset, &parList) ;
}
delete bIter ;
RooArgList tmp(parList) ;
tmp.sort() ;
return new RooArgSet(tmp) ;
}
RooArgSet* RooAbsArg::getObservables(const RooAbsData* set) const
{
if (!set) return new RooArgSet ;
return getObservables(set->get()) ;
}
RooArgSet* RooAbsArg::getObservables(const RooArgSet* dataList) const
{
RooArgSet* depList = new RooArgSet("dependents") ;
if (!dataList) return depList ;
RooArgSet leafList("leafNodeServerList") ;
treeNodeServerList(&leafList,0,kFALSE,kTRUE,kTRUE) ;
TIterator *sIter = leafList.createIterator() ;
RooAbsArg* arg ;
while ((arg=(RooAbsArg*)sIter->Next())) {
if (arg->dependsOn(*dataList) && arg->isLValue()) {
depList->add(*arg) ;
}
}
delete sIter ;
RooArgSet branchList ;
branchNodeServerList(&branchList) ;
RooAbsArg* branch ;
TIterator* bIter = branchList.createIterator() ;
while((branch=(RooAbsArg*)bIter->Next())) {
branch->getObservablesHook(dataList, depList) ;
}
delete bIter ;
return depList ;
}
RooArgSet* RooAbsArg::getComponents() const
{
TString name(GetName()) ;
name.Append("_components") ;
RooArgSet* set = new RooArgSet(name) ;
branchNodeServerList(set) ;
return set ;
}
Bool_t RooAbsArg::checkObservables(const RooArgSet*) const
{
return kFALSE ;
}
Bool_t RooAbsArg::recursiveCheckObservables(const RooArgSet* nset) const
{
RooArgSet nodeList ;
treeNodeServerList(&nodeList) ;
TIterator* iter = nodeList.createIterator() ;
RooAbsArg* arg ;
Bool_t ret(kFALSE) ;
while((arg=(RooAbsArg*)iter->Next())) {
if (arg->getAttribute("ServerDied")) {
cout << "RooAbsArg::recursiveCheckObservables(" << GetName() << "): ERROR: one or more servers of node "
<< arg->GetName() << " no longer exists!" << endl ;
arg->Print("v") ;
ret = kTRUE ;
}
ret |= arg->checkObservables(nset) ;
}
delete iter ;
return ret ;
}
Bool_t RooAbsArg::dependsOn(const RooAbsCollection& serverList, const RooAbsArg* ignoreArg) const
{
Bool_t result(kFALSE);
TIterator* sIter = serverList.createIterator();
RooAbsArg* server ;
while ((!result && (server=(RooAbsArg*)sIter->Next()))) {
if (dependsOn(*server,ignoreArg)) {
result= kTRUE;
}
}
delete sIter;
return result;
}
Bool_t RooAbsArg::dependsOn(const RooAbsArg& testArg, const RooAbsArg* ignoreArg) const
{
if (this==ignoreArg) return kFALSE ;
if (!TString(testArg.GetName()).CompareTo(GetName())) return kTRUE ;
if (_serverList.FindObject(testArg.GetName())) return kTRUE ;
TIterator* sIter = serverIterator() ;
RooAbsArg* server = 0 ;
while ((server=(RooAbsArg*)sIter->Next())) {
if (server->dependsOn(testArg)) {
delete sIter ;
return kTRUE ;
}
}
delete sIter ;
return kFALSE ;
}
Bool_t RooAbsArg::overlaps(const RooAbsArg& testArg) const
{
RooArgSet list("treeNodeList") ;
treeNodeServerList(&list) ;
return testArg.dependsOn(list) ;
}
Bool_t RooAbsArg::observableOverlaps(const RooAbsData* dset, const RooAbsArg& testArg) const
{
return observableOverlaps(dset->get(),testArg) ;
}
Bool_t RooAbsArg::observableOverlaps(const RooArgSet* nset, const RooAbsArg& testArg) const
{
RooArgSet* depList = getObservables(nset) ;
Bool_t ret = testArg.dependsOn(*depList) ;
delete depList ;
return ret ;
}
void RooAbsArg::setValueDirty(const RooAbsArg* source) const
{
if (_operMode!=Auto || _inhibitDirty) return ;
if (_clientListValue.GetSize()==0) {
_valueDirty = kTRUE ;
return ;
}
if (source==0) {
source=this ;
} else if (source==this) {
cout << "RooAbsArg::setValueDirty(" << GetName()
<< "): cyclical dependency detected" << endl ;
return ;
}
if (_verboseDirty) cout << "RooAbsArg::setValueDirty(" << (source?source->GetName():"self") << "->" << GetName() << "," << this
<< "): dirty flag " << (_valueDirty?"already ":"") << "raised" << endl ;
_valueDirty = kTRUE ;
_clientValueIter->Reset() ;
RooAbsArg* client ;
while ((client=(RooAbsArg*)_clientValueIter->Next())) {
client->setValueDirty(source) ;
}
}
void RooAbsArg::setShapeDirty(const RooAbsArg* source) const
{
if (_verboseDirty) cout << "RooAbsArg::setShapeDirty(" << GetName()
<< "): dirty flag " << (_shapeDirty?"already ":"") << "raised" << endl ;
if (_clientListShape.GetSize()==0) {
_shapeDirty = kTRUE ;
return ;
}
if (source==0) {
source=this ;
} else if (source==this) {
cout << "RooAbsArg::setShapeDirty(" << GetName()
<< "): cyclical dependency detected" << endl ;
return ;
}
_shapeDirty=kTRUE ;
_clientShapeIter->Reset() ;
RooAbsArg* client ;
while ((client=(RooAbsArg*)_clientShapeIter->Next())) {
client->setShapeDirty(source) ;
client->setValueDirty(source) ;
}
}
Bool_t RooAbsArg::redirectServers(const RooAbsCollection& newSet, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t isRecursionStep)
{
if (!_serverList.First()) return kFALSE ;
if (newSet.getSize()==0) return kFALSE ;
Bool_t ret(kFALSE) ;
THashList origServerList, origServerValue, origServerShape ;
RooAbsArg *oldServer, *newServer ;
TIterator* sIter = _serverList.MakeIterator() ;
while ((oldServer=(RooAbsArg*)sIter->Next())) {
origServerList.Add(oldServer) ;
if (oldServer->_clientListValue.FindObject(this)) {
origServerValue.Add(oldServer) ;
}
if (oldServer->_clientListShape.FindObject(this)) {
origServerShape.Add(oldServer) ;
}
}
delete sIter ;
sIter = origServerList.MakeIterator() ;
Bool_t propValue, propShape ;
while ((oldServer=(RooAbsArg*)sIter->Next())) {
newServer= oldServer->findNewServer(newSet, nameChange);
if (newServer && _verboseDirty) {
cout << "RooAbsArg::redirectServers(" << (void*)this << "," << GetName() << "): server " << oldServer->GetName()
<< " redirected from " << oldServer << " to " << newServer << endl ;
}
if (!newServer) {
if (mustReplaceAll) {
cout << "RooAbsArg::redirectServers(" << (void*)this << "," << GetName() << "): server " << oldServer->GetName()
<< " (" << (void*)oldServer << ") not redirected" << (nameChange?"[nameChange]":"") << endl ;
ret = kTRUE ;
}
continue ;
}
propValue=origServerValue.FindObject(oldServer)?kTRUE:kFALSE ;
propShape=origServerShape.FindObject(oldServer)?kTRUE:kFALSE ;
replaceServer(*oldServer,*newServer,propValue,propShape) ;
}
delete sIter ;
setValueDirty() ;
setShapeDirty() ;
Bool_t allReplaced=kTRUE ;
for (int i=0 ; i<numProxies() ; i++) {
Bool_t ret = getProxy(i)->changePointer(newSet,nameChange) ;
allReplaced &= ret ;
}
if (mustReplaceAll && !allReplaced) {
cout << "RooAbsArg::redirectServers(" << GetName()
<< "): ERROR, some proxies could not be adjusted" << endl ;
ret = kTRUE ;
}
ret |= redirectServersHook(newSet,mustReplaceAll,nameChange,isRecursionStep) ;
return ret ;
}
RooAbsArg *RooAbsArg::findNewServer(const RooAbsCollection &newSet, Bool_t nameChange) const {
RooAbsArg *newServer = 0;
if (!nameChange) {
newServer = newSet.find(GetName()) ;
}
else {
TString nameAttrib("ORIGNAME:") ;
nameAttrib.Append(GetName()) ;
RooArgSet* tmp = (RooArgSet*) newSet.selectByAttrib(nameAttrib,kTRUE) ;
if(0 != tmp) {
if (tmp->getSize()==0) {
delete tmp ;
return 0 ;
}
if(tmp->getSize()>1) {
cout << "RooAbsArg::redirectServers(" << GetName() << "): FATAL Error, " << tmp->getSize() << " servers with "
<< nameAttrib << " attribute" << endl ;
tmp->Print("v") ;
assert(0) ;
}
newServer= tmp->first();
delete tmp ;
}
}
return newServer;
}
Bool_t RooAbsArg::recursiveRedirectServers(const RooAbsCollection& newSet, Bool_t mustReplaceAll, Bool_t nameChange)
{
static RooLinkedList callStack ;
if (callStack.FindObject(this)) {
return kFALSE ;
} else {
callStack.Add(this) ;
}
Bool_t ret(kFALSE) ;
ret |= redirectServers(newSet,mustReplaceAll,nameChange,kTRUE) ;
TIterator* sIter = serverIterator() ;
RooAbsArg* server ;
while((server=(RooAbsArg*)sIter->Next())) {
ret |= server->recursiveRedirectServers(newSet,mustReplaceAll,nameChange) ;
}
delete sIter ;
callStack.Remove(this) ;
return ret ;
}
void RooAbsArg::registerProxy(RooArgProxy& proxy)
{
if (_proxyList.FindObject(&proxy)) {
cout << "RooAbsArg::registerProxy(" << GetName() << "): proxy named "
<< proxy.GetName() << " for arg " << proxy.absArg()->GetName()
<< " already registered" << endl ;
return ;
}
addServer(*proxy.absArg(),proxy.isValueServer(),proxy.isShapeServer()) ;
_proxyList.Add(&proxy) ;
}
void RooAbsArg::unRegisterProxy(RooArgProxy& proxy)
{
_proxyList.Remove(&proxy) ;
}
void RooAbsArg::registerProxy(RooSetProxy& proxy)
{
if (_proxyList.FindObject(&proxy)) {
cout << "RooAbsArg::registerProxy(" << GetName() << "): proxy named "
<< proxy.GetName() << " already registered" << endl ;
return ;
}
_proxyList.Add(&proxy) ;
}
void RooAbsArg::unRegisterProxy(RooSetProxy& proxy)
{
_proxyList.Remove(&proxy) ;
}
void RooAbsArg::registerProxy(RooListProxy& proxy)
{
if (_proxyList.FindObject(&proxy)) {
cout << "RooAbsArg::registerProxy(" << GetName() << "): proxy named "
<< proxy.GetName() << " already registered" << endl ;
return ;
}
_proxyList.Add(&proxy) ;
}
void RooAbsArg::unRegisterProxy(RooListProxy& proxy)
{
_proxyList.Remove(&proxy) ;
}
RooAbsProxy* RooAbsArg::getProxy(Int_t index) const
{
return dynamic_cast<RooAbsProxy*> (_proxyList.At(index)) ;
}
Int_t RooAbsArg::numProxies() const
{
return _proxyList.GetSize() ;
}
void RooAbsArg::setProxyNormSet(const RooArgSet* nset)
{
for (int i=0 ; i<numProxies() ; i++) {
getProxy(i)->changeNormSet(nset) ;
}
}
void RooAbsArg::attachToTree(TTree& ,Int_t)
{
cout << "RooAbsArg::attachToTree(" << GetName()
<< "): Cannot be attached to a TTree" << endl ;
}
Bool_t RooAbsArg::isValid() const
{
return kTRUE ;
}
void RooAbsArg::copyList(TList& dest, const TList& source)
{
dest.Clear() ;
TIterator* sIter = source.MakeIterator() ;
TObject* obj ;
while ((obj = sIter->Next())) {
dest.Add(obj) ;
}
delete sIter ;
}
void RooAbsArg::printToStream(ostream& os, PrintOption opt, TString indent) const
{
if(opt == Standard) {
os << ClassName() << "::" << this << "::" << GetName() ;
Int_t nfill = _nameLength-strlen(GetName()) ;
while(nfill-- > 0) os << " " ;
os << ": " ;
if (isDerived()) {
os << "(" ;
writeToStream(os,kFALSE);
os << ") -> " ;
writeToStream(os,kTRUE);
} else {
writeToStream(os,kFALSE);
}
os << endl;
}
else {
if (opt==InLine) {
inLinePrint(os,*this) ;
} else if (opt==OneLine) {
oneLinePrint(os,*this);
} else if(opt == Verbose) {
os << indent << "--- RooAbsArg ---" << endl;
os << indent << " Value State: " ;
switch(_operMode) {
case ADirty: os << "FORCED DIRTY" ; break ;
case AClean: os << "FORCED clean" ; break ;
case Auto: os << (isValueDirty() ? "DIRTY":"clean") ; break ;
}
os << endl
<< indent << " Shape State: " << (isShapeDirty() ? "DIRTY":"clean") << endl;
os << indent << " Attributes: " ;
printAttribList(os) ;
os << endl ;
os << indent << " Address: " << (void*)this << endl;
os << indent << " Clients: " << endl;
TIterator *clientIter= _clientList.MakeIterator();
RooAbsArg* client ;
while ((client=(RooAbsArg*)clientIter->Next())) {
os << indent << " (" << (void*)client << ","
<< (_clientListValue.FindObject(client)?"V":"-")
<< (_clientListShape.FindObject(client)?"S":"-")
<< ") " ;
client->printToStream(os,OneLine);
}
delete clientIter;
os << indent << " Servers: " << endl;
TIterator *serverIter= _serverList.MakeIterator();
RooAbsArg* server ;
while ((server=(RooAbsArg*)serverIter->Next())) {
os << indent << " (" << (void*)server << ","
<< (server->_clientListValue.FindObject((TObject*)this)?"V":"-")
<< (server->_clientListShape.FindObject((TObject*)this)?"S":"-")
<< ") " ;
server->printToStream(os,OneLine);
}
delete serverIter;
os << indent << " Proxies: " << endl ;
for (int i=0 ; i<numProxies() ; i++) {
RooAbsProxy* proxy=getProxy(i) ;
if (proxy->IsA()->InheritsFrom(RooArgProxy::Class())) {
os << indent << " " << proxy->name() << " -> " ;
((RooArgProxy*)proxy)->absArg()->printToStream(os,OneLine) ;
} else {
os << indent << " " << proxy->name() << " -> " ;
TString moreIndent(indent) ;
moreIndent.Append(" ") ;
((RooSetProxy*)proxy)->printToStream(os,Standard,moreIndent.Data()) ;
}
}
}
}
}
ostream& operator<<(ostream& os, RooAbsArg &arg)
{
arg.writeToStream(os,kTRUE) ;
return os ;
}
istream& operator>>(istream& is, RooAbsArg &arg)
{
arg.readFromStream(is,kTRUE,kFALSE) ;
return is ;
}
void RooAbsArg::printAttribList(ostream& os) const
{
TIterator *attribIter= _attribList.MakeIterator();
TObjString* attrib ;
Bool_t first(kTRUE) ;
while ((attrib=(TObjString*)attribIter->Next())) {
os << (first?" [":",") << attrib->String() ;
first=kFALSE ;
}
if (!first) os << "] " ;
delete attribIter ;
}
void RooAbsArg::attachDataSet(const RooAbsData &data)
{
const RooArgSet* set = data.get() ;
RooArgSet branches ;
branchNodeServerList(&branches) ;
TIterator* iter = branches.createIterator() ;
RooAbsArg* branch ;
while((branch=(RooAbsArg*)iter->Next())) {
branch->redirectServers(*set,kFALSE,kFALSE) ;
}
delete iter ;
}
Int_t RooAbsArg::Compare(const TObject* other) const
{
return strcmp(GetName(),other->GetName()) ;
}
void RooAbsArg::printDirty(Bool_t depth) const
{
if (depth) {
RooArgSet branchList ;
branchNodeServerList(&branchList) ;
TIterator* bIter = branchList.createIterator() ;
RooAbsArg* branch ;
while((branch=(RooAbsArg*)bIter->Next())) {
branch->printDirty(kFALSE) ;
}
} else {
cout << GetName() << " : " ;
switch (_operMode) {
case AClean: cout << "FORCED clean" ; break ;
case ADirty: cout << "FORCED DIRTY" ; break ;
case Auto: cout << "Auto " << (isValueDirty()?"DIRTY":"clean") ;
}
cout << endl ;
}
}
void RooAbsArg::constOptimize(ConstOpCode opcode)
{
TIterator* sIter = serverIterator() ;
RooAbsArg* server ;
while((server=(RooAbsArg*)sIter->Next())) {
server->constOptimize(opcode) ;
}
delete sIter ;
}
void RooAbsArg::setOperMode(OperMode mode, Bool_t recurseADirty)
{
if (mode==_operMode) return ;
_operMode = mode ;
operModeHook() ;
if (mode==ADirty && recurseADirty) {
TIterator* iter = valueClientIterator() ;
RooAbsArg* client ;
while((client=(RooAbsArg*)iter->Next())) {
client->setOperMode(mode) ;
}
delete iter ;
}
}
void RooAbsArg::printCompactTree(const char* indent, const char* filename, const char* namePat)
{
if (filename) {
ofstream ofs(filename) ;
printCompactTree(ofs,indent,namePat) ;
} else {
printCompactTree(cout,indent,namePat) ;
}
}
void RooAbsArg::printCompactTree(ostream& os, const char* indent, const char* namePat)
{
if ( !namePat || TString(GetName()).Contains(namePat)) {
os << indent << this << " " << IsA()->GetName() << "::" << GetName() << " (" << GetTitle() << ") " ;
if (_serverList.GetSize()>0) {
switch(operMode()) {
case Auto: os << " [Auto]" << endl ; break ;
case AClean: os << " [ACLEAN]" << endl ; break ;
case ADirty: os << " [ADIRTY]" << endl ; break ;
}
} else {
os << endl ;
}
printCompactTreeHook(os,indent) ;
}
TString indent2(indent) ;
indent2 += " " ;
TIterator * iter = serverIterator() ;
RooAbsArg* arg ;
while((arg=(RooAbsArg*)iter->Next())) {
arg->printCompactTree(os,indent2,namePat) ;
}
delete iter ;
}
TString RooAbsArg::cleanBranchName() const
{
TString cleanName(GetName()) ;
cleanName.ReplaceAll("/","D") ;
cleanName.ReplaceAll("-","M") ;
cleanName.ReplaceAll("+","P") ;
cleanName.ReplaceAll("*","X") ;
cleanName.ReplaceAll("[","L") ;
cleanName.ReplaceAll("]","R") ;
cleanName.ReplaceAll("(","L") ;
cleanName.ReplaceAll(")","R") ;
cleanName.ReplaceAll("{","L") ;
cleanName.ReplaceAll("}","R") ;
if (cleanName.Length()<=60) return cleanName ;
static char buf[1024] ;
strcpy(buf,cleanName.Data()) ;
sprintf(buf+46,"_CRC%08x",crc32(cleanName.Data())) ;
return TString(buf) ;
}
UInt_t RooAbsArg::crc32(const char* data) const
{
Int_t len = strlen(data) ;
if (len<4) {
cout << "RooAbsReal::crc32 cannot calculate checksum of less than 4 bytes of data" << endl ;
return 0 ;
}
static Bool_t init(kFALSE) ;
static unsigned int crctab[256];
if (!init) {
int i, j;
unsigned int crc;
for (i = 0; i < 256; i++){
crc = i << 24;
for (j = 0; j < 8; j++) {
if (crc & 0x80000000) {
crc = (crc << 1) ^ 0x04c11db7 ;
} else {
crc = crc << 1;
}
}
crctab[i] = crc;
}
init = kTRUE ;
}
unsigned int result(0);
int i(0);
result = *data++ << 24;
result |= *data++ << 16;
result |= *data++ << 8;
result |= *data++;
result = ~ result;
len -=4;
for (i=0; i<len; i++) {
result = (result << 8 | *data++) ^ crctab[result >> 24];
}
return ~result;
}
void RooAbsArg::printCompactTreeHook(ostream&, const char *)
{
}
RooArgSet* RooAbsArg::getVariables() const
{
return getParameters(RooArgSet()) ;
}
RooLinkedList RooAbsArg::getCloningAncestors() const
{
RooLinkedList retVal ;
TIterator* iter = attribIterator() ;
TObjString* attrib ;
while((attrib=(TObjString*)iter->Next())) {
if (attrib->String().BeginsWith("CloneOf(")) {
char buf[128] ;
strcpy(buf,attrib->String().Data()) ;
strtok(buf,"(") ;
char* ptrToken = strtok(0,")") ;
RooAbsArg* ptr = (RooAbsArg*) strtol(ptrToken,0,16) ;
retVal.Add(ptr) ;
}
}
delete iter ;
return retVal ;
}
ROOT page - Class index - Class Hierarchy - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.