OSX/libsecurity_apple_x509_cl/lib/LockedMap.h

   1 /*
   2  * Copyright (c) 2000-2001,2011,2014 Apple 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  * Copyright (c) 2000,2011,2014 Apple Inc.
  23  */
  24
  25 #ifndef _LOCKED_MAP_H_
  26 #define _LOCKED_MAP_H_
  27
  28 #include <map>
  29 #include <security_utilities/threading.h>
  30
  31 template <class KeyType, class ValueType>
  32 class LockedMap
  33 {
  34 private:
  35         typedef std::map<KeyType, ValueType *> MapType;
  36         MapType                                 mMap;
  37         Mutex                                   mMapLock;
  38
  39         /* low-level lookup, cacheMapLock held on entry and exit */
  40         ValueType
  41         *lookupEntryLocked(KeyType key)
  42                 {
  43                         // don't create new entry if desired entry isn't there
  44                         typename MapType::iterator it = mMap.find(key);
  45                         if(it == mMap.end()) {
  46                                 return NULL;
  47                         }
  48                         return it->second;
  49                 }
  50
  51 public:
  52         /* high level maintenance */
  53         void
  54         addEntry(ValueType &value, KeyType key)
  55                 {
  56                         StLock<Mutex> _(mMapLock);
  57                         mMap[key] = &value;
  58                 }
  59
  60         ValueType
  61         *lookupEntry(KeyType key)
  62                 {
  63                         StLock<Mutex> _(mMapLock);
  64                         return lookupEntryLocked(key);
  65                 }
  66
  67         void
  68         removeEntry(KeyType key)
  69                 {
  70                         StLock<Mutex> _(mMapLock);
  71
  72                         ValueType *value = lookupEntryLocked(key);
  73                         if(value != NULL) {
  74                                 mMap.erase(key);
  75                         }
  76                 }
  77
  78         ValueType
  79         *removeFirstEntry()
  80                 {
  81                         StLock<Mutex> _(mMapLock);
  82                         typename MapType::iterator it = mMap.begin();
  83                         if(it == mMap.end()) {
  84                                 return NULL;
  85                         }
  86                         ValueType *rtn = it->second;
  87                         mMap.erase(it->first);
  88                         return rtn;
  89                 }
  90 };
  91
  92 #endif  /* _LOCKED_MAP_H_ */