Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RooListProxy.cxx
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * @(#)root/roofitcore:$Id$
5 * Authors: *
6 * WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
7 * DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
8 * *
9 * Copyright (c) 2000-2005, Regents of the University of California *
10 * and Stanford University. All rights reserved. *
11 * *
12 * Redistribution and use in source and binary forms, *
13 * with or without modification, are permitted according to the terms *
14 * listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
15 *****************************************************************************/
16
17/**
18\file RooListProxy.cxx
19\class RooListProxy
20\ingroup Roofitcore
21
22RooListProxy is the concrete proxy for RooArgList objects.
23A RooListProxy is the only safe mechanism to store a RooArgList
24with RooAbsArg contents in another RooAbsArg.
25The list proxy has the semantic of a RooArgList but also
26takes care of all bookkeeping required when composite objects
27are clone and client-server links need to be redirected.
28**/
29
30
31#include "RooFit.h"
32#include "Riostream.h"
33
34#include "RooListProxy.h"
35#include "RooArgList.h"
36#include "RooAbsArg.h"
37
38using namespace std;
39
41;
42
43
44
45////////////////////////////////////////////////////////////////////////////////
46/// Constructor with proxy name, description and pointer to ownder of
47/// the RooListProxy. The default strategy for value/shape dirty flag
48/// propagation of the list contents to the list owner is controlled
49/// by the defValueServer and defShapeServer flags.
50
51RooListProxy::RooListProxy(const char* inName, const char* /*desc*/, RooAbsArg* owner,
52 Bool_t defValueServer, Bool_t defShapeServer) :
53 RooArgList(inName), _owner(owner),
54 _defValueServer(defValueServer),
55 _defShapeServer(defShapeServer)
56{
57 _owner->registerProxy(*this) ;
58}
59
60
61
62////////////////////////////////////////////////////////////////////////////////
63/// Copy constructor with name of proxy, pointer to owner of this proxy and
64/// reference to list proxy to be copied
65
66RooListProxy::RooListProxy(const char* inName, RooAbsArg* owner, const RooListProxy& other) :
67 RooArgList(other,inName), _owner(owner),
68 _defValueServer(other._defValueServer),
69 _defShapeServer(other._defShapeServer)
70{
71 _owner->registerProxy(*this) ;
72}
73
74
75
76////////////////////////////////////////////////////////////////////////////////
77/// Destructor
78
80{
81 if (_owner) _owner->unRegisterProxy(*this) ;
82}
83
84
85
86////////////////////////////////////////////////////////////////////////////////
87/// Add object to list with explicitl directives on value and shape dirty flag propagation
88/// of inserted object to list owner
89
90Bool_t RooListProxy::add(const RooAbsArg& var, Bool_t valueServer, Bool_t shapeServer, Bool_t silent)
91{
92 Bool_t ret=RooArgList::add(var,silent) ;
93 if (ret && _owner) {
94 _owner->addServer((RooAbsArg&)var,valueServer,shapeServer) ;
95 }
96 return ret ;
97}
98
99
100
101////////////////////////////////////////////////////////////////////////////////
102/// Reimplementation of standard RooArgList::add()
103
105{
106 return add(var,_defValueServer,_defShapeServer,silent) ;
107}
108
109
110
111////////////////////////////////////////////////////////////////////////////////
112/// Reimplementation of standard RooArgList::addOwned()
113
115{
116 Bool_t ret=RooArgList::addOwned(var,silent) ;
117 if (ret) {
119 }
120 return ret ;
121}
122
123
124////////////////////////////////////////////////////////////////////////////////
125/// Reimplementation of standard RooArgList::replace()
126
128{
129 Bool_t ret=RooArgList::replace(var1,var2) ;
130 if (ret) {
131 _owner->removeServer((RooAbsArg&)var1) ;
133 _owner->isShapeServer(var2)) ;
134 }
135 return ret ;
136}
137
138
139
140////////////////////////////////////////////////////////////////////////////////
141/// Reimplementation of standard RooArgList::remove()
142
143Bool_t RooListProxy::remove(const RooAbsArg& var, Bool_t silent, Bool_t matchByNameOnly)
144{
145 Bool_t ret=RooArgList::remove(var,silent,matchByNameOnly) ;
146 if (ret) {
148 }
149 return ret ;
150}
151
152
153
154////////////////////////////////////////////////////////////////////////////////
155/// Reimplementation of standard RooArgList::removeAll()
156
158{
159 RooFIter iter = fwdIterator();
160 RooAbsArg* arg ;
161 while ((arg=(RooAbsArg*)iter.next())) {
162 _owner->removeServer(*arg) ;
163 }
164
166}
167
168
169
170
171////////////////////////////////////////////////////////////////////////////////
172/// Reimplementation of standard RooArgList assignment operator
173
175{
176 RooArgList::operator=(other) ;
177 return *this ;
178}
179
180
181
182
183////////////////////////////////////////////////////////////////////////////////
184/// Internal function that implements consequences of a server redirect on the
185/// owner. If the list contains any element with names identical to those in newServerList
186/// replace them with the instance in newServerList
187
188Bool_t RooListProxy::changePointer(const RooAbsCollection& newServerList, Bool_t nameChange, Bool_t factoryInitMode)
189{
190 if (getSize()==0) {
191 if (factoryInitMode) {
192 RooFIter iter = newServerList.fwdIterator() ;
193 RooAbsArg* arg ;
194 while((arg=(RooAbsArg*)iter.next())) {
195 if (arg!=_owner) {
196 add(*arg,kTRUE) ;
197 }
198 }
199 } else {
200 return kTRUE ;
201 }
202 }
203 RooFIter iter = fwdIterator();
204 RooAbsArg* arg ;
205 Bool_t error(kFALSE) ;
206 while ((arg=(RooAbsArg*)iter.next())) {
207
208 RooAbsArg* newArg= arg->findNewServer(newServerList, nameChange);
209 if (newArg && newArg!=_owner) error |= !RooArgList::replace(*arg,*newArg) ;
210 }
211 return !error ;
212}
213
214
215
216////////////////////////////////////////////////////////////////////////////////
217/// Print the name of the proxy, and if requested a summary of
218/// the contained elements as well
219
220void RooListProxy::print(ostream& os, Bool_t addContents) const
221{
222 if (!addContents) {
223 os << name() << "=" ; printStream(os,kValue,kInline) ;
224 } else {
225 os << name() << "=(" ;
226 RooFIter iter = fwdIterator() ;
227 RooAbsArg* arg ;
228 Bool_t first2(kTRUE) ;
229 while ((arg=(RooAbsArg*)iter.next())) {
230 if (first2) {
231 first2 = kFALSE ;
232 } else {
233 os << "," ;
234 }
236 }
237 os << ")" ;
238 }
239}
const Bool_t kFALSE
Definition RtypesCore.h:101
const Bool_t kTRUE
Definition RtypesCore.h:100
#define ClassImp(name)
Definition Rtypes.h:364
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition RooAbsArg.h:69
Bool_t isValueServer(const RooAbsArg &arg) const
Check if this is serving values to arg.
Definition RooAbsArg.h:213
void registerProxy(RooArgProxy &proxy)
Register an RooArgProxy in the proxy list.
Bool_t isShapeServer(const RooAbsArg &arg) const
Check if this is serving shape to arg.
Definition RooAbsArg.h:221
void unRegisterProxy(RooArgProxy &proxy)
Remove proxy from proxy list.
void addServer(RooAbsArg &server, Bool_t valueProp=kTRUE, Bool_t shapeProp=kFALSE, std::size_t refCount=1)
Register another RooAbsArg as a server to us, ie, declare that we depend on it.
void removeServer(RooAbsArg &server, Bool_t force=kFALSE)
Unregister another RooAbsArg as a server to us, ie, declare that we no longer depend on its value and...
RooAbsArg * findNewServer(const RooAbsCollection &newSet, Bool_t nameChange) const
Find the new server in the specified set that matches the old server.
RooAbsCollection is an abstract container object that can hold multiple RooAbsArg objects.
virtual void removeAll()
Remove all arguments from our set, deleting them if we own them.
virtual Bool_t replace(const RooAbsArg &var1, const RooAbsArg &var2)
Replace var1 with var2 and return kTRUE for success.
Int_t getSize() const
RooFIter fwdIterator() const
One-time forward iterator.
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
virtual Bool_t addOwned(RooAbsArg &var, Bool_t silent=kFALSE)
Add an argument and transfer the ownership to the collection.
virtual Bool_t remove(const RooAbsArg &var, Bool_t silent=kFALSE, Bool_t matchByNameOnly=kFALSE)
Remove the specified argument from our list.
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition RooArgList.h:22
RooArgList & operator=(const RooArgList &other)
Definition RooArgList.h:106
A one-time forward iterator working on RooLinkedList or RooAbsCollection.
RooAbsArg * next()
Return next element or nullptr if at end.
RooListProxy is the concrete proxy for RooArgList objects.
virtual Bool_t replace(const RooAbsArg &var1, const RooAbsArg &var2) override
Reimplementation of standard RooArgList::replace()
Bool_t _defValueServer
RooListProxy & operator=(const RooArgList &other)
Reimplementation of standard RooArgList assignment operator.
virtual Bool_t addOwned(RooAbsArg &var, Bool_t silent=kFALSE) override
Reimplementation of standard RooArgList::addOwned()
virtual const char * name() const override
virtual ~RooListProxy()
Destructor.
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE) override
Reimplementation of standard RooArgList::add()
virtual Bool_t changePointer(const RooAbsCollection &newServerSet, Bool_t nameChange=kFALSE, Bool_t factoryInitMode=kFALSE) override
Internal function that implements consequences of a server redirect on the owner.
virtual void removeAll() override
Reimplementation of standard RooArgList::removeAll()
virtual void print(std::ostream &os, Bool_t addContents=kFALSE) const override
Print the name of the proxy, and if requested a summary of the contained elements as well.
Bool_t _defShapeServer
RooAbsArg * _owner
virtual Bool_t remove(const RooAbsArg &var, Bool_t silent=kFALSE, Bool_t matchByNameOnly=kFALSE) override
Reimplementation of standard RooArgList::remove()
virtual void printStream(std::ostream &os, Int_t contents, StyleOption style, TString indent="") const
Print description of object on ostream, printing contents set by contents integer,...