AppleX509CL/LockedMap.h

   1 /*
   2  * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
   3  *
   4  * The contents of this file constitute Original Code as defined in and are
   5  * subject to the Apple Public Source License Version 1.2 (the 'License').
   6  * You may not use this file except in compliance with the License. Please obtain
   7  * a copy of the License at http://www.apple.com/publicsource and read it before
   8  * using this file.
   9  *
  10  * This Original Code and all software distributed under the License are
  11  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
  12  * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
  13  * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  14  * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
  15  * specific language governing rights and limitations under the License.
  16  */
  17
  18
  19 /*
  20  * LockedMap.h - STL-style map with attached Mutex
  21  *
  22  * Created 9/1/2000 by Doug Mitchell.
  23  * Copyright (c) 2000 by Apple Computer.
  24  */
  25
  26 #ifndef _LOCKED_MAP_H_
  27 #define _LOCKED_MAP_H_
  28
  29 #include <map>
  30 #include <Security/threading.h>
  31
  32 template <class KeyType, class ValueType>
  33 class LockedMap
  34 {
  35 private:
  36         typedef std::map<KeyType, ValueType *> MapType;
  37         MapType                                 mMap;
  38         Mutex                                   mMapLock;
  39
  40         /* low-level lookup, cacheMapLock held on entry and exit */
  41         ValueType
  42         *lookupEntryLocked(KeyType key)
  43                 {
  44                         // don't create new entry if desired entry isn't there
  45                         typename MapType::iterator it = mMap.find(key);
  46                         if(it == mMap.end()) {
  47                                 return NULL;
  48                         }
  49                         return it->second;
  50                 }
  51
  52 public:
  53         /* high level maintenance */
  54         void
  55         addEntry(ValueType &value, KeyType key)
  56                 {
  57                         StLock<Mutex> _(mMapLock);
  58                         mMap[key] = &value;
  59                 }
  60
  61         ValueType
  62         *lookupEntry(KeyType key)
  63                 {
  64                         StLock<Mutex> _(mMapLock);
  65                         return lookupEntryLocked(key);
  66                 }
  67
  68         void
  69         removeEntry(KeyType key)
  70                 {
  71                         StLock<Mutex> _(mMapLock);
  72
  73                         ValueType *value = lookupEntryLocked(key);
  74                         if(value != NULL) {
  75                                 mMap.erase(key);
  76                         }
  77                 }
  78
  79         ValueType
  80         *removeFirstEntry()
  81                 {
  82                         StLock<Mutex> _(mMapLock);
  83                         typename MapType::iterator it = mMap.begin();
  84                         if(it == mMap.end()) {
  85                                 return NULL;
  86                         }
  87                         ValueType *rtn = it->second;
  88                         mMap.erase(it->first);
  89                         return rtn;
  90                 }
  91 };
  92
  93 #endif  /* _LOCKED_MAP_H_ */