HLT/MUON/AliHLTMUONCountedList.h

   1 #ifndef ALIHLTMUONCOUNTEDLIST_H
   2 #define ALIHLTMUONCOUNTEDLIST_H
   3 /**************************************************************************
   4  * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
   5  *                                                                        *
   6  * Author: The ALICE Off-line Project.                                    *
   7  * Contributors are mentioned in the code where appropriate.              *
   8  *                                                                        *
   9  * Permission to use, copy, modify and distribute this software and its   *
  10  * documentation strictly for non-commercial purposes is hereby granted   *
  11  * without fee, provided that the above copyright notice appears in all   *
  12  * copies and that both the copyright notice and this permission notice   *
  13  * appear in the supporting documentation. The authors make no claims     *
  14  * about the suitability of this software for any purpose. It is          *
  15  * provided "as is" without express or implied warranty.                  *
  16  **************************************************************************/
  17
  18 // $Id$
  19
  20 /**
  21  * @file   AliHLTMUONCountedList.h
  22  * @author Artur Szostak <artursz@iafrica.com>
  23  * @date
  24  * @brief  Declaration of a linked-list class which counts the number of
  25  *         elements it contains.
  26  */
  27
  28 #include "AliHLTMUONList.h"
  29
  30 /**
  31  * The AliHLTMUONCountedList class behaves just like the AliHLTMUONList class
  32  * but uses an internal counter to count the number of elements in the list.
  33  * This means calls to Count() are much more efficient.
  34  */
  35 template <typename DataType>
  36 class AliHLTMUONCountedList : public AliHLTMUONList<DataType>
  37 {
  38 public:
  39
  40         typedef typename AliHLTMUONList<DataType>::Iterator Iterator;
  41         typedef typename AliHLTMUONList<DataType>::ConstIterator ConstIterator;
  42
  43         AliHLTMUONCountedList(AliHLTUInt32_t maxentries = 1024*4) :
  44                 AliHLTMUONList<DataType>(maxentries), fCount(0)
  45         {}
  46
  47         // Perform a deep copy.
  48         AliHLTMUONCountedList(const AliHLTMUONCountedList& list)
  49                 : AliHLTMUONList<DataType>(list), fCount(list.fCount)
  50         {}
  51
  52         // Perform a deep copy.
  53         AliHLTMUONCountedList& operator = (const AliHLTMUONCountedList& list)
  54         {
  55                 AliHLTMUONList<DataType>::operator = (list);
  56                 fCount = list.fCount;
  57                 return *this;
  58         }
  59
  60         virtual ~AliHLTMUONCountedList() {} // Just to make gcc -Weffc++ option shutup.
  61
  62         /**
  63          * Adds a new element to the start of the linked list.
  64          * @return  The pointer to the new element to fill its fields.
  65          */
  66         DataType* Add()
  67         {
  68                 DataType* newdata = AliHLTMUONList<DataType>::Add();
  69                 fCount++;
  70                 return newdata;
  71         }
  72
  73         /**
  74          * Adds a new element to the start of the linked list and fills it with
  75          * the data specified in 'data'.
  76          * @param data  The value to set the new element to.
  77          */
  78         void Add(const DataType& data)
  79         {
  80                 AliHLTMUONList<DataType>::Add(data);
  81                 fCount++;
  82         }
  83
  84         /**
  85          * Searches the list if the element 'data' is already in the list. If it
  86          * is then a pointer to the existing element is returned, otherwise a new
  87          * element is created and a pointer to it is returned.
  88          * @param data  The value to search for or set the new element to.
  89          * @return  A pointer to the existing or new element.
  90          */
  91         DataType* AddUniquely(const DataType& data)
  92         {
  93                 Iterator result = Find(data);
  94                 if (result == ConstIterator(NULL))
  95                 {
  96                         DataType* newdata = Add();
  97                         *newdata = data;
  98                         return newdata;
  99                 }
 100                 else
 101                         return result;
 102         }
 103
 104         /**
 105          * Removes the index'th element from the list.
 106          * No error checking is done so there better be at least 'index' number
 107          * of entries in the list. You can use Count() to find out how many
 108          * entries there are.
 109          */
 110         void Remove(const AliHLTUInt32_t index)
 111         {
 112                 AliHLTMUONList<DataType>::Remove(index);
 113                 fCount--;
 114         }
 115
 116         /**
 117          * Looks for the entry with the same values as 'data' and removes it
 118          * from the list. If the entry could not be found then false is returned.
 119          * However if it is found then it is deleted and true is returned.
 120          */
 121         bool Remove(const DataType& data)
 122         {
 123                 Iterator current = Find(data);
 124                 if ( current != ConstIterator(NULL) )
 125                 {
 126                         Remove(current);
 127                         return true;
 128                 }
 129                 else
 130                         return false;
 131         }
 132
 133         /**
 134          * Removes the entry pointed to by the iterator which must have been
 135          * extracted from the list with a call to First() and/or several calls
 136          * to the iterators increment operators.
 137          * @param iter  The entry to remove from the list.
 138          */
 139         void Remove(Iterator& iter)
 140         {
 141                 AliHLTMUONList<DataType>::Remove(iter);
 142                 fCount--;
 143         }
 144
 145         /**
 146          * This deletes all elements from the list.
 147          */
 148         void Clear()
 149         {
 150                 AliHLTMUONList<DataType>::Clear();
 151                 fCount = 0;
 152         }
 153
 154         /**
 155          * This deletes all elements from the list and resizes the buffer which
 156          * is used to store the entries for the list.
 157          */
 158         void Clear(AliHLTUInt32_t maxentries) throw(std::bad_alloc)
 159         {
 160                 AliHLTMUONList<DataType>::Clear(maxentries);
 161                 fCount = 0;
 162         }
 163
 164         /**
 165          * Counts and returns the number of elements in the list.
 166          */
 167         AliHLTUInt32_t Count() const { return fCount; }
 168
 169 protected:
 170
 171         AliHLTUInt32_t fCount;
 172 };
 173
 174
 175 #endif // ALIHLTMUONCOUNTEDLIST_H