Log of /branches/v5-22-00-patches/io/io/src/TStreamerInfoReadBuffer.cxx
Parent Directory
Revision
33176 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Sat Apr 24 21:45:46 2010 UTC (4 years, 9 months ago) by
pcanal
File length: 93514 byte(s)
Diff to
previous 30998
Add support for reading file written by 5.27/02 and containing
a data member like:
std::container<Data> *fDataObjects;
which has been streamed memberwise (see revision r33173 of the trunk).
Revision
25450 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Thu Sep 18 21:13:42 2008 UTC (6 years, 4 months ago) by
pcanal
Original Path:
trunk/io/io/src/TStreamerInfoReadBuffer.cxx
File length: 84622 byte(s)
Diff to
previous 23122
Import the code from the branch dev/datamodelevolution revision 25436
This implements the infrastructure for the new Data Model Evolution Scheme.
This Data Model Evolution is brought to your courtesy of BNL/STAR/ATLAS/Fermi/Cern
Current Capabilities:
Assign values to transient data members
Rename classes
Rename data members
Change the shape of the data structures or convert one class structure to another
Change the meaning of data members
Ability to access the TBuffer directly when needed
Ensure that the objects in collections are handled in the same way as the ones stored separately
Supported in object-wise, member-wise and split modes.
Coming soon:
Make things operational also in bare ROOT mode
Ability to transform data before writing
Support for changing the class type of nested object in a split branch
Support for access to onfile version of nested objects from within the parent rule
LinkDef rule syntax:
Setting a transient member:
#pragma read sourceClass="ACache" targetClass="ACache" source="" version="[1-]" target="zcalc" \
code="{ zcalc = false; }"
Setting a new member from 2 removed members
#pragma read sourceClass="ACache" targetClass="ACache" source="int x; int y; char c" version="[8]" target="z" \
code="{ z = onfile.x*1000 + onfile.y*10; }"
Renaming a class
#pragma read sourceClass="ACache" version="[8]" targetClass="Axis" \
source="int x; int y;" target="z" \
code="{ z = onfile.x*1000 + onfile.y*
#pragma read sourceClass="ACache" version="[9]" targetClass="Axis";
Selection XML syntax
<read sourceClass="ACache" targetClass="ACache" source="" version="[1-]" target="zcalc">
<![CDATA[
{ zcalc = false; }
]]></read>
Revision
22940 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Wed Apr 2 11:00:49 2008 UTC (6 years, 9 months ago) by
pcanal
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 78703 byte(s)
Diff to
previous 21917
Insure that the TStreamerInfo a contained class that is to written memberwise
is _not_ optimized.
Repair a few place where TStreamerInfo was wasting some space when the
streamed collection was empty. Increase TStreamerInfo version to 7 to
distinguish the old and new cases.
Rename TCollectionProxyInfo::Environ::delete_temp to use_temp to clarify code/semantic
and fix its use to properly manage the life time of the temporary used (necessary in
the case of memberwise streaming (in non-split mode)).
Revision
20854 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Fri Nov 16 22:34:15 2007 UTC (7 years, 2 months ago) by
pcanal
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 76615 byte(s)
Diff to
previous 20173
* Correct the schema evolution to and from any numerical type involvind on one
end or the other any variation of Float16_t and Double32_t.
* Add the annotation (aka the comment part with [xyz]) of C style arrays,
Float16_t and Double32_t to the checksum calculation.
* Allow the checksum of existing class with a ClassDef to match with and
without the annotation taken in consideration. This allows for reading
older file (hence with desufficient checksum) to be read without any warning
message. However this also means that if the classes on this older file are
different _only_ by the annotation, it will not be noted.
* Prevent the fact that any consecutive Double32_t, independently of their
annotation are 'compiled' together and thus only the annotation of the first
one are used (incorrectly). To support backward compatibility with files
written with this bug, the version number of TStreamerInfo has been
increased to 6. The compilation is still done the same way for 'old'
TStreamerInfo (TStreamerInfo version 5 or less). However if the
Double32_t are changed to Float16_t, since the compilation is turned off
because of the schema evolution, the 'wrong' annotation might be used for
those old files. [This should be rare]
* Corrected the fact that due to an off by one lookup, the number of
TStreamerInfo for a class was actually limited to 13.
Revision
19048 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Sat Jun 16 03:19:37 2007 UTC (7 years, 7 months ago) by
pcanal
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 72099 byte(s)
Diff to
previous 17819
Add I/O support for a varying length array of polymorphic
pointers to objects.
Int_t fN;
MyClass** fAry; //[fN]
MyClass** fAryAry[10]; //[fN]
fAry = new MyClass*[fN];
fAryAry[0] = new MyClass*[fN];
fAry[0] = new MyClass;
fAry[1] = new DerivedFromMyClass;
fAryAry[0][0] = new MyClass;
fAryAry[0][1] = new DerivedFromMyClass;
This is implement using a different file format for data member
which are variable size arrays of pointers to objects.
We plan on triggering on the file version (5.15/09) which in practice
means that any file that
a) was written with 5.15/09 (the development code) prior to the checking
b) contains variable size arrays of pointers to objects.
will __partially__ not be readable with the new code (more exactly it will
issue a lot of warning messages and lose 'only' the objects from
the variable size arrays of pointers to objects.
Revision
17412 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Sat Jan 20 19:29:35 2007 UTC (8 years ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 63090 byte(s)
Diff to
previous 14085
-Remove Varargs.h from TString.h and TObject.h and add this include
in the few files that need it.
-Move the following enums from TBuffer.h to TBufferFile.h
enum { kMapSize = 503 };
enum { kStreamedMemberWise = BIT(14) }; //added to version number to know if a collection has been stored member-wise
enum { kNotDecompressed = BIT(15) }; //indicates a weird buffer, used by TBasket
enum { kCannotHandleMemberWiseStreaming = BIT(17), //if set TClonesArray should not use memeber wise streaming
kTextBasedStreaming = BIT(18) }; // indicates if buffer used for XML/SQL object streaming
Revision
12991 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Thu Oct 20 19:24:04 2005 UTC (9 years, 3 months ago) by
pcanal
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 63346 byte(s)
Diff to
previous 12601
From Paul Russo:
We extend the support for pointers to varying length arrays
of objects to include the cases:
1) Objects whose classes do not have a ClassDef macro, but do
have dictionaries loaded (no default Streamer, but we do have
TStreamerInfo).
2) Objects of classes with custom Streamer functions.
3) Reading an object from a file when we do not have the
dictionary loaded for the object's class, and then writing
that object out to a file again (emulated objects). This
allows us to copy trees without have to have the class
dictionaries loaded.
Note that we still do not support the case of STL objects.
There is a problem with the old implementation and the current
implementation in that memory is leaked in the case of reading
a varying length array of pointers to objects. The memory for
the objects read on the previous read is leaked because the code
is written in such a way that we have already overwritten the
length of the old variable array with the length of the new one
before we get to the place where we must iterate through the
array and free the old objects. The code must be changed to
take note of the old value of the varying length when the new
value is read, so that it may be used later to free the old
set of objects.
Revision
11606 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Mon Apr 18 10:54:58 2005 UTC (9 years, 9 months ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 58631 byte(s)
Diff to
previous 11445
Extend the functionality of the Double32_t data type (see below)
This extension supports higher precision than just a 32 bit float
and it also allows better compression when the range and number of bits
are specified.
New functions in TBuffer
void TBuffer::ReadDouble32 (Double_t *d, TStreamerElement *ele)
void TBuffer::WriteDouble32 (Double_t *d, TStreamerElement *ele)
The following functions of TBuffer have new signatures;
Int_t TBuffer::ReadArrayDouble32(Double_t *&d, TStreamerElement *ele)
Int_t TBuffer::ReadStaticArrayDouble32(Double_t *d, TStreamerElement *ele)
void TBuffer::ReadFastArrayDouble32(Double_t *d, Int_t n, TStreamerElement *ele)
void TBuffer::WriteArrayDouble32(const Double_t *d, Int_t n, TStreamerElement *ele)
void TBuffer::WriteFastArrayDouble32(const Double_t *d, Int_t n, TStreamerElement *ele)
The following data members have been added to TStreamerElement;
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 fFactor; //Conversion factor if a range is specified fFactor = (1<<nbits/(xmax-xmin)
The static function GetRange has been added to TStreamerElement.cxx.
This function analyzes the range specifier given in the data member
comments field.
The following cases are supported for streaming a Double32_t type
depending on the range declaration in the comment field of the data member:
A- Double32_t fNormal;
B- Double32_t fTemperature; //[0,100]
C- Double32_t fCharge; //[-1,1,2]
D- Double32_t fVertex[3]; //[-30,30,10]
E Int_t fNsp;
Double32_t* fPointValue; //[fNsp][0,3]
In case A fNormal is converted from a Double_t to a Float_t
In case B fTemperature is converted to a 32 bit unsigned integer
In case C fCharge is converted to a 2 bits unsigned integer
In case D the array elements of fVertex are converted to an unsigned 10 bits integer
In case E the fNsp elements of array fPointvalue are converted to an unsigned 32 bit integer
Note that the range specifier must follow the dimension specifier.
the case B has more precision (9 to 10 significative digits than case A (6 to 7 digits).
The range specifier has the general format: [xmin,xmax] or [xmin,xmax,nbits]
[0,1]
[-10,100];
[-pi,pi], [-pi/2,pi/4],[-2pi,2*pi]
[-10,100,16]
if nbits is not specified, or nbits <2 or nbits>32 it is set to 32
TStreamerInfo has been modified to take into account the new facility
when streaming a Double32_t. It calls the new TBuffer functions ReadDouble32
and WriteDouble32 instead of the previous inline code.
Note that the files TEmulatedCollectionProxy.cxx and TGenCollectionStreamer.cxx
must still be modified to pass correctly the TStreamerElement object
to the Double32 conversion routines (for Philippe).
Note also that the class TXMLBuffer must still be changed to support
the Double32_t data type (for Sergei).
The test program Event has been modified to illustrate several combinations
of the range specifier.
The test program stress2 has been changed to take into account the slight
increase in the file size due to the new members in TStreamerElement.
Revision
11436 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Mon Mar 28 21:17:39 2005 UTC (9 years, 9 months ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 58643 byte(s)
Diff to
previous 11189
From Philippe
The following problems were found while running roottest on MacOS.
rootcint: Insure that the dimensions of
Int_t (*fArray)[3];
are properly recorded by the ShowMembers function
TStreamerInfo: Insure that the wrapper template function see
all modifications to the TStreamerInfo
TTreePlayer: In Scan insures that the entry number is printed
as a long long (aka with %lld).
Revision
11001 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Fri Jan 28 05:45:41 2005 UTC (9 years, 11 months ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 58601 byte(s)
Diff to
previous 10958
From Philippe:
This patch solved a problem due to the fact that TObject's fUniqueID can
only hold a 8 bits ProccessID identifier (in addition to storing a 24 bits
object ID). However we support 65535 distinct ProcsssID identifiers per
file. Before this patch, for a file containing more than 255 distcint
ProcessID, the
TRef using the later ProcessID would be unable to find their references.
Specifically, fUniqueID can now store the ProcessID indentifier 0 through
254. When more identifiers
are used, then instead of store the identifier in the 8 higher bit of
fUniqueID we store in a table (TProcessID::fgObjPIDs) linking addresses to
pids.
Revision
10958 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Wed Jan 19 18:30:58 2005 UTC (10 years ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 58415 byte(s)
Diff to
previous 10750
From Philippe:
This patch implement support for bool of various in memory size. They are
always written using only 1 bytes. This solves problem on MacOS where
sizeof(bool)==4 instead of 1.
Note that there should still be a problem with the old-style splitted branch
(tested in Event.old.split.root.
A fix for this will come later on.
Revision
10730 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Thu Dec 9 07:49:22 2004 UTC (10 years, 1 month ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 57940 byte(s)
Diff to
previous 10553
From Sergei Linev
In TStreamerInfoReadBuffer.cxx I modified SkipCBasicArray(name)
and SkipCBasicPointer(name) macros in view of XML schema evolution.
I create temporary a buffer, read data and delete the buffer.
In SkipCBasicPointer in case of a counter I read in a dummy variable.
Revision
10549 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Wed Nov 17 17:56:53 2004 UTC (10 years, 2 months ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 59037 byte(s)
Diff to
previous 10545
From Philippe,
This patch implements the schema evolution to and from selected containers.
The following cases are currently implemented:
TClonesArray object -> STL object containing the same type
TClonesArray pointer -> STL pointer containing the same type
STL object -> STL object containing the same type
STL pointer -> STL pointer containing the same type
STL split branches -> TClonesArray
In addition this patch implement the ability to have schema evolution
between various version of a foreign class when the library is not present.
This patch also support in in TTree::Draw for the schema evolution of simple
type stored in a non-split branch.
Revision
10541 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Wed Nov 17 06:02:52 2004 UTC (10 years, 2 months ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 59037 byte(s)
Diff to
previous 10485
From Philippe:
This patch implements the schema evolution to and from selected containers.
The following cases are currently implemented:
TClonesArray object -> STL object containing the same type
TClonesArray pointer -> STL pointer containing the same type
STL object -> STL object containing the same type
STL pointer -> STL pointer containing the same type
STL split branches -> TClonesArray
In addition this patch implement the ability to have schema evolution
between various version of a foreign class when the library is not present.
This patch also support in in TTree::Draw for the schema evolution of simple
type stored in a non-split branch.
Revision
10485 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Fri Nov 5 14:32:36 2004 UTC (10 years, 2 months ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 58597 byte(s)
Diff to
previous 10451
From Markus
I have removed the call
TVirtualCollectionProxy::Streamer()
and
TVirtualCollectionProxy::Resize()
A call to the latter one I thought I have already removed with Rene
some days ago (??) but it did not show up in cvs.
In principle the TVirtualCollectionProxy should now
be sufficiently clean. What may also be questioned are
the calls SetValueClass(), but with this Philippe has
something in mind.
The files
cont/inc/TVectorProxy.h
cont/inc/TEmulatedVectorProxy.h
cont/src/TEmulatedVectorProxy.cxx
should be removed from the cvs head. They are no longer in use.
Their functionality was completely taken over by the
new proxy class(es).
WARNING!!!!
When installing from source, do
rm -f cont/src/G*
rm -f cont/src/TEmulatedVectorProxy.*
make
Revision
10350 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Tue Oct 19 11:00:09 2004 UTC (10 years, 3 months ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 58455 byte(s)
Diff to
previous 9861
From Philippe:
implements MemberWise streaming for collection with a
TVirtualCollectionProxy and whose content is splittable (i.e. guaranteed
homogeneous).
In this first implementation, objectwise streaming is still the default.
To activate memberwise streaming, call the static function
TStreamerInfo::SetStreamMemberWise(kTRUE);
Revision
9825 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Mon Aug 23 16:05:43 2004 UTC (10 years, 5 months ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 56873 byte(s)
Diff to
previous 9803
From Philippe:
This patch work around the fact that some compiler (MS6 and alpha) does
not properly handle templated member function. This result in non optimal
run-time performance on those platforms. Also work around the difficulty
with stl container for void* with CINT on MS7)
Revision
9803 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Fri Aug 20 21:02:10 2004 UTC (10 years, 5 months ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 45736 byte(s)
Diff to
previous 9290
From Philippe:
This patch is an important step toward the implementation of the member-wise
saving of stl containers.
Mainly, the code does not require anymore the collection proxy to be able
to provide a C-style array of pointer to its content. This avoid the
problems of having to iterate twice through some collection and/or to have to
keep in memory a version of this array. Concretely this also mean that the
I/O routine will now be able to recurse through stl containers.
Technically, this is done by templating TStreamerInfo::ReadBuffer and
TStreamerInfo::WriteBufferAux (as well as the ReadBufferSkip And
ReadBufferConv) so that you can use it directly with a char** or
with a TVirtualCollection (to which we added an operator [] and
removed the method GetPtrArray).
In addition, we added 2 new method to TVirtualCollectionProxy:
PushProxy and PopProxy that will allow to keep some state on
where we are in the iteration for a collection when we recurse.
(This is required for a reasonable implementation of the
TVirtualCollection for std::list).
Also (in an unrelated fix) we update TTreePlayer::Scan to
properly display the columns when they are more expressions
in the request than leaves in the tree.
Revision
9290 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Tue Jun 22 18:47:17 2004 UTC (10 years, 7 months ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 25326 byte(s)
Diff to
previous 8882
From Philippe:
TXmlBuffer.cxx:
Update IncrementLevel and DecrementLevel to call their TBuffer
counter-part.
TStreamerInfo.h:
Increase the class version to allow backward compatibility test
(STL containers of pointer to a class not inheriting from TObject
but with a ClassDef.)
TXmlBuffer.cxx TStreamerInfo.cxx
formatting updates
rootcint.cxx TROOT.cxx
Made sure that the version number of a STL continer's TClass is
always the same as TStreamerInfo's class version.
Fix a backward compatibility problem with STL containers of
pointer to a class not inheriting from TObject but with a ClassDef.
Revision
8087 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Thu Jan 29 23:08:16 2004 UTC (10 years, 11 months ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 25183 byte(s)
Diff to
previous 7997
From Philippe:
This patch should resolve completely the issue discovered by Minos (related to
typename being typedefs). It also repairs the I/O for fixed size array of
TObject.
TString:
add constructor and operator= taking a std::string argument
TROOT:
GetClass now properly resolve templateClass<typedef>.
Previously the typedef resolution was restricted to the full name.
TClassTable:
Look for an existing TClass directly in TROOT::fListOfClasses to
avoid the potential loading behavior of TROOT::GetClass
TCint::UpdateClassInfo
Also look for possible alias name in the list of TClass objects.
In particular, depending on the load order of libraries and file,
the Emulated class for container<int> might be container<Int_t> or
vce et versa.
TClass::Init
When we have a templated class, also look for existing Emulated
class which may have a different name.
TStreamerElement/TStreamerInfo
Use the name with resolved typedef in the TStreamerElement.
Also repair the I/O for fixed size array of TObjects.
TClassEdit:
Add a utility to resolve the typedefs inside a typename.
This resolution has 2 modes. One where it resolved all
typedefs which should be used to compare 2 typename and
establish equality. A second where it resolved all
typedefs __except__ for the ROOT integral type typedefs,
this version is used to create the typename that will be
save on file. This is necessary to avoid the replacement
of (for example) Long64_t by its platform dependent version.
Revision
7880 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Added
Sat Jan 10 10:52:31 2004 UTC (11 years ago) by
brun
Original Path:
trunk/io/src/TStreamerInfoReadBuffer.cxx
File length: 24223 byte(s)
From Philippe:
This mega patch introduces a new implementation of the STL I/O
which is backward and forward compatible. In addition this is more
exactly a new implementation or an extension of the container I/O.
We are introducing a new abstract interface:
"TVirtualContainerProxy", which can be implemented to present a
proxy to any collection which the I/O (and TTreeFormula) can use
then transparently.
The TVirtualContainerProxy interface allows to the I/O system to
request some information and to execute some essential function of
the container:
what kind of object/data does it contain
does it contain pointers
how to insert data into the container
how to retrieve an array of pointer to the elements inside
how to create a collection object
how to clear the collection
how to resize the collection
how to streamer the collection (if needed)
how to calculate the sizeof the collection
how to calculate the number of elements of the collection.
Using those primitives, the I/O and TTreeFormula should be able to
access any collection. The I/O should also be able to handle the
splitting of collections that can be split (i.e. contains a single
type of object/data).
The current compromise selected between code duplication,
performance of the I/O of TClonesArray and vector of pointers and
the performance of the I/O of other containers, was to have on
function handle all collection as if they were a C-style array of
pointers to data. This implies for example that the I/O of vector
of object current passes via the construction of temporary array
of pointer. The cost of this construction is usually ~Qjust~R the
cost of calculating the addresses of the elements and assigning it
to an array element.
Registering a collection proxy will be similar to
static int dummy = GenerateInitInstance((CollectType*)0x0)-
>AdoptCollectionProxy(new CollectTypeProxy));
Follows a few details on the modifications made to some of the
files and classes.
Bytes.h:
Work around a problem in the MSVC++ 6.0 optimizer. This should
not affect other compilers.
String:
Included the std::string dictionary into G__Base2.cxx, this
insures its presence at all time.
Added a new file string.cxx holding the streamer for
std::string.
RConfig.h
Added proper ansi stream configuration for AIX, KCC
Added template specialization defect for MSVC
TBrowser
Start adding the ability to browser non TObject classes
TBuffer
To handle the reading and writing array of objects, added:
Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const
TClass *clss, const char* classname);
Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const
char *classname);
void ReadFastArray(void *start , TClass *cl, Int_t n=1,
TMemberStreamer *s=0);
void ReadFastArray(void **startp, TClass *cl, Int_t n=1,
Bool_t isPreAlloc=kFALSE, TMemberStreamer *s=0);
void WriteFastArray(void *start, TClass *cl, Int_t n=1,
TMemberStreamer *s=0);
Int_t WriteFastArray(void **startp, TClass *cl, Int_t n=1,
Bool_t isPreAlloc=kFALSE, TMemberStreamer *s=0);
TROOT
Enhancement to make the access to gROOT not dependent for the
library loading order. In particular we added:
ROOT::GetROOT()
which should be used instead of gROOT.
Improve support for STL. In particular, now STL containers do
have a corresponding TClass object
TRealData
Replace SetStreamer by AdoptStreamer that allow to use not only
a streamer function but also streamer object (allowing streamer
with a state for Foreign classes)
TString:
Improve streamer performance
TSystem:
More consistency of the return value of TSystem::CompileMacro
build/unix/makecintdlls.sh
Stop making the string.dll
config:
enhance sgicc makefiles
cont:
fix TBits::operator=
TClassTable now warns for duplicate only for non stl classes
TClonesArray fix a typo
gpad:
Add a new class TInspectObject to enable inspect non TObject
classes
TRootBrowser : enable inspect non TObject classes
TFormula/TTreeFormula
To enhance performance switch from using one array fOper which
contained the operation code and its arguments to using 2 arrays
fActions and fActionParams to store respectively the operation and
its parameters.
A new function Convert is used to convert old version from the
fOper to fActions. This allows cleaner coding and offer
optimization opportunities.
TTreePlayer
Start adding support in MakeClass for STL containers.
TRint/TProofServ
Insure the loading of the string support
Event.cxx
make sure to avoid memory over-write
stress.cxx
Add new parameters
stress <nevent> <style> <subbench> <portion>
if <subbench> is 1 or higher, print the benchmark results after
each test. This allows understand
which test is affect by a performance change.
portion is a binary field to indicate which test to run. This
allows to focus on a particular test.
TVirtualCollectionProxy
Abstract interface used to access any type of containers from
the I/O system and TTreeFormula. See TVectorProxy and
TEmulatedVectorProxy for examples.
TEmulatedVectorProxy
Implementation of a std::vector proxy to be able to read a
std::vector without any libraries.
TVectorProxy
Implementation of TVirtualCollectionProxy for a std::vector for
which we have the library.
TStreamerInfo.cxx
Split in 3 files: TStreamerInfo.cxx
TStreamerInfoReadBuffer.cxx TStreamerInfoWriteBuffer.cxx
All the ReadBuffer, ReadBufferClones and the new ReadBufferSTL
(similarly for WriteBuffer) have been factorized into one
function and 2 short wrappers. The new main function expect an
array of pointer to the objects (this array is most often of size
one).
TClonesArray objects pass GetObjectRef(0) to the common
ReadBuffer
vector<bla*> v pass &(v[0])
vector<bla> needs to create an intermediary array to hold the
address
This mechanism is sometimes not optimal (vector<blah>) but
allows extremely flexibly and extension. Basically, to add
support for a new container type using the StreamerInfo mechanism
(in particular allows splitting), one 'just' need to implement a
TVirtualCollectionProxy, which, in particular, will return an
array of address to the object it contains. Even std::map can be
handled with this mechanism, since, for I/O purposes, it can be
consider as a container of pairs.
Add a few optimization, including more caching via a new array
of a new struct (fComp).
Fixed a problem (re)introduced while implementing the Foreign
class CheckSum. Doing:
class Event;
f = new TFile("Event.root");
resulted in errors.
TCint
Add proper support for TClass of STL containers. Fix a memory
leak.
Add support for load TClass via a typedef.
Fix a problem with multiple inheritance
TClass
Fixed a problem (re)introduced while implementing the Foreign
class CheckSum. Doing:
class Event;
f = new TFile("Event.root");
resulted in errors.
Add a
TClass/TGenericClassInfo/TDataMember
Add support for a new interface (TVirtualCollectionProxy)
useable for STL containers or any user defined containers.
Add support for streamer with are objects (as opposed to free
standing function or methods). This allows the user a greater
flexibility in writing a streamer.
Add a few optimizations
Add CanSplit to answer the question for a whole Class (for
example some collection can not be splitted).
TClassStreamer
New class to wrap a class wide streamer
ClassStreamerFunc_t
typedef for a class wide streamer function
TMemberStreamer
New class to wrap a specific class member streamer
MemberStreamerFunc_t
typedef for a specific class member streamer function
RootStreamer
Macro to specify a free standing streamer object or function
for a class
For example:
RootStreamer(string,std_string_streamer);
TStreamerElement:
A couple of optimization/simplification.
Add support for the new STL I/O
Extend the useful
TBranchElement:
add a connection to the proper TVirtualCollectionProxy
add support for STL containers (non-split and split mode)
TTree
Make the function TTree::GetMakeClass NON-virtual for better
efficiency
Add support for STL containers
TBasket
Left (in comment) a yet unproved improvement proposed by
Victor. The preliminary tests were inconclusive performance wise
and it had (seemingly) problem with backward and forward
compatibility.
TBranch
Performance improvements
metautils
This is a new package for C++ files shared between rootcint and
meta.
It contains TClassEdit a class to help determine some property
of a class given its class name (stl, template, etc).
utils
Introduced a new file RStl.cxx to start separating rootcint in
modules.
Modified rootcint to support the new STL I/O methods.
In particular a new class RStl is in charge of doing the
generating of code for STL containers.
This form allows you to request diffs between any two revisions of this file.
For each of the two "sides" of the diff,
enter a numeric revision.
