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 33namespace de 34{ 35 36void STLUtil_selfTest (void); 37 38//! Test whether `item` is a member of `container`. The type `C` must be an 39//! AssociativeContainer. 40 41template<typename C> 42inline 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 48template<typename I, typename K> 49inline 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 55template<typename C> 56C 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 64template<typename C> 65C 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. 76template <typename M> 77const 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. 87template<typename M> 88const 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. 98template<typename M> 99const 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. 109template<typename M> 110bool 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