1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef PDFIUM_THIRD_PARTY_BASE_STL_UTIL_H_
#define PDFIUM_THIRD_PARTY_BASE_STL_UTIL_H_
#include <algorithm>
#include <iterator>
#include <memory>
#include <set>
#include <vector>
#include "third_party/base/numerics/safe_conversions.h"
#include "third_party/base/numerics/safe_math.h"
namespace pdfium {
// Test to see if a set, map, hash_set or hash_map contains a particular key.
// Returns true if the key is in the collection.
template <typename Collection, typename Key>
bool ContainsKey(const Collection& collection, const Key& key) {
return collection.find(key) != collection.end();
}
// Test to see if a collection like a vector contains a particular value.
// Returns true if the value is in the collection.
template <typename Collection, typename Value>
bool ContainsValue(const Collection& collection, const Value& value) {
return std::find(std::begin(collection), std::end(collection), value) !=
std::end(collection);
}
// Means of generating a key for searching STL collections of std::unique_ptr
// that avoids the side effect of deleting the pointer.
template <class T>
class FakeUniquePtr : public std::unique_ptr<T> {
public:
using std::unique_ptr<T>::unique_ptr;
~FakeUniquePtr() { std::unique_ptr<T>::release(); }
};
// Convenience routine for "int-fected" code, so that the stl collection
// size_t size() method return values will be checked.
template <typename ResultType, typename Collection>
ResultType CollectionSize(const Collection& collection) {
return pdfium::base::checked_cast<ResultType>(collection.size());
}
// Convenience routine for "int-fected" code, to handle signed indicies. The
// compiler can deduce the type, making this more convenient than the above.
template <typename IndexType, typename Collection>
bool IndexInBounds(const Collection& collection, IndexType index) {
return index >= 0 && index < CollectionSize<IndexType>(collection);
}
// Track the addition of an object to a set, removing it automatically when
// the ScopedSetInsertion goes out of scope.
template <typename T>
class ScopedSetInsertion {
public:
ScopedSetInsertion(std::set<T>* org_set, T elem)
: m_Set(org_set), m_Entry(elem) {
m_Set->insert(m_Entry);
}
~ScopedSetInsertion() { m_Set->erase(m_Entry); }
private:
std::set<T>* const m_Set;
const T m_Entry;
};
// std::clamp(), some day.
template <class T>
constexpr const T& clamp(const T& v, const T& lo, const T& hi) {
return std::min(std::max(v, lo), hi);
}
// Safely allocate a 1-dim vector big enough for |w| by |h| or die.
template <typename T>
std::vector<T> Vector2D(size_t w, size_t h) {
pdfium::base::CheckedNumeric<size_t> safe_size = w;
safe_size *= h;
return std::vector<T>(safe_size.ValueOrDie());
}
} // namespace pdfium
#endif // PDFIUM_THIRD_PARTY_BASE_STL_UTIL_H_
|
