framework/delibs/decpp/deSTLUtil.hpp

   1 #ifndef _DESTLUTIL_HPP
   2 #define _DESTLUTIL_HPP
   3 /*-------------------------------------------------------------------------
   4  * drawElements C++ Base Library
   5  * -----------------------------
   6  *
   7  * Copyright 2014 The Android Open Source Project
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*!
  22  * \file
  23  * \brief Utilities for STL containers.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "deDefs.hpp"
  27
  28 #include <algorithm>
  29 #include <stdexcept>
  30 #include <utility>
  31 #include <iterator>
  32
  33 namespace de
  34 {
  35
  36 void STLUtil_selfTest (void);
  37
  38 //! Test whether `item` is a member of `container`. The type `C` must be an
  39 //! AssociativeContainer.
  40
  41 template<typename C>
  42 inline bool contains (const C& container, const typename C::key_type& item)
  43 {
  44         const typename C::const_iterator it = container.find(item);
  45         return (it != container.end());
  46 }
  47
  48 template<typename I, typename K>
  49 inline bool contains (const I& begin, const I& end, const K& item)
  50 {
  51         const I it = std::find(begin, end, item);
  52         return (it != end);
  53 }
  54
  55 template<typename C>
  56 C intersection (const C& s1, const C& s2)
  57 {
  58         C ret;
  59         std::set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(),
  60                                                   std::insert_iterator<C>(ret, ret.begin()));
  61         return ret;
  62 }
  63
  64 template<typename C>
  65 C set_union (const C& s1, const C& s2)
  66 {
  67         C ret;
  68         std::set_union(s1.begin(), s1.end(), s2.begin(), s2.end(),
  69                                    std::insert_iterator<C>(ret, ret.begin()));
  70         return ret;
  71 }
  72
  73 // Utilities for map-like container types
  74
  75 //! Return a pointer to the value mapped to `key`, or null if not found.
  76 template <typename M>
  77 const typename M::mapped_type* tryLookup (const M& map,
  78                                                                                   const typename M::key_type& key)
  79 {
  80         typename M::const_iterator it = map.find(key);
  81         if (it == map.end())
  82                 return DE_NULL;
  83         return &it->second;
  84 }
  85
  86 //! Return a reference to the value mapped to `key`, or `fallback` if not found.
  87 template<typename M>
  88 const typename M::mapped_type& lookupDefault (const M&                                                  map,
  89                                                                                           const typename M::key_type&           key,
  90                                                                                           const typename M::mapped_type&        fallback)
  91 {
  92         const typename M::mapped_type* ptr = tryLookup(map, key);
  93         return ptr == DE_NULL ? fallback : *ptr;
  94 }
  95
  96 //! Return a reference to the value mapped to `key`, or raise
  97 //! `std::out_of_range` if not found.
  98 template<typename M>
  99 const typename M::mapped_type& lookup (const M& map, const typename M::key_type& key)
 100 {
 101         const typename M::mapped_type* ptr = tryLookup(map, key);
 102         if (ptr == DE_NULL)
 103                 throw std::out_of_range("key not found in map");
 104         return *ptr;
 105 }
 106
 107 //! Map `key` to `value`. This differs from `map[key] = value` in that there
 108 //! is no default construction and assignment involved.
 109 template<typename M>
 110 bool insert (M& map, const typename M::key_type& key, const typename M::mapped_type& value)
 111 {
 112         typename M::value_type entry(key, value);
 113         std::pair<typename M::iterator,bool> ret = map.insert(entry);
 114         return ret.second;
 115 }
 116
 117 } // de
 118
 119 #endif // _DESTLUTIL_HPP