Fixing a backward compatibility issue
[u/mrichter/AliRoot.git] / MUON / mapping / AliMpExMap.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 // $Id$
17 // $MpId: AliMpExMap.cxx,v 1.5 2006/05/24 13:58:29 ivana Exp $
18 // Category: basic
19
20 //-----------------------------------------------------------------------------
21 // Class AliMpExMap
22 // ------------------------
23 // Helper class making Root persistent TExMap
24 // Author:Ivana Hrivnacova; IPN Orsay
25 //-----------------------------------------------------------------------------
26
27 #include "AliMpExMap.h"
28 #include "AliMpExMapIterator.h"
29
30 #include "AliLog.h"
31
32 #include <TClass.h>
33 #include <TString.h>
34 #include <Riostream.h>
35
36 #include <stdlib.h>
37
38 /// \cond CLASSIMP
39 ClassImp(AliMpExMap)
40 /// \endcond
41
42 //
43 // static members
44 //
45
46 const Int_t   AliMpExMap::fgkDefaultSize = 300;
47 const Bool_t  AliMpExMap::fgkDefaultOwnership = true;
48
49 const Int_t AliMpExMap::fgkSeparator1 = 10000;
50 const Int_t AliMpExMap::fgkSeparator2 = 100;
51
52 const TString  AliMpExMap::fgkCharacterMap 
53   = " 1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-";
54
55 //
56 // static methods
57 //
58
59 //_____________________________________________________________________________
60 Long_t  AliMpExMap::GetIndex(const TString& s)
61 {
62 /// Convert the TString to integer.
63
64   if (s.Length() > 5) {
65     AliErrorClass("String too long.");
66     return -1;
67   }  
68
69   Long_t index = 0;
70   for (Int_t i=s.Length()-1; i>=0; --i)  
71     index = index*fgkSeparator2 + fgkCharacterMap.First(s(i));
72   
73   return index;
74 }
75
76 //_____________________________________________________________________________
77 TString  AliMpExMap::GetString(Long_t index)
78 {
79 /// Convert the integer index to the string.
80
81   TString s;
82   while (index >0) {
83     Char_t c = fgkCharacterMap(index%fgkSeparator2);
84     s += c;
85     index = index/fgkSeparator2;
86   }
87   return s;
88 }
89
90 //
91 // constructors/destructor
92 //
93
94 //_____________________________________________________________________________
95 AliMpExMap::AliMpExMap() 
96   : TObject(),
97     fMap(fgkDefaultSize),
98     fObjects(fgkDefaultSize),
99     fKeys(fgkDefaultSize)
100 {
101       /// Default constructor
102
103   fObjects.SetOwner(fgkDefaultOwnership);
104 }
105
106 //_____________________________________________________________________________
107 AliMpExMap::AliMpExMap(TRootIOCtor*) 
108   : TObject(),
109     fMap(),
110     fObjects(),
111     fKeys()
112 {
113       /// "Root - I/O" constructor
114 }
115
116
117 //_____________________________________________________________________________
118 AliMpExMap::AliMpExMap(const AliMpExMap& rhs)
119   : TObject(),
120     fMap(),
121     fObjects(),
122     fKeys()
123
124 {
125   /// Copy ctor
126   rhs.Copy(*this);
127 }
128
129 //_____________________________________________________________________________
130 AliMpExMap&
131 AliMpExMap::operator=(const AliMpExMap& rhs)
132 {
133   /// Assignment operator
134
135   // check assignment to self
136   if (this == &rhs) return *this;
137
138   rhs.Copy(*this);
139   return *this;
140 }
141
142 //_____________________________________________________________________________
143 AliMpExMap::~AliMpExMap() 
144 {
145 /// Destructor 
146 }
147
148 //
149 // private static methods
150 //
151
152 //______________________________________________________________________________
153 Long_t  AliMpExMap::GetIndex(Int_t first, Int_t second)
154 {
155 /// Convert the pair of integers to integer.
156
157   if ( first >= 0xFFFF || second >= 0xFFFF ) 
158   {
159     AliFatalClass("Index out of limit");
160     return 0;
161   }
162   
163   return 1 + ( first | ( second << 16 ) );
164            
165 //  if (pair.GetFirst() >= fgkSeparator1 || pair.GetSecond() >= fgkSeparator1) {
166 //    AliFatalClass("Index out of limit.");
167 //    exit(1); 
168 //  }  
169 //      
170 //  return pair.GetFirst()*fgkSeparator1 + pair.GetSecond() + 1;
171 }  
172
173 //______________________________________________________________________________
174 Int_t  AliMpExMap::GetPairFirst(Long_t index) 
175 {
176 /// Return first integer from index (encoded pair)
177
178   return (index-1) & 0xFFFF ;
179 }  
180
181 //______________________________________________________________________________
182 Int_t  AliMpExMap::GetPairSecond(Long_t index)
183 {
184 /// Return second integer from index (encoded pair)
185
186   return ( (index-1) & 0xFFFF0000 ) >> 16 ;
187 }  
188
189 //
190 // private methods
191 //
192
193 //_____________________________________________________________________________
194 void AliMpExMap::FillMap()
195 {
196 /// Fill transient map from the arrays of objects and keys
197
198   for (Int_t i=0; i<fObjects.GetEntriesFast(); i++) 
199     fMap.Add(fKeys.At(i), (Long_t)fObjects.At(i)); 
200 }
201
202 //_____________________________________________________________________________
203 void AliMpExMap::AddKey(Long_t key)
204 {
205 /// Add key in array with checking size
206
207   // Resize array if needed
208   if (fObjects.GetEntriesFast() == fKeys.GetSize()) {
209    fKeys.Set(2*fKeys.GetSize());
210    AliDebugStream(1) << "AliMpExMap::AddKey: resized Key array " << endl;
211   } 
212    
213   fKeys.AddAt(key, fObjects.GetEntriesFast());      
214 }
215
216 //_____________________________________________________________________________
217 void
218 AliMpExMap::Copy(TObject& dest) const
219 {
220   /// Copy this to dest
221   /// Copy implies that dest will become owner of its objects, whatever
222   /// the ownership of (*this) is.
223   
224   AliDebug(1,"");
225   
226   TObject::Copy(dest);
227   AliMpExMap& m = static_cast<AliMpExMap&>(dest);
228   m.fKeys = fKeys;
229   m.fMap.Delete();
230   m.fObjects.Clear();
231   
232   for ( Int_t i = 0; i <= fObjects.GetLast(); ++i ) 
233   {
234     TObject* o = fObjects.At(i)->Clone();
235     if (!o)
236     {
237       AliError("Object was not cloned properly ! Please investigate...");
238     }
239     m.fObjects.AddLast(o);
240   }
241   m.FillMap();
242   m.fObjects.SetOwner(kTRUE);
243 }
244
245 //
246 // public methods
247 //
248
249 //_____________________________________________________________________________
250 void AliMpExMap::Clear(Option_t* option)
251 {
252 /// Clear memory
253
254   fMap.Delete();
255   fObjects.Clear(option);
256   fKeys.Reset();
257 }
258
259 //_____________________________________________________________________________
260 void AliMpExMap::Print(Option_t* opt) const
261 {
262 /// Print out
263
264   cout << Form("fMap size/capacity %d/%d",fMap.GetSize(),fMap.Capacity()) 
265        << Form(" fObjects.GetSize/Entries %d/%d",fObjects.GetSize(),fObjects.GetEntries()) 
266        << Form(" fKeys.GetSize %d",fKeys.GetSize()) << endl;
267   
268   TString sopt(opt);
269   sopt.ToUpper();
270   
271   if ( sopt.Contains("FULL") ) 
272   {
273     TIter next(CreateIterator());
274     TObject* o;
275     while ( ( o = next() ) )
276     {
277       o->Print();
278     }
279   }
280 }
281
282 //_____________________________________________________________________________
283 void AliMpExMap::Add(Int_t keyFirst, Int_t keySecond, TObject* object)
284 {
285 /// Add object with its key to the map and arrays
286   
287   fMap.Add(GetIndex(keyFirst, keySecond), (Long_t)object);
288   AddKey(GetIndex(keyFirst, keySecond));
289   fObjects.Add(object);
290 }
291
292 //_____________________________________________________________________________
293 void AliMpExMap::Add(const TString& key, TObject* object)
294 {
295 /// Add object with its key to the map and arrays
296   
297   fMap.Add(GetIndex(key), (Long_t)object);
298   AddKey(GetIndex(key));
299   fObjects.Add(object);
300 }
301
302 //_____________________________________________________________________________
303 void AliMpExMap::Add(Int_t key, TObject* object)
304 {
305 /// Add object with its key to the map and arrays
306   
307   fMap.Add(key, (Long_t)object);
308   AddKey(key);
309   fObjects.Add(object);
310 }
311
312 //_____________________________________________________________________________
313 void AliMpExMap::SetSize(Int_t size)
314 {
315 /// Set given size to the key array
316
317   // fMap.Set(size);
318   // fObjects.Set(size);
319   fKeys.Set(size);
320
321
322 //_____________________________________________________________________________
323 void AliMpExMap::SetOwner(Bool_t owner)
324 {
325 /// Set given ownership to object array
326
327   fObjects.SetOwner(owner);
328 }  
329
330 //_____________________________________________________________________________
331 Int_t AliMpExMap::GetSize() const
332 {
333 /// Return the map size
334
335   return fObjects.GetEntriesFast();
336 }
337
338 //_____________________________________________________________________________
339 Int_t AliMpExMap::GetCapacity() const
340 {
341   /// Return the map capacity
342   
343   return fObjects.GetSize();
344 }
345
346 //_____________________________________________________________________________
347 AliMpExMapIterator*
348 AliMpExMap::CreateIterator() const
349 {
350 /// Return iterator set to the beginning of the map
351
352   return new AliMpExMapIterator(*this);
353 }
354
355 //_____________________________________________________________________________
356 TObject* AliMpExMap::GetValue(Int_t keyFirst, Int_t keySecond) const
357 {
358 /// Return the object associated with the given key if found,
359 /// otherwise return 0
360
361   return reinterpret_cast<TObject*>(fMap.GetValue(GetIndex(keyFirst, keySecond)));
362 }
363
364 //_____________________________________________________________________________
365 TObject*  AliMpExMap::GetValue(const TString& key) const
366 {
367 /// Return the object associated with the given key if found,
368 /// otherwise return 0
369
370   return reinterpret_cast<TObject*>(fMap.GetValue(GetIndex(key)));
371 }
372
373 //_____________________________________________________________________________
374 TObject*  AliMpExMap::GetValue(Int_t key) const
375 {
376 /// Return the object associated with the given key if found,
377 /// otherwise return 0
378
379   return reinterpret_cast<TObject*>(fMap.GetValue(key));
380 }
381
382 //_____________________________________________________________________________
383 void AliMpExMap::Streamer(TBuffer &R__b)
384 {
385 // Customized streamer                                                     \n
386 // After the arrays are read, fill the transient map
387
388   if (R__b.IsReading()) {
389     AliMpExMap::Class()->ReadBuffer(R__b, this);
390     FillMap();
391   } 
392   else {
393     AliMpExMap::Class()->WriteBuffer(R__b, this);
394   }
395 }