class RooFactoryWSTool: public TNamed, public RooPrintable

 Default constructor

 Destructor

 Low-level factory interface for creating a RooRealVar with a given range and initial value

 Low-level factory interface for creating a RooCategory with a given list of state names. The State name list
 can be of the form 'name1,name2,name3' or of the form 'name1=id1,name2=id2,name3=id3'

 Low-level factory interface for creating a RooAbsPdf of a given class with a given list of input variables
 The variable list varList should be of the form "a,b,c" where the interpretation of the argument is
 dependent on the p.d.f. Set and List arguments can be passed by substituting a single argument with
 the form (a,b,c), i.e. one can set varList to "x,(a0,a1,a2)" to pass a RooAbsReal and a RooArgSet as arguments.

 Process high-level object creation syntax
 Accepted forms of syntax are


 Creating variables

 x[-10,10]             -  Create variable x with given range and put it in workspace
 x[3,-10,10]           -  Create variable x with given range and initial value and put it in workspace
 x[3]                  -  Create variable x with given constant value

 <numeric literal>     - Numeric literal expressions (0.5, -3 etc..) are converted to a RooConst(<numeric literal>)
                         where ever a RooAbsReal or RooAbsArg argument is expected

 Creating categories

 c[lep,kao,nt1,nt2]    -  Create category c with given state names
 tag[B0=1,B0bar=-1]    -  Create category tag with given state names and index assignments


 Creating functions and p.d.f.s

 MyPdf::g(x,m,s)       - Create p.d.f or function of type MyPdf with name g with argument x,m,s
                         Interpretation and number of arguments are mapped to the constructor arguments of the class
                         (after the name and title).

 MyPdf(x,m,s)          - As above, but with an implicitly defined (unique) object name


 Creating sets and lists (to be used as inputs above)

 {a,b,c}               - Create RooArgSet or RooArgList (as determined by context) from given contents



 Objects that are not created, are assumed to exist in the workspace
 Object creation expressions as shown above can be nested, e.g. one can do

   RooGaussian::g(x[-10,10],m[0],3)

 to create a p.d.f and its variables in one go. This nesting can be applied recursively e.g.

   SUM::model( f[0.5,0,1] * RooGaussian::g( x[-10,10], m[0], 3] ),
                            RooChebychev::c( x, {a0[0.1],a1[0.2],a2[-0.3]} ))

 creates the sum of a Gaussian and a Chebychev and all its variables


 A seperate series of operator meta-type exists to simplify the construction of composite expressions
 meta-types in all capitals (SUM) create p.d.f.s, meta types in lower case (sum) create
 functions.


 SUM::name(f1*pdf1,f2*pdf2,pdf3]  -- Create sum p.d.f name with value f1*pdf1+f2*pdf2+(1-f1-f2)*pdf3
 RSUM::name(f1*pdf1,f2*pdf2,pdf3] -- Create recursive sum p.d.f. name with value f1*pdf1 + (1-f1)(f2*pdf2 + (1-f2)pdf3)
 ASUM::name(f1*amp1,f2*amp2,amp3] -- Create sum p.d.f. name with value f1*amp1+f2*amp2+(1-f1-f2)*amp3 where amplX are amplitudes of type RooAbsReal
 sum::name(a1,a2,a3]              -- Create sum function with value a1+a2+a3
 sum::name(a1*b1,a2*b2,a3*b 3]    -- Create sum function with value a1*b1+a2*b2+a3*b3

 PROD::name(pdf1,pdf2]            -- Create product of p.d.f with 'name' with given input p.d.fs
 PROD::name(pdf1|x,pdf2]          -- Create product of conditional p.d.f. pdf1 given x and pdf2
 prod::name(a,b,c]                -- Create production function with value a*b*c

 SIMUL::name(cat,a=pdf1,b=pdf2]   -- Create simultaneous p.d.f index category cat. Make pdf1 to state a, pdf2 to state b

 EXPR::name('expr',var,...]       -- Create an generic p.d.f that interprets the given expression
 expr::name('expr',var,...]       -- Create an generic function that interprets the given expression


 The functionality of high level object creation tools like RooSimWSTool, RooCustomizer and RooClassFactory
 is also interfaced through meta-types in the factory


 Interface to RooSimWSTool

 SIMCLONE::name( modelPdf, $ParamSplit(...),
                 $ParamSplitConstrained(...), $Restrict(...) ]            -- Clone-and-customize modelPdf according to ParamSplit and ParamSplitConstrained()
                                                                             specifications and return a RooSimultaneous p.d.f. of all built clones

 MSIMCLONE::name( masterIndex,
                  $AddPdf(mstate1, modelPdf1, $ParamSplit(...)),
                  $AddPdf(mstate2,modelPdf2),...) ]                       -- Clone-and-customize multiple models (modelPdf1,modelPdf2) according to ParamSplit and
                                                                             ParamSplitConstrained() specifications and return a RooSimultaneous p.d.f. of all built clones,
                                                                             using the specified master index to map prototype p.d.f.s to master states
 Interface to RooCustomizer

 EDIT::name( orig, substNode=origNode), ... ]                             -- Create a clone of input object orig, with the specified replacements operations executed
 EDIT::name( orig, origNode=$REMOVE(), ... ]                              -- Create clone of input removing term origNode from all PROD() terms that contained it
 EDIT::name( orig, origNode=$REMOVE(prodname,...), ... ]                  -- As above, but restrict removal of origNode to PROD term(s) prodname,...


 Interface to RooClassFactory

 CEXPR::name('expr',var,...]       -- Create an custom compiled p.d.f that evaluates the given expression
 cexpr::name('expr',var,...]       -- Create an custom compiled function that evaluates the given expression


 $MetaType(...)        - Meta argument that does not result in construction of an object but is used logically organize
                         input arguments in certain operator p.d.f. constructions. The defined meta arguments are context dependent.

                         The only meta argument that is defined globally is $Alias(typeName,aliasName) to
                         define aliases for type names. For the definition of meta arguments in operator p.d.f.s
                         see the definitions below

 Process a single high-level expression or list of
 expressions. The returned string a the reduced expression where
 all inline object creations have been executed and substituted
 with the name of the created object

 e.g. 'RooGaussian::g(x,m,s)' --> 'g'
      '{x(-10,10),s}          --> '{x,s}'

 Process a single composite expression

 e.g. 'A=RooGaussian::g[x,m,s]' --> 'A=g'
 e.g. 'f[0,1]*RooGaussian::g[x,m,s]' --> 'f*g'
 e.g. 'RooGaussian::g(x,y,s)|x' --> g|x'
 e.g. '$MetaArg(RooGaussian::g[x,m,s],blah)' --> '$MetaArg(g,blah)'

 Process a single high-level expression. The returned string a the reduced
 expression where all inline object creations have been executed and substituted
 with the name of the created object

 e.g. 'RooGaussian::g(x,m,s)' --> 'g'
 e.g. 'x[-10,10]' --> 'x'

 Process a list of high-level expression. The returned string a the reduced
 expression list where all inline object creations have been executed and substituted
 with the name of the created object

 E.g.   '{x(-10,10),s}  --> '{x,s}'

 Parse token

 Glue function between high-level syntax and low-level factory call to createVariable:
 Process a parsed call to create a variable named 'func'

 If initial token is non-numeric, a RooCategory will be created, and the args are interpreted
 as either state names or 'name=id' assignments. Otherwise a RooRealvar is created and the
 arg list is interpreted as follows:
 If list has two args, these are interpreted as xmin,xmax
 If list has three args, these are interpreted as xinit,xmin,xmax
 If list has one arg, this is interpreted as xinit and the variable is set as constant

 Glue function between high-level syntax and low-level factory call to createArg:
 Process a parsed call to create a p.d.f named func

 The func arg is interpreted as ClassName::ObjectName and the arglist is passed
 verbatim to createArg. The received arglist is expected to be fully reduced (i.e.
 all inline object creations must have been compiled)

 Concatenate list of args into comma separated string

 Allocate and fill work buffer

 Perform basic syntax on given factory expression. If function returns
 true syntax errors are found.

 CINT constructor interface, return constructor string argument #idx as RooAbsArg reference found in workspace

 CINT constructor interface, return constructor string argument #idx as RooAbsReal reference found in workspace

 CINT constructor interface, return constructor string argument #idx as RooAbsRealLValue reference found in workspace

 CINT constructor interface, return constructor string argument #idx as RooRealVar reference found in workspace

 CINT constructor interface, return constructor string argument #idx as RooAbsPdf reference found in workspace

 CINT constructor interface, return constructor string argument #idx as RooResolutionModel reference found in workspace

 CINT constructor interface, return constructor string argument #idx as RooAbsCategory reference found in workspace

 CINT constructor interface, return constructor string argument #idx as RooAbsCategoryLValue reference found in workspace

 CINT constructor interface, return constructor string argument #idx as RooCategory reference found in workspace

 CINT constructor interface, return constructor string argument #idx as RooArgSet of objects found in workspace

 CINT constructor interface, return constructor string argument #idx as RooArgList of objects found in workspace

 CINT constructor interface, return constructor string argument #idx as RooAbsData object found in workspace

 CINT constructor interface, return constructor string argument #idx as RooDataHist object found in workspace

 CINT constructor interface, return constructor string argument #idx as RooDataSet object found in workspace

 CINT constructor interface, return constructor string argument #idx as const char*

 CINT constructor interface, return constructor string argument #idx as Int_t

 CINT constructor interface, return constructor string argument #idx as Double_t

 Register foreign special objects in factory

 Constructors, assignment etc

 --- Internal stuff that must be public so that CINT can access it ---
 CINT constructor interface

 Hooks for other tools