ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitAna/DataCont/interface/FastArrayBasic.h
Revision: 1.7
Committed: Thu Mar 12 18:19:47 2009 UTC (16 years, 2 months ago) by loizides
Content type: text/plain
Branch: MAIN
CVS Tags: Mit_008pre2
Changes since 1.6: +16 -4 lines
Log Message: 
Proper resetting of the cached entry in BaseCollection.

File Contents

# Content
1 //--------------------------------------------------------------------------------------------------
2 // $Id: FastArrayBasic.h,v 1.6 2009/03/06 13:52:54 loizides Exp $
3 //
4 // FastArrayBasic
5 //
6 // Implementation of a "fast" array on the heap: Memory is dynamically allocated,
7 // but there is an optimization in the read streamer similar to the TClonesArray
8 // where the heap memory of an existing object is reused.
9 // This class is meant to be used as a datamember for objects which are contained
10 // inside a TClonesArray.
11 // For various reasons, the array can not be written in split mode.
12 // Array is meant to store basic data types as opposed to FastArray
13 // which can hold arbitrary (non-heap using) classes.
14 // Since it stores basic types it can not derive from the Collection<ArrayElement>
15 // interface, or else the At() member functions would have to return pointers to
16 // basic elements. Something we did not want to do.
17 //
18 // Authors: J.Bendavid
19 //--------------------------------------------------------------------------------------------------
20
21 #ifndef MITANA_DATACONT_FASTARRAYBASIC_H
22 #define MITANA_DATACONT_FASTARRAYBASIC_H
23
24 #include <TObject.h>
25 #include <TClass.h>
26 #include <TStorage.h>
27 #include "MitAna/DataCont/interface/Collection.h"
28
29 namespace mithep
30 {
31 template<class ArrayElement, Bool_t IsDouble32 = kFALSE>
32 class FastArrayBasic : public BaseCollection
33 {
34 public:
35 FastArrayBasic(UShort_t icap=0);
36 FastArrayBasic(const FastArrayBasic &a);
37 ~FastArrayBasic() { Init(0); }
38
39 void Add(const ArrayElement &ae);
40 ArrayElement At(UInt_t idx);
41 const ArrayElement At(UInt_t idx) const;
42 void Clear(Option_t */*opt*/="") { fSize=0; Init(0); }
43 UInt_t Entries() const { return fSize; }
44 UInt_t GetEntries() const { return fSize; }
45 UInt_t GetSize() const { return fCapacity; }
46 Bool_t IsOwner() const { return kTRUE; }
47 TObject *ObjAt(UInt_t /*idx*/) { return 0; }
48 const TObject *ObjAt(UInt_t /*idx*/) const { return 0; }
49 void Reset();
50 void Trim() { Expand(fSize); }
51 ArrayElement UncheckedAt(UInt_t idx);
52 const ArrayElement UncheckedAt(UInt_t idx) const;
53 ArrayElement operator[](UInt_t idx);
54 const ArrayElement operator[](UInt_t idx) const;
55
56 protected:
57 void Init(UShort_t s);
58 void Expand(UShort_t s);
59
60 UShort_t fSize; //size of array
61 UShort_t fCapacity; //!size of heap allocated
62 ArrayElement *fArray; //!heap storage for objects
63
64 ClassDef(FastArrayBasic,1) // Fast array for basic types
65 };
66 }
67
68 //--------------------------------------------------------------------------------------------------
69 template<class ArrayElement, Bool_t IsDouble32>
70 inline mithep::FastArrayBasic<ArrayElement, IsDouble32>::FastArrayBasic(UShort_t icap) :
71 fSize(0),
72 fCapacity(0),
73 fArray(0)
74 {
75 // Default constructor.
76
77 if (icap)
78 Init(icap);
79 }
80
81 //--------------------------------------------------------------------------------------------------
82 template<class ArrayElement, Bool_t IsDouble32>
83 inline mithep::FastArrayBasic<ArrayElement, IsDouble32>::FastArrayBasic(const FastArrayBasic &a) :
84 fSize(0),
85 fCapacity(0),
86 fArray(0)
87 {
88 // Copy constructor. Copy only elements which are used.
89
90 Init(a.fSize);
91 for (UInt_t i=0; i<a.fSize; ++i)
92 Add(a.fArray[i]);
93 }
94
95 //--------------------------------------------------------------------------------------------------
96 template<class ArrayElement, Bool_t IsDouble32>
97 void mithep::FastArrayBasic<ArrayElement, IsDouble32>::Add(const ArrayElement &ae)
98 {
99 // Add a copy of an existing object.
100
101 if (fSize >= fCapacity)
102 Expand(TMath::Max(16,2*fCapacity));
103
104 ++fSize;
105 fArray[fSize-1] = ae;
106 }
107
108 //--------------------------------------------------------------------------------------------------
109 template<class ArrayElement, Bool_t IsDouble32>
110 inline ArrayElement mithep::FastArrayBasic<ArrayElement, IsDouble32>::At(UInt_t idx)
111 {
112 // Return entry at given index.
113
114 if (idx<fSize)
115 return fArray[idx];
116
117 ArrayElement tmp;
118 TObject::Fatal("At","Index too large: (%u < %u violated) for %s containing %s",
119 idx, fSize, this->GetName(), typeid(tmp).name());
120 return 0;
121 }
122
123 //--------------------------------------------------------------------------------------------------
124 template<class ArrayElement, Bool_t IsDouble32>
125 inline const ArrayElement mithep::FastArrayBasic<ArrayElement, IsDouble32>::At(UInt_t idx) const
126 {
127 // Return entry at given index.
128
129 if (idx<fSize)
130 return fArray[idx];
131
132 ArrayElement tmp;
133 TObject::Fatal("At","Index too large: (%u < %u violated) for %s containing %s",
134 idx, fSize, this->GetName(), typeid(tmp).name());
135 return 0;
136 }
137
138 //--------------------------------------------------------------------------------------------------
139 template<class ArrayElement, Bool_t IsDouble32>
140 inline void mithep::FastArrayBasic<ArrayElement, IsDouble32>::Expand(UShort_t s)
141 {
142
143 // Expand or shrink the array to given number of elements.
144
145 if (s < fSize) {
146 TObject::Fatal("Expand", "Cannot shrink FastArrayBasic to less than fSize");
147 return;
148 }
149
150 if (!fArray || s==0) {
151 Init(s);
152 return;
153 }
154
155 if (fCapacity == s)
156 return;
157
158 fArray = static_cast<ArrayElement*>(TStorage::ReAlloc(fArray, s * sizeof(ArrayElement),
159 fCapacity * sizeof(ArrayElement)));
160 fCapacity = s;
161 }
162
163 //--------------------------------------------------------------------------------------------------
164 template<class ArrayElement, Bool_t IsDouble32>
165 inline void mithep::FastArrayBasic<ArrayElement, IsDouble32>::Init(UShort_t s)
166 {
167
168 // Initialize the array the heap.
169
170 if (fArray && fCapacity != s) {
171 TStorage::Dealloc(fArray);
172 fArray = 0;
173 }
174
175 fCapacity = s;
176
177 if (!fArray && fCapacity > 0)
178 fArray = static_cast<ArrayElement*>(TStorage::Alloc(fCapacity*sizeof(ArrayElement)));
179 }
180
181 //-------------------------------------------------------------------------------------------------
182 template<class ArrayElement, Bool_t IsDouble32>
183 void mithep::FastArrayBasic<ArrayElement, IsDouble32>::Reset()
184 {
185 // Reset this array.
186
187 fSize = 0;
188 BaseCollection::Clear();
189 }
190
191 //-------------------------------------------------------------------------------------------------
192 template<class ArrayElement, Bool_t IsDouble32>
193 void mithep::FastArrayBasic<ArrayElement, IsDouble32>::Streamer(TBuffer &b)
194 {
195 // Stream all objects in the array to or from the I/O buffer.
196 // Ugly special case handling for Double32
197
198 if (b.IsReading()) {
199 b >> fSize;
200 if (fSize) {
201 if (fSize > fCapacity)
202 Expand(TMath::Max(static_cast<Int_t>(fSize),2*fCapacity));
203
204 if (IsDouble32)
205 b.ReadFastArrayDouble32(reinterpret_cast<Double_t*>(fArray),fSize);
206 else
207 b.ReadFastArray(fArray,fSize);
208 }
209 } else { /*writing*/
210 b << fSize;
211 if (fSize) {
212 if (IsDouble32)
213 b.WriteFastArrayDouble32(reinterpret_cast<Double_t*>(fArray),fSize);
214 else
215 b.WriteFastArray(fArray,fSize);
216 }
217 }
218 }
219
220 //--------------------------------------------------------------------------------------------------
221 template<class ArrayElement, Bool_t IsDouble32>
222 inline ArrayElement mithep::FastArrayBasic<ArrayElement, IsDouble32>::UncheckedAt(UInt_t idx)
223 {
224 // Return entry at given index.
225
226 return fArray[idx];
227 }
228
229 //--------------------------------------------------------------------------------------------------
230 template<class ArrayElement, Bool_t IsDouble32>
231 inline const ArrayElement
232 mithep::FastArrayBasic<ArrayElement, IsDouble32>::UncheckedAt(UInt_t idx) const
233 {
234 // Return entry at given index.
235
236 return fArray[idx];
237 }
238
239 //--------------------------------------------------------------------------------------------------
240 template<class ArrayElement, Bool_t IsDouble32>
241 inline const ArrayElement
242 mithep::FastArrayBasic<ArrayElement, IsDouble32>::operator[](UInt_t idx) const
243 {
244 // Return entry at given index.
245
246 return At(idx);
247 }
248
249 //--------------------------------------------------------------------------------------------------
250 template<class ArrayElement, Bool_t IsDouble32>
251 inline ArrayElement mithep::FastArrayBasic<ArrayElement, IsDouble32>::operator[](UInt_t idx)
252 {
253 // Return entry at given index.
254
255 return At(idx);
256 }
257 #endif