ROOT logo
// @(#)root/cont:$Id$
// Author: Fons Rademakers   12/11/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMap                                                                 //
//                                                                      //
// TMap implements an associative array of (key,value) pairs using a    //
// THashTable for efficient retrieval (therefore TMap does not conserve //
// the order of the entries). The hash value is calculated              //
// using the value returned by the keys Hash() function and the         //
// key comparison is done via the IsEqual() function.                   //
// Both key and value must inherit from TObject.                        //
//Begin_Html
/*
<img src=gif/tmap.gif>
*/
//End_Html
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TMap.h"
#include "THashTable.h"
#include "TROOT.h"
#include "TBrowser.h"
#include "TRegexp.h"

ClassImp(TMap)

//______________________________________________________________________________
TMap::TMap(Int_t capacity, Int_t rehashlevel)
{
   // TMap ctor. See THashTable for a description of the arguments.

   fSize  = 0;
   fTable = new THashTable(capacity, rehashlevel);
}

//______________________________________________________________________________
TMap::~TMap()
{
   // TMap dtor. Objects are not deleted unless the TMap is the
   // owner (set via SetOwner()).

   Clear();
   delete fTable;
}

//______________________________________________________________________________
void TMap::Add(TObject *)
{
   // This function may not be used (but we need to provide it since it is
   // a pure virtual in TCollection). Use Add(key,value) instead.

   MayNotUse("Add(TObject *obj)");
}

//______________________________________________________________________________
void TMap::Add(TObject *key, TObject *value)
{
   // Add a (key,value) pair to the map.

   if (IsArgNull("Add", key)) return;

   fTable->Add(new TPair(key, value));
   fSize++;
}

//______________________________________________________________________________
Float_t TMap::AverageCollisions() const
{
   // Return the ratio of entries vs occupied slots.

   return fTable->AverageCollisions();
}

//______________________________________________________________________________
Int_t TMap::Capacity() const
{
   // Return number of slots in the hashtable. Use GetSize() to get the
   // number of objects stored in the TMap.

   return fTable->Capacity();
}

//______________________________________________________________________________
void TMap::Clear(Option_t *option)
{
   // Remove all (key,value) pairs from the map. The keys/values are
   // deleted depending on the state of key-ownership (SetOwner()) and
   // value-ownership (SetOwnerValue()).
   //
   // To delete these objects regardless of the ownership state use:
   //  - Delete()       to delete only keys;
   //  - DeleteValues() to delete only values;
   //  - DeleteAll()    to delete both keys and values.

   if (IsOwner() && IsOwnerValue())
      DeleteAll();
   else if (IsOwner())
      Delete();
   else if (IsOwnerValue())
      DeleteValues();
   else {
      fTable->Delete(option);    // delete the TPair's
      fSize = 0;
   }
}

//______________________________________________________________________________
Int_t TMap::Collisions(const char *keyname) const
{
   // Returns the number of collisions for a key with a certain name
   // (i.e. number of objects in same slot in the hash table, i.e. length
   // of linked list).

   return fTable->Collisions(keyname);
}

//______________________________________________________________________________
Int_t TMap::Collisions(TObject *key) const
{
   // Returns the number of collisions for a key (i.e. number of objects
   // in same slot in the hash table, i.e. length of linked list).

   return fTable->Collisions(key);
}

//______________________________________________________________________________
void TMap::Delete(Option_t *option)
{
   // Remove all (key,value) pairs from the map AND delete the keys
   // when they are allocated on the heap.

   TIter next(fTable);
   TPair *a;

   while ((a = (TPair *)next()))
      if (a->Key() && a->Key()->IsOnHeap())
         TCollection::GarbageCollect(a->Key());

   fTable->Delete(option);   // delete the TPair's
   fSize = 0;
}

//______________________________________________________________________________
void TMap::DeleteValues()
{
   // Remove all (key,value) pairs from the map AND delete the values
   // when they are allocated on the heap.

   TIter next(fTable);
   TPair *a;

   while ((a = (TPair *)next()))
      if (a->Value() && a->Value()->IsOnHeap())
         TCollection::GarbageCollect(a->Value());

   fTable->Delete();   // delete the TPair's
   fSize = 0;
}

//______________________________________________________________________________
void TMap::DeleteAll()
{
   // Remove all (key,value) pairs from the map AND delete the keys AND
   // values when they are allocated on the heap.

   TIter next(fTable);
   TPair *a;

   while ((a = (TPair *)next())) {
      if (a->Key()   && a->Key()->IsOnHeap())
         TCollection::GarbageCollect(a->Key());
      if (a->Value() && a->Value()->IsOnHeap())
         TCollection::GarbageCollect(a->Value());
   }

   fTable->Delete();   // delete the TPair's
   fSize = 0;
}

//______________________________________________________________________________
Bool_t TMap::DeleteEntry(TObject *key)
{
   // Remove (key,value) pair with key from the map. Returns true
   // if the key was found and removed, false otherwise.
   // The key and value objects are deleted if map is the owner
   // of keys and values respectively.

   if (!key) return kFALSE;

   TPair *a;
   if ((a = (TPair *)fTable->FindObject(key))) {
      if (fTable->Remove(key)) {
         if (IsOwner() && a->Key() && a->Key()->IsOnHeap())
            TCollection::GarbageCollect(a->Key());
         if (IsOwnerValue() && a->Value() && a->Value()->IsOnHeap())
            TCollection::GarbageCollect(a->Value());
         delete a;
         fSize--;
         return kTRUE;
      }
   }
   return kFALSE;
}

//______________________________________________________________________________
TObject *TMap::FindObject(const char *keyname) const
{
   // Check if a (key,value) pair exists with keyname as name of the key.
   // Returns a TPair* (need to downcast from TObject). Use Key() and
   // Value() to get the pointers to the key and value, respectively.
   // Returns 0 if not found.

   return fTable->FindObject(keyname);
}

//______________________________________________________________________________
TObject *TMap::FindObject(const TObject *key) const
{
   // Check if a (key,value) pair exists with key as key.
   // Returns a TPair* (need to downcast from TObject). Use Key() and
   // Value() to get the pointers to the key and value, respectively.
   // Returns 0 if not found.

   if (IsArgNull("FindObject", key)) return 0;

   return fTable->FindObject(key);
}

//______________________________________________________________________________
TObject *TMap::GetValue(const char *keyname) const
{
   // Returns a pointer to the value associated with keyname as name of the key.

   TPair *a = (TPair *)fTable->FindObject(keyname);
   if (a) return a->Value();
   return 0;
}

//______________________________________________________________________________
TObject *TMap::GetValue(const TObject *key) const
{
   // Returns a pointer to the value associated with key.

   if (IsArgNull("GetValue", key)) return 0;

   TPair *a = (TPair *)fTable->FindObject(key);
   if (a) return a->Value();
   return 0;
}

//______________________________________________________________________________
TIterator *TMap::MakeIterator(Bool_t dir) const
{
   // Create an iterator for TMap.

   return new TMapIter(this, dir);
}

//______________________________________________________________________________
void TMap::PrintCollectionEntry(TObject* entry, Option_t* option, Int_t recurse) const
{
   // Print the collection entry.

   TObject* val = GetValue(entry);

   TROOT::IndentLevel();
   printf("Key:   ");
   entry->Print();
   TROOT::IndentLevel();
   printf("Value: ");
   TCollection* coll = dynamic_cast<TCollection*>(val);
   if (coll) {
     coll->Print(option, recurse);
   } else {
     val->Print(option);
   }
}

//______________________________________________________________________________
void TMap::Rehash(Int_t newCapacity, Bool_t checkObjValidity)
{
   // Rehash the underlaying THashTable (see THashTable::Rehash()).

   fTable->Rehash(newCapacity, checkObjValidity);
}

//______________________________________________________________________________
TObject *TMap::Remove(TObject *key)
{
   // Remove the (key,value) pair with key from the map. Returns the
   // key object or 0 in case key was not found. If map is the owner
   // of values, the value is deleted.

   if (!key) return 0;

   TPair *a;
   if ((a = (TPair *)fTable->FindObject(key))) {
      if (fTable->Remove(key)) {
         if (IsOwnerValue() && a->Value() && a->Value()->IsOnHeap())
            TCollection::GarbageCollect(a->Value());
         TObject *kobj = a->Key();
         delete a;
         fSize--;
         return kobj;
      }
   }
   return 0;
}

//______________________________________________________________________________
TPair *TMap::RemoveEntry(TObject *key)
{
   // Remove (key,value) pair with key from the map. Returns the
   // pair object or 0 in case the key was not found.
   // It is caller's responsibility to delete the pair and, eventually,
   // the key and value objects.

   if (!key) return 0;

   TPair *a;
   if ((a = (TPair *)fTable->FindObject(key))) {
      if (fTable->Remove(key)) {
         fSize--;
         return a;
      }
   }
   return 0;
}

//______________________________________________________________________________
void TMap::SetOwnerValue(Bool_t enable)
{
   // Set whether this map is the owner (enable==true)
   // of its values.  If it is the owner of its contents,
   // these objects will be deleted whenever the collection itself
   // is deleted. The objects might also be deleted or destructed when Clear
   // is called (depending on the collection).

   if (enable)
      SetBit(kIsOwnerValue);
   else
      ResetBit(kIsOwnerValue);
}

//______________________________________________________________________________
void TMap::SetOwnerKeyValue(Bool_t ownkeys, Bool_t ownvals)
{
   // Set ownership for keys and values.

   SetOwner(ownkeys);
   SetOwnerValue(ownvals);
}

//______________________________________________________________________________
void TMap::Streamer(TBuffer &b)
{
   // Stream all key/value pairs in the map to or from the I/O buffer.

   TObject *obj=0;
   UInt_t R__s, R__c;

   if (b.IsReading()) {
      Int_t    nobjects;
      TObject *value=0;

      Version_t v = b.ReadVersion(&R__s, &R__c);
      if (v > 2)
         TObject::Streamer(b);
      if (v > 1)
         fName.Streamer(b);
      b >> nobjects;
      for (Int_t i = 0; i < nobjects; i++) {
         b >> obj;
         b >> value;
         if (obj) Add(obj, value);
      }
      b.CheckByteCount(R__s, R__c,TMap::IsA());
   } else {
      R__c = b.WriteVersion(TMap::IsA(), kTRUE);
      TObject::Streamer(b);
      fName.Streamer(b);
      b << GetSize();
      TIter next(fTable);
      TPair *a;
      while ((a = (TPair*) next())) {
         b << a->Key();
         b << a->Value();
      }
      b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
Int_t TMap::Write(const char *name, Int_t option, Int_t bsize) const
{
   // Write all objects in this map. By default all objects in
   // the collection are written individually (each object gets its
   // own key). Note, this is recursive, i.e. objects in collections
   // in the collection are also written individually. To write all
   // objects using a single key specify a name and set option to
   // TObject::kSingleKey (i.e. 1).

   if ((option & kSingleKey)) {
      return TObject::Write(name, option, bsize);
   } else {
      option &= ~kSingleKey;
      Int_t nbytes = 0;
      TIter next(fTable);
      TPair *a;
      while ((a = (TPair*) next())) {
         if (a->Key())
            nbytes += a->Key()->Write(name, option, bsize);
         if (a->Value())
            nbytes += a->Value()->Write(name, option, bsize);
      }
      return nbytes;
   }
}

//______________________________________________________________________________
Int_t TMap::Write(const char *name, Int_t option, Int_t bsize)
{
   // Write all objects in this map. By default all objects in
   // the collection are written individually (each object gets its
   // own key). Note, this is recursive, i.e. objects in collections
   // in the collection are also written individually. To write all
   // objects using a single key specify a name and set option to
   // TObject::kSingleKey (i.e. 1).

   return ((const TMap*)this)->Write(name,option,bsize);
}


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TPair                                                                //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
void TPair::Browse(TBrowser *b)
{
   // Browse the pair.

   if (b) {
      if (fKey)   b->Add(fKey);
      if (fValue) b->Add(fValue);
   } else {
      if (fKey)   fKey->Browse(b);
      if (fValue) fValue->Browse(b);
   }
}

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMapIter                                                             //
//                                                                      //
// Iterator of map.                                                     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

ClassImp(TMapIter)

//______________________________________________________________________________
TMapIter::TMapIter(const TMap *m, Bool_t dir)
{
   // Create a map iterator. Use dir to specify the desired iteration direction.

   fMap        = m;
   fDirection  = dir;
   fCursor     = 0;
}

//______________________________________________________________________________
TMapIter::TMapIter(const TMapIter &iter) : TIterator(iter)
{
   // Copy ctor.

   fMap       = iter.fMap;
   fDirection = iter.fDirection;
   fCursor    = 0;
   if (iter.fCursor) {
      fCursor = (THashTableIter *)iter.fCursor->GetCollection()->MakeIterator();
      if (fCursor)
         fCursor->operator=(*iter.fCursor);
   }
}

//______________________________________________________________________________
TIterator &TMapIter::operator=(const TIterator &rhs)
{
   // Overridden assignment operator.

   if (this != &rhs && rhs.IsA() == TMapIter::Class()) {
      const TMapIter &rhs1 = (const TMapIter &)rhs;
      fMap       = rhs1.fMap;
      fDirection = rhs1.fDirection;
      if (rhs1.fCursor) {
         fCursor = (THashTableIter *)rhs1.fCursor->GetCollection()->MakeIterator();
         if (fCursor)
            fCursor->operator=(*rhs1.fCursor);
      }
   }
   return *this;
}

//______________________________________________________________________________
TMapIter &TMapIter::operator=(const TMapIter &rhs)
{
   // Overloaded assignment operator.

   if (this != &rhs) {
      fMap       = rhs.fMap;
      fDirection = rhs.fDirection;
      if (rhs.fCursor) {
         fCursor = (THashTableIter *)rhs.fCursor->GetCollection()->MakeIterator();
         if (fCursor)
            fCursor->operator=(*rhs.fCursor);
      }
   }
   return *this;
}

//______________________________________________________________________________
TMapIter::~TMapIter()
{
   // Map iterator dtor.

   Reset();
}

//______________________________________________________________________________
TObject *TMapIter::Next()
{
   // Returns the next key from a map. Use TMap::GetValue() to get the value
   // associated with the key. Returns 0 when no more items in map.

   if (!fCursor)
      fCursor = new THashTableIter(fMap->fTable, fDirection);

   TPair *a = (TPair *)fCursor->Next();
   if (a) return a->Key();
   return 0;
}

//______________________________________________________________________________
void TMapIter::Reset()
{
   // Reset the map iterator.

   SafeDelete(fCursor);
}

//______________________________________________________________________________
Bool_t TMapIter::operator!=(const TIterator &aIter) const
{
   // This operator compares two TIterator objects.

   if (nullptr == (&aIter))
      return fCursor->operator*();

   if (aIter.IsA() == TMapIter::Class()) {
      const TMapIter &iter(dynamic_cast<const TMapIter &>(aIter));
      return (fCursor->operator*() != iter.fCursor->operator*());
   }
   return false; // for base class we don't implement a comparison
}

//______________________________________________________________________________
Bool_t TMapIter::operator!=(const TMapIter &aIter) const
{
   // This operator compares two TMapIter objects.

   if (nullptr == (&aIter))
      return fCursor->operator*();

   return (fCursor->operator*() != aIter.fCursor->operator*());
}

//______________________________________________________________________________
TObject *TMapIter::operator*() const
{
   // Return pointer to current object (a TPair) or nullptr.

   return (fCursor ? fCursor->operator*() : nullptr);
}
 TMap.cxx:1
 TMap.cxx:2
 TMap.cxx:3
 TMap.cxx:4
 TMap.cxx:5
 TMap.cxx:6
 TMap.cxx:7
 TMap.cxx:8
 TMap.cxx:9
 TMap.cxx:10
 TMap.cxx:11
 TMap.cxx:12
 TMap.cxx:13
 TMap.cxx:14
 TMap.cxx:15
 TMap.cxx:16
 TMap.cxx:17
 TMap.cxx:18
 TMap.cxx:19
 TMap.cxx:20
 TMap.cxx:21
 TMap.cxx:22
 TMap.cxx:23
 TMap.cxx:24
 TMap.cxx:25
 TMap.cxx:26
 TMap.cxx:27
 TMap.cxx:28
 TMap.cxx:29
 TMap.cxx:30
 TMap.cxx:31
 TMap.cxx:32
 TMap.cxx:33
 TMap.cxx:34
 TMap.cxx:35
 TMap.cxx:36
 TMap.cxx:37
 TMap.cxx:38
 TMap.cxx:39
 TMap.cxx:40
 TMap.cxx:41
 TMap.cxx:42
 TMap.cxx:43
 TMap.cxx:44
 TMap.cxx:45
 TMap.cxx:46
 TMap.cxx:47
 TMap.cxx:48
 TMap.cxx:49
 TMap.cxx:50
 TMap.cxx:51
 TMap.cxx:52
 TMap.cxx:53
 TMap.cxx:54
 TMap.cxx:55
 TMap.cxx:56
 TMap.cxx:57
 TMap.cxx:58
 TMap.cxx:59
 TMap.cxx:60
 TMap.cxx:61
 TMap.cxx:62
 TMap.cxx:63
 TMap.cxx:64
 TMap.cxx:65
 TMap.cxx:66
 TMap.cxx:67
 TMap.cxx:68
 TMap.cxx:69
 TMap.cxx:70
 TMap.cxx:71
 TMap.cxx:72
 TMap.cxx:73
 TMap.cxx:74
 TMap.cxx:75
 TMap.cxx:76
 TMap.cxx:77
 TMap.cxx:78
 TMap.cxx:79
 TMap.cxx:80
 TMap.cxx:81
 TMap.cxx:82
 TMap.cxx:83
 TMap.cxx:84
 TMap.cxx:85
 TMap.cxx:86
 TMap.cxx:87
 TMap.cxx:88
 TMap.cxx:89
 TMap.cxx:90
 TMap.cxx:91
 TMap.cxx:92
 TMap.cxx:93
 TMap.cxx:94
 TMap.cxx:95
 TMap.cxx:96
 TMap.cxx:97
 TMap.cxx:98
 TMap.cxx:99
 TMap.cxx:100
 TMap.cxx:101
 TMap.cxx:102
 TMap.cxx:103
 TMap.cxx:104
 TMap.cxx:105
 TMap.cxx:106
 TMap.cxx:107
 TMap.cxx:108
 TMap.cxx:109
 TMap.cxx:110
 TMap.cxx:111
 TMap.cxx:112
 TMap.cxx:113
 TMap.cxx:114
 TMap.cxx:115
 TMap.cxx:116
 TMap.cxx:117
 TMap.cxx:118
 TMap.cxx:119
 TMap.cxx:120
 TMap.cxx:121
 TMap.cxx:122
 TMap.cxx:123
 TMap.cxx:124
 TMap.cxx:125
 TMap.cxx:126
 TMap.cxx:127
 TMap.cxx:128
 TMap.cxx:129
 TMap.cxx:130
 TMap.cxx:131
 TMap.cxx:132
 TMap.cxx:133
 TMap.cxx:134
 TMap.cxx:135
 TMap.cxx:136
 TMap.cxx:137
 TMap.cxx:138
 TMap.cxx:139
 TMap.cxx:140
 TMap.cxx:141
 TMap.cxx:142
 TMap.cxx:143
 TMap.cxx:144
 TMap.cxx:145
 TMap.cxx:146
 TMap.cxx:147
 TMap.cxx:148
 TMap.cxx:149
 TMap.cxx:150
 TMap.cxx:151
 TMap.cxx:152
 TMap.cxx:153
 TMap.cxx:154
 TMap.cxx:155
 TMap.cxx:156
 TMap.cxx:157
 TMap.cxx:158
 TMap.cxx:159
 TMap.cxx:160
 TMap.cxx:161
 TMap.cxx:162
 TMap.cxx:163
 TMap.cxx:164
 TMap.cxx:165
 TMap.cxx:166
 TMap.cxx:167
 TMap.cxx:168
 TMap.cxx:169
 TMap.cxx:170
 TMap.cxx:171
 TMap.cxx:172
 TMap.cxx:173
 TMap.cxx:174
 TMap.cxx:175
 TMap.cxx:176
 TMap.cxx:177
 TMap.cxx:178
 TMap.cxx:179
 TMap.cxx:180
 TMap.cxx:181
 TMap.cxx:182
 TMap.cxx:183
 TMap.cxx:184
 TMap.cxx:185
 TMap.cxx:186
 TMap.cxx:187
 TMap.cxx:188
 TMap.cxx:189
 TMap.cxx:190
 TMap.cxx:191
 TMap.cxx:192
 TMap.cxx:193
 TMap.cxx:194
 TMap.cxx:195
 TMap.cxx:196
 TMap.cxx:197
 TMap.cxx:198
 TMap.cxx:199
 TMap.cxx:200
 TMap.cxx:201
 TMap.cxx:202
 TMap.cxx:203
 TMap.cxx:204
 TMap.cxx:205
 TMap.cxx:206
 TMap.cxx:207
 TMap.cxx:208
 TMap.cxx:209
 TMap.cxx:210
 TMap.cxx:211
 TMap.cxx:212
 TMap.cxx:213
 TMap.cxx:214
 TMap.cxx:215
 TMap.cxx:216
 TMap.cxx:217
 TMap.cxx:218
 TMap.cxx:219
 TMap.cxx:220
 TMap.cxx:221
 TMap.cxx:222
 TMap.cxx:223
 TMap.cxx:224
 TMap.cxx:225
 TMap.cxx:226
 TMap.cxx:227
 TMap.cxx:228
 TMap.cxx:229
 TMap.cxx:230
 TMap.cxx:231
 TMap.cxx:232
 TMap.cxx:233
 TMap.cxx:234
 TMap.cxx:235
 TMap.cxx:236
 TMap.cxx:237
 TMap.cxx:238
 TMap.cxx:239
 TMap.cxx:240
 TMap.cxx:241
 TMap.cxx:242
 TMap.cxx:243
 TMap.cxx:244
 TMap.cxx:245
 TMap.cxx:246
 TMap.cxx:247
 TMap.cxx:248
 TMap.cxx:249
 TMap.cxx:250
 TMap.cxx:251
 TMap.cxx:252
 TMap.cxx:253
 TMap.cxx:254
 TMap.cxx:255
 TMap.cxx:256
 TMap.cxx:257
 TMap.cxx:258
 TMap.cxx:259
 TMap.cxx:260
 TMap.cxx:261
 TMap.cxx:262
 TMap.cxx:263
 TMap.cxx:264
 TMap.cxx:265
 TMap.cxx:266
 TMap.cxx:267
 TMap.cxx:268
 TMap.cxx:269
 TMap.cxx:270
 TMap.cxx:271
 TMap.cxx:272
 TMap.cxx:273
 TMap.cxx:274
 TMap.cxx:275
 TMap.cxx:276
 TMap.cxx:277
 TMap.cxx:278
 TMap.cxx:279
 TMap.cxx:280
 TMap.cxx:281
 TMap.cxx:282
 TMap.cxx:283
 TMap.cxx:284
 TMap.cxx:285
 TMap.cxx:286
 TMap.cxx:287
 TMap.cxx:288
 TMap.cxx:289
 TMap.cxx:290
 TMap.cxx:291
 TMap.cxx:292
 TMap.cxx:293
 TMap.cxx:294
 TMap.cxx:295
 TMap.cxx:296
 TMap.cxx:297
 TMap.cxx:298
 TMap.cxx:299
 TMap.cxx:300
 TMap.cxx:301
 TMap.cxx:302
 TMap.cxx:303
 TMap.cxx:304
 TMap.cxx:305
 TMap.cxx:306
 TMap.cxx:307
 TMap.cxx:308
 TMap.cxx:309
 TMap.cxx:310
 TMap.cxx:311
 TMap.cxx:312
 TMap.cxx:313
 TMap.cxx:314
 TMap.cxx:315
 TMap.cxx:316
 TMap.cxx:317
 TMap.cxx:318
 TMap.cxx:319
 TMap.cxx:320
 TMap.cxx:321
 TMap.cxx:322
 TMap.cxx:323
 TMap.cxx:324
 TMap.cxx:325
 TMap.cxx:326
 TMap.cxx:327
 TMap.cxx:328
 TMap.cxx:329
 TMap.cxx:330
 TMap.cxx:331
 TMap.cxx:332
 TMap.cxx:333
 TMap.cxx:334
 TMap.cxx:335
 TMap.cxx:336
 TMap.cxx:337
 TMap.cxx:338
 TMap.cxx:339
 TMap.cxx:340
 TMap.cxx:341
 TMap.cxx:342
 TMap.cxx:343
 TMap.cxx:344
 TMap.cxx:345
 TMap.cxx:346
 TMap.cxx:347
 TMap.cxx:348
 TMap.cxx:349
 TMap.cxx:350
 TMap.cxx:351
 TMap.cxx:352
 TMap.cxx:353
 TMap.cxx:354
 TMap.cxx:355
 TMap.cxx:356
 TMap.cxx:357
 TMap.cxx:358
 TMap.cxx:359
 TMap.cxx:360
 TMap.cxx:361
 TMap.cxx:362
 TMap.cxx:363
 TMap.cxx:364
 TMap.cxx:365
 TMap.cxx:366
 TMap.cxx:367
 TMap.cxx:368
 TMap.cxx:369
 TMap.cxx:370
 TMap.cxx:371
 TMap.cxx:372
 TMap.cxx:373
 TMap.cxx:374
 TMap.cxx:375
 TMap.cxx:376
 TMap.cxx:377
 TMap.cxx:378
 TMap.cxx:379
 TMap.cxx:380
 TMap.cxx:381
 TMap.cxx:382
 TMap.cxx:383
 TMap.cxx:384
 TMap.cxx:385
 TMap.cxx:386
 TMap.cxx:387
 TMap.cxx:388
 TMap.cxx:389
 TMap.cxx:390
 TMap.cxx:391
 TMap.cxx:392
 TMap.cxx:393
 TMap.cxx:394
 TMap.cxx:395
 TMap.cxx:396
 TMap.cxx:397
 TMap.cxx:398
 TMap.cxx:399
 TMap.cxx:400
 TMap.cxx:401
 TMap.cxx:402
 TMap.cxx:403
 TMap.cxx:404
 TMap.cxx:405
 TMap.cxx:406
 TMap.cxx:407
 TMap.cxx:408
 TMap.cxx:409
 TMap.cxx:410
 TMap.cxx:411
 TMap.cxx:412
 TMap.cxx:413
 TMap.cxx:414
 TMap.cxx:415
 TMap.cxx:416
 TMap.cxx:417
 TMap.cxx:418
 TMap.cxx:419
 TMap.cxx:420
 TMap.cxx:421
 TMap.cxx:422
 TMap.cxx:423
 TMap.cxx:424
 TMap.cxx:425
 TMap.cxx:426
 TMap.cxx:427
 TMap.cxx:428
 TMap.cxx:429
 TMap.cxx:430
 TMap.cxx:431
 TMap.cxx:432
 TMap.cxx:433
 TMap.cxx:434
 TMap.cxx:435
 TMap.cxx:436
 TMap.cxx:437
 TMap.cxx:438
 TMap.cxx:439
 TMap.cxx:440
 TMap.cxx:441
 TMap.cxx:442
 TMap.cxx:443
 TMap.cxx:444
 TMap.cxx:445
 TMap.cxx:446
 TMap.cxx:447
 TMap.cxx:448
 TMap.cxx:449
 TMap.cxx:450
 TMap.cxx:451
 TMap.cxx:452
 TMap.cxx:453
 TMap.cxx:454
 TMap.cxx:455
 TMap.cxx:456
 TMap.cxx:457
 TMap.cxx:458
 TMap.cxx:459
 TMap.cxx:460
 TMap.cxx:461
 TMap.cxx:462
 TMap.cxx:463
 TMap.cxx:464
 TMap.cxx:465
 TMap.cxx:466
 TMap.cxx:467
 TMap.cxx:468
 TMap.cxx:469
 TMap.cxx:470
 TMap.cxx:471
 TMap.cxx:472
 TMap.cxx:473
 TMap.cxx:474
 TMap.cxx:475
 TMap.cxx:476
 TMap.cxx:477
 TMap.cxx:478
 TMap.cxx:479
 TMap.cxx:480
 TMap.cxx:481
 TMap.cxx:482
 TMap.cxx:483
 TMap.cxx:484
 TMap.cxx:485
 TMap.cxx:486
 TMap.cxx:487
 TMap.cxx:488
 TMap.cxx:489
 TMap.cxx:490
 TMap.cxx:491
 TMap.cxx:492
 TMap.cxx:493
 TMap.cxx:494
 TMap.cxx:495
 TMap.cxx:496
 TMap.cxx:497
 TMap.cxx:498
 TMap.cxx:499
 TMap.cxx:500
 TMap.cxx:501
 TMap.cxx:502
 TMap.cxx:503
 TMap.cxx:504
 TMap.cxx:505
 TMap.cxx:506
 TMap.cxx:507
 TMap.cxx:508
 TMap.cxx:509
 TMap.cxx:510
 TMap.cxx:511
 TMap.cxx:512
 TMap.cxx:513
 TMap.cxx:514
 TMap.cxx:515
 TMap.cxx:516
 TMap.cxx:517
 TMap.cxx:518
 TMap.cxx:519
 TMap.cxx:520
 TMap.cxx:521
 TMap.cxx:522
 TMap.cxx:523
 TMap.cxx:524
 TMap.cxx:525
 TMap.cxx:526
 TMap.cxx:527
 TMap.cxx:528
 TMap.cxx:529
 TMap.cxx:530
 TMap.cxx:531
 TMap.cxx:532
 TMap.cxx:533
 TMap.cxx:534
 TMap.cxx:535
 TMap.cxx:536
 TMap.cxx:537
 TMap.cxx:538
 TMap.cxx:539
 TMap.cxx:540
 TMap.cxx:541
 TMap.cxx:542
 TMap.cxx:543
 TMap.cxx:544
 TMap.cxx:545
 TMap.cxx:546
 TMap.cxx:547
 TMap.cxx:548
 TMap.cxx:549
 TMap.cxx:550
 TMap.cxx:551
 TMap.cxx:552
 TMap.cxx:553
 TMap.cxx:554
 TMap.cxx:555
 TMap.cxx:556
 TMap.cxx:557
 TMap.cxx:558
 TMap.cxx:559
 TMap.cxx:560
 TMap.cxx:561
 TMap.cxx:562
 TMap.cxx:563
 TMap.cxx:564
 TMap.cxx:565
 TMap.cxx:566
 TMap.cxx:567
 TMap.cxx:568
 TMap.cxx:569
 TMap.cxx:570
 TMap.cxx:571
 TMap.cxx:572
 TMap.cxx:573
 TMap.cxx:574
 TMap.cxx:575
 TMap.cxx:576
 TMap.cxx:577
 TMap.cxx:578
 TMap.cxx:579
 TMap.cxx:580
 TMap.cxx:581
 TMap.cxx:582
 TMap.cxx:583
 TMap.cxx:584
 TMap.cxx:585
 TMap.cxx:586
 TMap.cxx:587
 TMap.cxx:588
 TMap.cxx:589
 TMap.cxx:590
 TMap.cxx:591
 TMap.cxx:592
 TMap.cxx:593
 TMap.cxx:594
 TMap.cxx:595
 TMap.cxx:596
 TMap.cxx:597