HypoTestInverterResult.h   HypoTestInverterResult.h 
skipping to change at line 47 skipping to change at line 47
HypoTestInverterResult( const HypoTestInverterResult& other, const char* name ); HypoTestInverterResult( const HypoTestInverterResult& other, const char* name );
// destructor // destructor
virtual ~HypoTestInverterResult(); virtual ~HypoTestInverterResult();
// operator = // operator =
HypoTestInverterResult& operator = (const HypoTestInverterResult& other) ; HypoTestInverterResult& operator = (const HypoTestInverterResult& other) ;
// remove points that appear to have failed. // remove points that appear to have failed.
void ExclusionCleanup(); int ExclusionCleanup();
// merge with the content of another HypoTestInverterResult object // merge with the content of another HypoTestInverterResult object
bool Add( const HypoTestInverterResult& otherResult ); bool Add( const HypoTestInverterResult& otherResult );
//add the result of a single point (an HypoTestRsult) //add the result of a single point (an HypoTestRsult)
bool Add( Double_t x, const HypoTestResult & result ); bool Add( Double_t x, const HypoTestResult & result );
// function to return the value of the parameter of interest for the i^t h entry in the results // function to return the value of the parameter of interest for the i^t h entry in the results
double GetXValue( int index ) const ; double GetXValue( int index ) const ;
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 RVersion.h   RVersion.h 
skipping to change at line 17 skipping to change at line 17
* These macros can be used in the following way: * These macros can be used in the following way:
* *
* #if ROOT_VERSION_CODE >= ROOT_VERSION(2,23,4) * #if ROOT_VERSION_CODE >= ROOT_VERSION(2,23,4)
* #include <newheader.h> * #include <newheader.h>
* #else * #else
* #include <oldheader.h> * #include <oldheader.h>
* #endif * #endif
* *
*/ */
#define ROOT_RELEASE "5.34/12" #define ROOT_RELEASE "5.34/13"
#define ROOT_RELEASE_DATE "Nov 16 2013" #define ROOT_RELEASE_DATE "Nov 30 2013"
#define ROOT_RELEASE_TIME "16:33:37" #define ROOT_RELEASE_TIME "23:01:20"
#define ROOT_SVN_REVISION 49361 #define ROOT_SVN_REVISION 49361
#define ROOT_GIT_COMMIT "v5-34-11-49-gafa5f25" #define ROOT_GIT_COMMIT "v5-34-12-50-g2a9389b"
#define ROOT_GIT_BRANCH "heads/v5-34-00-patches" #define ROOT_GIT_BRANCH "heads/v5-34-00-patches"
#define ROOT_VERSION_CODE 336396 #define ROOT_VERSION_CODE 336397
#define ROOT_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c)) #define ROOT_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
#endif #endif
 End of changes. 3 change blocks. 
5 lines changed or deleted 5 lines changed or added


 RooTrace.h   RooTrace.h 
skipping to change at line 20 skipping to change at line 20
* and Stanford University. All rights reserved. * * and Stanford University. All rights reserved. *
* * * *
* Redistribution and use in source and binary forms, * * Redistribution and use in source and binary forms, *
* with or without modification, are permitted according to the terms * * with or without modification, are permitted according to the terms *
* listed in LICENSE (http://roofit.sourceforge.net/license.txt) * * listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
************************************************************************** ***/ ************************************************************************** ***/
#ifndef ROO_TRACE #ifndef ROO_TRACE
#define ROO_TRACE #define ROO_TRACE
#include <assert.h> #include <assert.h>
#include <map>
#include "Riosfwd.h" #include "Riosfwd.h"
#include "RooLinkedList.h" #include "RooLinkedList.h"
#ifndef __CINT__
#define TRACE_CREATE RooTrace::create(this);
#define TRACE_DESTROY RooTrace::destroy(this);
#endif
class RooTrace { class RooTrace {
public: public:
virtual ~RooTrace() {} ; virtual ~RooTrace() {} ;
static void create(const TObject* obj) ; static void create(const TObject* obj) ;
static void destroy(const TObject* obj) ; static void destroy(const TObject* obj) ;
static void createSpecial(const char* name, int size) ;
static void destroySpecial(const char* name) ;
static void active(Bool_t flag) ; static void active(Bool_t flag) ;
static void verbose(Bool_t flag) ; static void verbose(Bool_t flag) ;
static void dump() ; static void dump() ;
static void dump(std::ostream& os, Bool_t sinceMarked=kFALSE) ; static void dump(std::ostream& os, Bool_t sinceMarked=kFALSE) ;
static void mark() ; static void mark() ;
static void printObjectCounts() ;
static void callgrind_zero() ; static void callgrind_zero() ;
static void callgrind_dump() ; static void callgrind_dump() ;
protected: protected:
static void create2(const TObject* obj) ; static void create2(const TObject* obj) ;
static void destroy2(const TObject* obj) ; static void destroy2(const TObject* obj) ;
static void create3(const TObject* obj) ;
static void destroy3(const TObject* obj) ;
void addPad(const TObject* ref, Bool_t doPad) ; void addPad(const TObject* ref, Bool_t doPad) ;
Bool_t removePad(const TObject* ref) ; Bool_t removePad(const TObject* ref) ;
static Bool_t _active ; static Bool_t _active ;
static Bool_t _verbose ; static Bool_t _verbose ;
static RooLinkedList _list ; static RooLinkedList _list ;
static RooLinkedList _markList ; static RooLinkedList _markList ;
static std::map<TClass*,int> _objectCount ;
static std::map<std::string,int> _specialCount ;
static std::map<std::string,int> _specialSize ;
ClassDef(RooTrace,0) // Memory tracer utility for RooFit objects ClassDef(RooTrace,0) // Memory tracer utility for RooFit objects
}; };
#endif #endif
 End of changes. 6 change blocks. 
0 lines changed or deleted 19 lines changed or added


 RootFinder.h   RootFinder.h 
// @(#)root/tmva $Id$ // @(#)root/mathmore:$Id$
// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss // Authors: L. Moneta, A. Zsenei 08/2005
/************************************************************************** /**********************************************************************
******** * *
* Project: TMVA - a Root-integrated toolkit for multivariate data analysis * Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
* * *
* Package: TMVA * This library is free software; you can redistribute it and/or *
* * modify it under the terms of the GNU General Public License *
* Class : RootFinder * as published by the Free Software Foundation; either version 2 *
* * of the License, or (at your option) any later version. *
* Web : http://tmva.sourceforge.net * *
* * This library is distributed in the hope that it will be useful, *
* * but WITHOUT ANY WARRANTY; without even the implied warranty of *
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Description: * General Public License for more details. *
* * *
* Root finding using Brents algorithm * You should have received a copy of the GNU General Public License *
* * along with this library (see file COPYING); if not, write *
* (translated from CERNLIB function RZERO) * to the Free Software Foundation, Inc., 59 Temple Place, Suite *
* * 330, Boston, MA 02111-1307 USA, or contact the author. *
* * *
* **********************************************************************/
* Authors (alphabetical):
* // Header file for class RootFinder
* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland //
* // Created by: moneta at Sun Nov 14 16:59:55 2004
* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, German //
y * // Last update: Sun Nov 14 16:59:55 2004
* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada //
* #ifndef ROOT_Math_RootFinder
* #define ROOT_Math_RootFinder
*
* Copyright (c) 2005:
*
* CERN, Switzerland
*
* U. of Victoria, Canada
*
* MPI-K Heidelberg, Germany
*
*
*
* Redistribution and use in source and binary forms, with or without
*
* modification, are permitted according to the terms listed in LICENSE
*
* (http://tmva.sourceforge.net/LICENSE)
*
**************************************************************************
********/
#ifndef ROOT_TMVA_RootFinder
#define ROOT_TMVA_RootFinder
//////////////////////////////////////////////////////////////////////////
// //
// RootFinder //
// //
// Root finding using Brents algorithm //
// (translated from CERNLIB function RZERO) //
// //
//////////////////////////////////////////////////////////////////////////
#ifndef ROOT_TObject #ifndef ROOT_Math_IFunctionfwd
#include "TObject.h" #include "Math/IFunctionfwd.h"
#endif #endif
namespace TMVA { #ifndef ROOT_Math_IRootFinderMethod
#include "Math/IRootFinderMethod.h"
class MsgLogger; #endif
class RootFinder : public TObject {
public:
RootFinder( Double_t (*rootVal)( Double_t ),
Double_t rootMin, Double_t rootMax,
Int_t maxIterations = 100,
Double_t absTolerance = 0.0 );
virtual ~RootFinder( void );
// returns the root of the function
Double_t Root( Double_t refValue );
private: /**
@defgroup RootFinders One-dimensional Root-Finding algorithms
Various implementation esists in MathCore and MathMore
The user interacts with a proxy class ROOT::Math::RootFinder which creat
es behing
the chosen algorithms which are implemented using the ROOT::Math::IRootF
inderMethod interface
@ingroup NumAlgo
*/
namespace ROOT {
namespace Math {
//_________________________________________________________________________
____________
/**
User Class to find the Root of one dimensional functions.
The GSL Methods are implemented in MathMore and they are loaded au
tomatically
via the plug-in manager
The possible types of Root-finding algorithms are:
<ul>
<li>Root Bracketing Algorithms which do not require function deriv
atives
<ol>
<li>RootFinder::kBRENT (default method implemented in MathCore)
<li>RootFinder::kGSL_BISECTION
<li>RootFinder::kGSL_FALSE_POS
<li>RootFinder::kGSL_BRENT
</ol>
<li>Root Finding Algorithms using Derivatives
<ol>
<li>RootFinder::kGSL_NEWTON
<li>RootFinder::kGSL_SECANT
<li>RootFinder::kGSL_STEFFENSON
</ol>
</ul>
This class does not cupport copying
@ingroup RootFinders
*/
class RootFinder {
public:
enum EType { kBRENT, // Methods
from MathCore
kGSL_BISECTION, kGSL_FALSE_POS, kGSL_BRENT, // GSL Nor
mal
kGSL_NEWTON, kGSL_SECANT, kGSL_STEFFENSON // GSL Der
ivatives
};
/**
Construct a Root-Finder algorithm
*/
RootFinder(RootFinder::EType type = RootFinder::kBRENT);
virtual ~RootFinder();
private:
// usually copying is non trivial, so we make this unaccessible
RootFinder(const RootFinder & ) {}
RootFinder & operator = (const RootFinder & rhs)
{
if (this == &rhs) return *this; // time saving self-test
return *this;
}
public:
bool SetMethod(RootFinder::EType type = RootFinder::kBRENT);
/**
Provide to the solver the function and the initial search inter
val [xlow, xup]
for algorithms not using derivatives (bracketing algorithms)
The templated function f must be of a type implementing the \a
operator() method,
<em> double operator() ( double x ) </em>
Returns non zero if interval is not valid (i.e. does not contai
ns a root)
*/
bool SetFunction( const IGenFunction & f, double xlow, double xup)
{
return fSolver->SetFunction( f, xlow, xup);
}
/**
Provide to the solver the function and an initial estimate of t
he root,
for algorithms using derivatives.
The templated function f must be of a type implementing the \a
operator()
and the \a Gradient() methods.
<em> double operator() ( double x ) </em>
Returns non zero if starting point is not valid
*/
bool SetFunction( const IGradFunction & f, double xstart) {
return fSolver->SetFunction( f, xstart);
}
template<class Function, class Derivative>
bool Solve(Function &f, Derivative &d, double start,
int maxIter = 100, double absTol = 1E-8, double relTol =
1E-10);
template<class Function>
bool Solve(Function &f, double min, double max,
int maxIter = 100, double absTol = 1E-8, double relTol =
1E-10);
/**
Compute the roots iterating until the estimate of the Root is
within the required tolerance returning
the iteration Status
*/
bool Solve( int maxIter = 100, double absTol = 1E-8, double relTol
= 1E-10) {
return fSolver->Solve( maxIter, absTol, relTol );
}
/**
Return the number of iteration performed to find the Root.
*/
int Iterations() const {
return fSolver->Iterations();
}
/**
Perform a single iteration and return the Status
*/
int Iterate() {
return fSolver->Iterate();
}
/**
Return the current and latest estimate of the Root
*/
double Root() const {
return fSolver->Root();
}
/**
Return the status of the last estimate of the Root
= 0 OK, not zero failure
*/
int Status() const {
return fSolver->Status();
}
/**
Return the current and latest estimate of the lower value of th
e Root-finding interval (for bracketing algorithms)
*/
/* double XLower() const { */
/* return fSolver->XLower(); */
/* } */
/**
Return the current and latest estimate of the upper value of th
e Root-finding interval (for bracketing algorithms)
*/
/* double XUpper() const { */
/* return fSolver->XUpper(); */
/* } */
/**
Get Name of the Root-finding solver algorithm
*/
const char * Name() const {
return fSolver->Name();
}
protected:
private:
IRootFinderMethod* fSolver; // type of algorithm to be used
Double_t fRootMin; // minimum root value };
Double_t fRootMax; // maximum root value
Int_t fMaxIter; // maximum number of iterations
Double_t fAbsTol; // absolute tolerance deviation
// function pointer } // namespace Math
Double_t (*fGetRootVal)( Double_t ); } // namespace ROOT
mutable MsgLogger* fLogger; //! message logger #ifndef ROOT_Math_WrappedFunction
MsgLogger& Log() const { return *fLogger; } #include "Math/WrappedFunction.h"
#endif
ClassDef(RootFinder,0) // Root finding using Brents algorithm #ifndef ROOT_Math_Functor
}; #include "Math/Functor.h"
#endif
} // namespace TMVA template<class Function, class Derivative>
bool ROOT::Math::RootFinder::Solve(Function &f, Derivative &d, double start
,
int maxIter, double absTol, double relTol
)
{
if (!fSolver) return false;
ROOT::Math::GradFunctor1D wf(f, d);
bool ret = fSolver->SetFunction(wf, start);
if (!ret) return false;
return Solve(maxIter, absTol, relTol);
}
template<class Function>
bool ROOT::Math::RootFinder::Solve(Function &f, double min, double max,
int maxIter, double absTol, double relTol
)
{
if (!fSolver) return false;
ROOT::Math::WrappedFunction<Function &> wf(f);
bool ret = fSolver->SetFunction(wf, min, max);
if (!ret) return false;
return Solve(maxIter, absTol, relTol);
}
#endif #endif /* ROOT_Math_RootFinder */
 End of changes. 11 change blocks. 
92 lines changed or deleted 254 lines changed or added


 TClassAttributeMap.h   TClassAttributeMap.h 
skipping to change at line 37 skipping to change at line 37
#include "THashTable.h" #include "THashTable.h"
#endif #endif
class TClassAttributeMap : public TObject class TClassAttributeMap : public TObject
{ {
public: public:
TClassAttributeMap(); TClassAttributeMap();
virtual ~TClassAttributeMap(); virtual ~TClassAttributeMap();
void AddProperty(const char* key, Int_t value);
void AddProperty(const char* key, const char* value); void AddProperty(const char* key, const char* value);
Bool_t HasKey(const char* key) const; Bool_t HasKey(const char* key) const;
const char *GetPropertyAsString(const char* key) const; const char *GetPropertyAsString(const char* key) const;
Int_t GetPropertyAsInt(const char* key) const; Int_t GetPropertySize() const { return fStringProperty.GetSize();
Int_t GetPropertySize() const; }
Int_t RemovePropertyInt(const char* key);
TString RemovePropertyString(const char* key); TString RemovePropertyString(const char* key);
Bool_t RemoveProperty(const char* key); Bool_t RemoveProperty(const char* key);
void Clear(Option_t* option = ""); void Clear(Option_t* option = "");
private: private:
THashTable fStringProperty; //all properties of String type THashTable fStringProperty; //all properties of String type
THashTable fIntProperty; //all properties of Int type
ClassDef(TClassAttributeMap,1) // Container for name/value pairs of TCl ass attributes ClassDef(TClassAttributeMap,1) // Container for name/value pairs of TCl ass attributes
}; };
#endif // ROOT_TClassAttributeMap #endif // ROOT_TClassAttributeMap
 End of changes. 3 change blocks. 
5 lines changed or deleted 2 lines changed or added


 TClassEdit.h   TClassEdit.h 
skipping to change at line 20 skipping to change at line 20
* For the list of contributors see $ROOTSYS/README/CREDITS. * * For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/ *************************************************************************/
#ifndef ROOT_TClassEdit #ifndef ROOT_TClassEdit
#define ROOT_TClassEdit #define ROOT_TClassEdit
#include "RConfig.h" #include "RConfig.h"
#include <string> #include <string>
#include <vector> #include <vector>
#ifndef ROOT_ESTLType
#include "ESTLType.h"
#endif
#ifdef R__OLDHPACC #ifdef R__OLDHPACC
namespace std { namespace std {
using ::string; using ::string;
using ::vector; using ::vector;
} }
#endif #endif
// TClassEdit is used to manipulate class and type names. // TClassEdit is used to manipulate class and type names.
// //
// This class does not dependent on any other ROOT facility // This class does not dependent on any other ROOT facility
skipping to change at line 49 skipping to change at line 53
kInnerClass = 1<<3, kInnerClass = 1<<3,
kInnedMostClass = 1<<4, kInnedMostClass = 1<<4,
kDropStlDefault = 1<<5, /* implies kDropDefaultAlloc */ kDropStlDefault = 1<<5, /* implies kDropDefaultAlloc */
kDropComparator = 1<<6, /* if the class has a comparator, drops BOT H the comparator and the Allocator */ kDropComparator = 1<<6, /* if the class has a comparator, drops BOT H the comparator and the Allocator */
kDropAllDefault = 1<<7, /* Drop default template parameter even in non STL classes */ kDropAllDefault = 1<<7, /* Drop default template parameter even in non STL classes */
kLong64 = 1<<8, /* replace all 'long long' with Long64_t. * / kLong64 = 1<<8, /* replace all 'long long' with Long64_t. * /
kDropStd = 1<<9 /* Drop any std:: */ kDropStd = 1<<9 /* Drop any std:: */
}; };
enum ESTLType { enum ESTLType {
kNotSTL = 0, kNotSTL = ROOT::kNotSTL,
kVector = 1, kVector = ROOT::kSTLvector,
kList = 2, kList = ROOT::kSTLlist,
kDeque = 3, kDeque = ROOT::kSTLdeque,
kMap = 4, kMap = ROOT::kSTLmap,
kMultiMap = 5, kMultiMap = ROOT::kSTLmultimap,
kSet = 6, kSet = ROOT::kSTLset,
kMultiSet = 7, kMultiSet = ROOT::kSTLmultiset,
kBitSet = 8, kBitSet = ROOT::kSTLbitset,
kEnd = 9 kEnd = 9
}; };
struct TSplitType { struct TSplitType {
const char *fName; // Original spelling of the name. const char *fName; // Original spelling of the name.
std::vector<std::string> fElements; std::vector<std::string> fElements;
int fNestedLocation; // Stores the location of the tail (nested names ) in nestedLoc (0 indicates no tail). int fNestedLocation; // Stores the location of the tail (nested names ) in nestedLoc (0 indicates no tail).
TSplitType(const char *type2split, EModType mode = TClassEdit::kNone) ; TSplitType(const char *type2split, EModType mode = TClassEdit::kNone) ;
 End of changes. 2 change blocks. 
9 lines changed or deleted 13 lines changed or added


 TDictionary.h   TDictionary.h 
skipping to change at line 59 skipping to change at line 59
typedef void CallFunc_t; typedef void CallFunc_t;
typedef void ClassInfo_t; typedef void ClassInfo_t;
typedef void BaseClassInfo_t; typedef void BaseClassInfo_t;
typedef void DataMemberInfo_t; typedef void DataMemberInfo_t;
typedef void MethodInfo_t; typedef void MethodInfo_t;
typedef void MethodArgInfo_t; typedef void MethodArgInfo_t;
typedef void MethodArgInfo_t; typedef void MethodArgInfo_t;
typedef void TypeInfo_t; typedef void TypeInfo_t;
typedef void TypedefInfo_t; typedef void TypedefInfo_t;
#ifndef ROOT_ESTLType
#include "ESTLType.h"
#endif
enum EProperty { enum EProperty {
kIsClass = G__BIT_ISCLASS, kIsClass = G__BIT_ISCLASS,
kIsStruct = G__BIT_ISSTRUCT, kIsStruct = G__BIT_ISSTRUCT,
kIsUnion = G__BIT_ISUNION, kIsUnion = G__BIT_ISUNION,
kIsEnum = G__BIT_ISENUM, kIsEnum = G__BIT_ISENUM,
kIsNamespace = G__BIT_ISNAMESPACE, kIsNamespace = G__BIT_ISNAMESPACE,
kIsTypedef = G__BIT_ISTYPEDEF, kIsTypedef = G__BIT_ISTYPEDEF,
kIsFundamental = G__BIT_ISFUNDAMENTAL, kIsFundamental = G__BIT_ISFUNDAMENTAL,
kIsAbstract = G__BIT_ISABSTRACT, kIsAbstract = G__BIT_ISABSTRACT,
kIsVirtual = G__BIT_ISVIRTUAL, kIsVirtual = G__BIT_ISVIRTUAL,
skipping to change at line 96 skipping to change at line 100
public: public:
TDictionary() { } TDictionary() { }
TDictionary(const char* name): TNamed(name, "") { } TDictionary(const char* name): TNamed(name, "") { }
virtual ~TDictionary() { } virtual ~TDictionary() { }
virtual Long_t Property() const = 0; virtual Long_t Property() const = 0;
static TDictionary* GetDictionary(const char* name); static TDictionary* GetDictionary(const char* name);
static TDictionary* GetDictionary(const type_info &typeinfo); static TDictionary* GetDictionary(const type_info &typeinfo);
// Type of STL container (returned by IsSTLContainer). // Type of STL container (returned by IsSTLContainer).
enum ESTLType {kNone=0, kVector=1, kList, kDeque, kMap, kMultimap, kSet, enum ESTLType {
kMultiset}; kNone = ROOT::kNotSTL,
kVector = ROOT::kSTLvector,
kList = ROOT::kSTLlist,
kDeque = ROOT::kSTLdeque,
kMap = ROOT::kSTLmap,
kMultimap = ROOT::kSTLmultimap,
kSet = ROOT::kSTLset,
kMultiset = ROOT::kSTLmultiset,
kBitset = ROOT::kSTLbitset
};
ClassDef(TDictionary,0) //ABC defining interface to dictionary ClassDef(TDictionary,0) //ABC defining interface to dictionary
}; };
#endif #endif
 End of changes. 2 change blocks. 
2 lines changed or deleted 15 lines changed or added


 TStreamerElement.h   TStreamerElement.h 
skipping to change at line 27 skipping to change at line 27
// TStreamerElement // // TStreamerElement //
// // // //
// Describe one element (data member) to be Streamed // // Describe one element (data member) to be Streamed //
// // // //
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
#ifndef ROOT_TNamed #ifndef ROOT_TNamed
#include "TNamed.h" #include "TNamed.h"
#endif #endif
#ifndef ROOT_ESTLType
#include "ESTLType.h"
#endif
class TMethodCall; class TMethodCall;
class TClass; class TClass;
class TStreamerBasicType; class TStreamerBasicType;
class TStreamerElement : public TNamed { class TStreamerElement : public TNamed {
private: private:
TStreamerElement(const TStreamerElement &); // Not implemented TStreamerElement(const TStreamerElement &); // Not implemented
TStreamerElement&operator=(const TStreamerElement&); // Not implemented TStreamerElement&operator=(const TStreamerElement&); // Not implemented
skipping to change at line 56 skipping to change at line 60
TString fTypeName; //Data type name of data member TString fTypeName; //Data type name of data member
TClass *fClassObject; //!pointer to class of object TClass *fClassObject; //!pointer to class of object
TClass *fNewClass; //!new element class when reading TClass *fNewClass; //!new element class when reading
TMemberStreamer *fStreamer; //!pointer to element Streamer TMemberStreamer *fStreamer; //!pointer to element Streamer
Double_t fXmin; //!Minimum of data member if a range is specified [xmin,xmax,nbits] Double_t fXmin; //!Minimum of data member if a range is specified [xmin,xmax,nbits]
Double_t fXmax; //!Maximum of data member if a range is specified [xmin,xmax,nbits] Double_t fXmax; //!Maximum of data member if a range is specified [xmin,xmax,nbits]
Double_t fFactor; //!Conversion factor if a range is sp ecified fFactor = (1<<nbits/(xmax-xmin) Double_t fFactor; //!Conversion factor if a range is sp ecified fFactor = (1<<nbits/(xmax-xmin)
public: public:
enum ESTLtype { kSTL = 300 /* TVirtualStreamerInfo::kSTL */, enum ESTLtype {
kSTLstring = 365 /* TVirtualStreamerInfo::kSTLstring */, kSTL = ROOT::kSTLany,
kSTLvector = 1, kSTLstring = ROOT::kSTLstring,
kSTLlist = 2, kSTLdeque = 3, kSTLmap = 4, kSTLvector = ROOT::kSTLvector,
kSTLset = 5, kSTLmultimap= 6, kSTLmultiset = 7, kSTLlist = ROOT::kSTLlist,
kSTLbitset = 8 kSTLdeque = ROOT::kSTLdeque,
kSTLmap = ROOT::kSTLmap,
kSTLmultimap = ROOT::kSTLmultimap,
kSTLset = ROOT::kSTLset,
kSTLmultiset = ROOT::kSTLmultiset,
kSTLbitset = ROOT::kSTLbitset
}; };
// TStreamerElement status bits // TStreamerElement status bits
enum { enum {
kHasRange = BIT(6), kHasRange = BIT(6),
kCache = BIT(9), kCache = BIT(9),
kRepeat = BIT(10), kRepeat = BIT(10),
kRead = BIT(11), kRead = BIT(11),
kWrite = BIT(12), kWrite = BIT(12),
kDoNotDelete = BIT(13), kDoNotDelete = BIT(13),
kWholeObject = BIT(14) kWholeObject = BIT(14)
 End of changes. 2 change blocks. 
6 lines changed or deleted 15 lines changed or added


 TVirtualStreamerInfo.h   TVirtualStreamerInfo.h 
skipping to change at line 27 skipping to change at line 27
// TVirtualStreamerInfo Abstract Interface class // // TVirtualStreamerInfo Abstract Interface class //
// // // //
// Abstract Interface describing Streamer information for one class. // // Abstract Interface describing Streamer information for one class. //
// // // //
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
#ifndef ROOT_TNamed #ifndef ROOT_TNamed
#include "TNamed.h" #include "TNamed.h"
#endif #endif
#ifndef ROOT_ESTLType
#include "ESTLType.h"
#endif
class TFile; class TFile;
class TClass; class TClass;
class TObjArray; class TObjArray;
class TStreamerElement; class TStreamerElement;
class TStreamerBasicType; class TStreamerBasicType;
class TVirtualCollectionProxy; class TVirtualCollectionProxy;
class TClassStreamer; class TClassStreamer;
namespace ROOT { class TCollectionProxyInfo; } namespace ROOT { class TCollectionProxyInfo; }
class TVirtualStreamerInfo : public TNamed { class TVirtualStreamerInfo : public TNamed {
skipping to change at line 72 skipping to change at line 76
kBase = 0, kOffsetL = 20, kOffsetP = 40, kCounter = 6, k CharStar = 7, kBase = 0, kOffsetL = 20, kOffsetP = 40, kCounter = 6, k CharStar = 7,
kChar = 1, kShort = 2, kInt = 3, kLong = 4, k Float = 5, kChar = 1, kShort = 2, kInt = 3, kLong = 4, k Float = 5,
kDouble = 8, kDouble32= 9, kDouble = 8, kDouble32= 9,
kUChar = 11, kUShort = 12, kUInt = 13, kULong = 14, k Bits = 15, kUChar = 11, kUShort = 12, kUInt = 13, kULong = 14, k Bits = 15,
kLong64 = 16, kULong64 = 17, kBool = 18, kFloat16 = 19, kLong64 = 16, kULong64 = 17, kBool = 18, kFloat16 = 19,
kObject = 61, kAny = 62, kObjectp = 63, kObjectP = 64, k TString = 65, kObject = 61, kAny = 62, kObjectp = 63, kObjectP = 64, k TString = 65,
kTObject = 66, kTNamed = 67, kAnyp = 68, kAnyP = 69, k AnyPnoVT = 70, kTObject = 66, kTNamed = 67, kAnyp = 68, kAnyP = 69, k AnyPnoVT = 70,
kSTLp = 71, kSTLp = 71,
kSkip = 100, kSkipL = 120, kSkipP = 140, kSkip = 100, kSkipL = 120, kSkipP = 140,
kConv = 200, kConvL = 220, kConvP = 240, kConv = 200, kConvL = 220, kConvP = 240,
kSTL = 300, kSTLstring = 365, kSTL = ROOT::kSTLany /* 300 */,
kSTLstring = ROOT::kSTLstring /* 365 */,
kStreamer = 500, kStreamLoop = 501, kStreamer = 500, kStreamLoop = 501,
kCache = 600, // Cache the value in memory than is not part of the object but is accessible via a SchemaRule kCache = 600, // Cache the value in memory than is not part of the object but is accessible via a SchemaRule
kArtificial = 1000, kArtificial = 1000,
kCacheNew = 1001, kCacheNew = 1001,
kCacheDelete = 1002, kCacheDelete = 1002,
kMissing = 99999 kMissing = 99999
}; };
// Some comments about EReadWrite // Some comments about EReadWrite
// kBase : base class element // kBase : base class element
 End of changes. 2 change blocks. 
1 lines changed or deleted 6 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/