• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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>
contains(const C & container,const typename C::key_type & item)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>
contains(const I & begin,const I & end,const K & item)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>
intersection(const C & s1,const C & s2)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>
set_union(const C & s1,const C & s2)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>
tryLookup(const M & map,const typename M::key_type & key)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>
lookupDefault(const M & map,const typename M::key_type & key,const typename M::mapped_type & fallback)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>
lookup(const M & map,const typename M::key_type & key)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>
insert(M & map,const typename M::key_type & key,const typename M::mapped_type & value)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
120