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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
| folly/AtomicHashMap.h: * Insert returns false if there is a key collision and throws if the max size
folly/AtomicHashMap.h: * AtomicHashMapFullError is thrown.
folly/ProducerConsumerQueue.h: throw std::bad_alloc();
folly/json.h: * system, the serializer will throw.
folly/json.h: * precisely represented by fit a double---instead, throws an
folly/dynamic-inl.h: * double, or throws if either is not a numeric type.
folly/dynamic-inl.h: throw TypeError("numeric", a.type(), b.type());
folly/dynamic-inl.h:inline bool dynamic::isString() const { return get_nothrow<fbstring>(); }
folly/dynamic-inl.h:inline bool dynamic::isObject() const { return get_nothrow<ObjectImpl>(); }
folly/dynamic-inl.h:inline bool dynamic::isBool() const { return get_nothrow<bool>(); }
folly/dynamic-inl.h:inline bool dynamic::isArray() const { return get_nothrow<Array>(); }
folly/dynamic-inl.h:inline bool dynamic::isDouble() const { return get_nothrow<double>(); }
folly/dynamic-inl.h:inline bool dynamic::isInt() const { return get_nothrow<int64_t>(); }
folly/dynamic-inl.h:inline bool dynamic::isNull() const { return get_nothrow<void*>(); }
folly/dynamic-inl.h: throw TypeError("object", type_);
folly/dynamic-inl.h: throw TypeError("int64", type(), o.type()); \
folly/dynamic-inl.h: throw TypeError("object/array", type());
folly/dynamic-inl.h: throw TypeError("object/array", type());
folly/dynamic-inl.h: if (auto* parray = get_nothrow<Array>()) {
folly/dynamic-inl.h: throw std::out_of_range("out of range in dynamic array");
folly/dynamic-inl.h: throw TypeError("int64", idx.type());
folly/dynamic-inl.h: auto* pobj = get_nothrow<ObjectImpl>();
folly/dynamic-inl.h: throw std::out_of_range(to<std::string>(
folly/dynamic-inl.h: if (auto* ar = get_nothrow<Array>()) {
folly/dynamic-inl.h: if (auto* obj = get_nothrow<ObjectImpl>()) {
folly/dynamic-inl.h: if (auto* str = get_nothrow<fbstring>()) {
folly/dynamic-inl.h: throw TypeError("array/object", type());
folly/dynamic-inl.h: throw TypeError("not null/object/array", type());
folly/dynamic-inl.h: case INT64: return to<T>(*get_nothrow<int64_t>());
folly/dynamic-inl.h: case DOUBLE: return to<T>(*get_nothrow<double>());
folly/dynamic-inl.h: case BOOL: return to<T>(*get_nothrow<bool>());
folly/dynamic-inl.h: case STRING: return to<T>(*get_nothrow<fbstring>());
folly/dynamic-inl.h: throw TypeError("int/double/bool/string", type());
folly/dynamic-inl.h:T* dynamic::get_nothrow() {
folly/dynamic-inl.h:T const* dynamic::get_nothrow() const {
folly/dynamic-inl.h: return const_cast<dynamic*>(this)->get_nothrow<T>();
folly/dynamic-inl.h: if (auto* p = get_nothrow<T>()) {
folly/dynamic-inl.h: throw TypeError(TypeInfo<T>::name, type());
folly/docs/Dynamic.md:`folly::TypeError`. Other exceptions can also be thrown if
folly/docs/Dynamic.md: dynamic hugeDoub = hugeInt.asDouble(); // throws a folly/Conv.h error,
folly/docs/Conv.md:* Otherwise, `to` inserts bounds checks and throws
folly/docs/FBVector.md:assignment is the same as bitblitting the bits over) or a nothrow
folly/docs/FBVector.md: (boost::has_trivial_assign<T>::value || boost::has_nothrow_constructor<T>::value));
folly/FormatArg.h: * Validate the argument for the given type; throws on error.
folly/FormatArg.h: * is thrown otherwise).
folly/FormatArg.h: * integer (an exception is thrown otherwise).
folly/FormatArg.h: throw std::invalid_argument(to<std::string>(
folly/Conv.h: ((condition) ? (void)0 : throw std::range_error( \
folly/Conv.h: * in which case digits_to throws.
folly/Conv.h: throw std::range_error("Cannot convert string " +
folly/Conv.h: throw std::range_error("Unable to convert an empty string"
folly/Conv.h: throw std::range_error("Unable to convert \"" + src->toString()
folly/Conv.h: throw std::range_error(
folly/sorted_vector_types.h: // Nothrow as long as swap() on the Compare type is nothrow.
folly/sorted_vector_types.h: // Nothrow as long as swap() on the Compare type is nothrow.
folly/test/DiscriminatedPtrTest.cpp: EXPECT_EQ(&a, p.get_nothrow<int>());
folly/test/DiscriminatedPtrTest.cpp: EXPECT_EQ(&a, static_cast<const Ptr&>(p).get_nothrow<int>());
folly/test/DiscriminatedPtrTest.cpp: EXPECT_EQ(static_cast<void*>(NULL), p.get_nothrow<void>());
folly/test/DiscriminatedPtrTest.cpp: EXPECT_EQ(static_cast<int*>(NULL), p.get_nothrow<int>());
folly/test/ScopeGuardTest.cpp: throw std::runtime_error("destructors should never throw!");
folly/test/ScopeGuardTest.cpp: "destructors should never throw");
folly/test/ScopeGuardTest.cpp: * to close a db connection regardless if an exception was thrown during
folly/test/ScopeGuardTest.cpp: * throw e; // re-throw the exception
folly/test/ScopeGuardTest.cpp: throw std::runtime_error("throwing an expected error");
folly/test/ScopeGuardTest.cpp: throw "never throw raw strings";
folly/test/ScopeGuardTest.cpp: throw std::runtime_error("test");
folly/test/FBStringLibstdcxxStdexceptTest.cpp: (use std::__throw_* from funcexcept.h instead)
folly/test/ConvTest.cpp: // However, if the next character would cause an overflow it throws a
folly/test/ConvTest.cpp: throw std::runtime_error("empty string");
folly/test/ConvTest.cpp: throw std::runtime_error("overflow");
folly/test/ConvTest.cpp: throw std::runtime_error("extra chars at the end");
folly/test/AtomicHashMapTest.cpp: static bool throwException_ = false;
folly/test/AtomicHashMapTest.cpp: throwException_ = !throwException_;
folly/test/AtomicHashMapTest.cpp: if (throwException_) {
folly/test/AtomicHashMapTest.cpp: throw 1;
folly/test/small_vector_test.cpp:int throwCounter = 1;
folly/test/small_vector_test.cpp: if (!--throwCounter) {
folly/test/small_vector_test.cpp: throw TestException();
folly/test/small_vector_test.cpp:// Check that throws don't break the basic guarantee for some cases.
folly/test/small_vector_test.cpp:// throwing code paths to occur.
folly/test/small_vector_test.cpp: throwCounter = 1000;
folly/test/small_vector_test.cpp: throwCounter = 1000;
folly/test/small_vector_test.cpp: throwCounter = 1000;
folly/test/small_vector_test.cpp: throwCounter = counter;
folly/test/small_vector_test.cpp: * of the above push_back's, and one of the Throwers throws,
folly/test/small_vector_test.cpp: throwCounter = 4;
folly/StlAllocator.h: * alignment required on your system), throwing std::bad_alloc if the
folly/StlAllocator.h: * if (!p) throw std::bad_alloc();
folly/dynamic.h: * complete interface than the raw type), and it'll just throw a
folly/dynamic.h: * those types. For objects, we throw TypeError.
folly/dynamic.h: * These throw TypeError when used with types or type combinations
folly/dynamic.h: * These functions may also throw if you use 64-bit integers with
folly/dynamic.h: * throws TypeError.
folly/dynamic.h: * non-arrays will throw a TypeError.
folly/dynamic.h: * value) in an object. Calling these on non-objects will throw a TypeError.
folly/dynamic.h: * the given name. Otherwise throws TypeError.
folly/dynamic.h: * will throw a TypeError. Using an index that is out of range or
folly/dynamic.h: * object-element that's not present throws std::out_of_range.
folly/dynamic.h: * In the case of an array, the index must be an integer, and this will throw
folly/dynamic.h: * value if the key isn't present. The const overload will throw
folly/dynamic.h: * Only defined for objects, throws TypeError otherwise.
folly/dynamic.h: * Inserts the supplied key-value pair to an object, or throws if
folly/dynamic.h: * Append elements to an array. If this is not an array, throws
folly/dynamic.h: template<class T> T* get_nothrow();
folly/dynamic.h: template<class T> T const* get_nothrow() const;
folly/String.h: * In strict mode (default), throws std::invalid_argument if it encounters
folly/String.h: * This function may allocate memory (and therefore throw).
folly/String.h:struct has_nothrow_constructor<folly::basic_fbstring<T> > : true_type {
folly/DiscriminatedPtr.h: * throws an exception (and get_nothrow returns nullptr)
folly/DiscriminatedPtr.h: T* get_nothrow() noexcept {
folly/DiscriminatedPtr.h: const T* get_nothrow() const noexcept {
folly/DiscriminatedPtr.h: * Types), and throws std::invalid_argument if this DiscriminatedPtr is empty
folly/DiscriminatedPtr.h: throw std::invalid_argument("Invalid type");
folly/DiscriminatedPtr.h: throw std::invalid_argument("Invalid type");
folly/DiscriminatedPtr.h: if (n == 0) throw std::invalid_argument("Empty DiscriminatedPtr");
folly/DiscriminatedPtr.h: if (n == 0) throw std::invalid_argument("Empty DiscriminatedPtr");
folly/Format-inl.h: // and throw if we see any lone "}"
folly/Format-inl.h: throw std::invalid_argument(
folly/Format-inl.h: throw std::invalid_argument(
folly/Format-inl.h: throw std::invalid_argument("folly::format: missing ending '}'");
folly/Format-inl.h: throw std::invalid_argument(
folly/String-inl.h: throw std::invalid_argument("incomplete escape sequence");
folly/String-inl.h: throw std::invalid_argument("incomplete hex escape sequence");
folly/String-inl.h: throw std::invalid_argument("invalid escape sequence");
folly/small_vector.h: * overflow the in situ capacity we throw an exception.
folly/small_vector.h: // threw: if someone throws from a move constructor the effects
folly/small_vector.h: throw;
folly/small_vector.h: throw;
folly/small_vector.h: * anything throws, undo what we did.
folly/small_vector.h: throw;
folly/small_vector.h: * Basic guarantee only. Provides the nothrow guarantee iff our
folly/small_vector.h: * value_type has a nothrow move or copy constructor.
folly/small_vector.h: throw;
folly/small_vector.h: throw;
folly/small_vector.h: * constructor throwing by clearing the whole vector).
folly/small_vector.h: * constructor throws, you either need a nothrow default
folly/small_vector.h: * constructor or a nothrow copy/move to get something back in the
folly/small_vector.h: throw std::out_of_range();
folly/small_vector.h: throw std::out_of_range();
folly/small_vector.h: * objects and insertion outside the function, otherwise exception is thrown.
folly/small_vector.h: throw std::length_error("max_size exceeded in small_vector");
folly/small_vector.h: throw std::bad_alloc();
folly/small_vector.h: throw;
folly/small_vector.h: throw;
folly/small_vector.h: throw;
folly/small_vector.h: throw;
folly/small_vector.h:// Basic guarantee only, or provides the nothrow guarantee iff T has a
folly/small_vector.h:// nothrow move or copy constructor.
folly/experimental/TestUtil.cpp: throw std::system_error(errno, std::system_category(),
folly/experimental/TestUtil.cpp: throw std::system_error(errno, std::system_category(),
folly/experimental/io/Cursor.h: throw std::out_of_range("underflow");
folly/experimental/io/Cursor.h: throw std::out_of_range("underflow");
folly/experimental/io/Cursor.h: throw std::out_of_range("overflow");
folly/experimental/io/Cursor.h: * (and push() and ensure() will throw) if growth == 0.
folly/experimental/io/Cursor.h: throw std::out_of_range("can't grow buffer chain");
folly/experimental/io/IOBuf.h: * second argument. The free function must never throw exceptions.
folly/experimental/io/IOBuf.h: * On error, std::bad_alloc will be thrown. If freeOnError is true (the
folly/experimental/io/IOBuf.h: * default) the buffer will be freed before throwing the error.
folly/experimental/io/IOBuf.h: * On error, std::bad_alloc will be thrown.
folly/experimental/io/IOBuf.h: * Currently unshare may also throw std::overflow_error if it tries to
folly/experimental/io/IOBuf.cpp: throw std::bad_alloc();
folly/experimental/io/IOBuf.cpp: throw std::bad_alloc();
folly/experimental/io/IOBuf.cpp: throw;
folly/experimental/io/IOBuf.cpp: // The user's free function is not allowed to throw.
folly/experimental/io/IOBuf.cpp: throw;
folly/experimental/io/IOBuf.cpp: throw std::overflow_error("IOBuf chain too large to coalesce");
folly/experimental/io/IOBuf.cpp: // The user's free function should never throw. Otherwise we might
folly/experimental/io/IOBuf.cpp: // throw from the IOBuf destructor. Other code paths like coalesce()
folly/experimental/io/IOBuf.cpp: // also assume that decrementRefcount() cannot throw.
folly/experimental/io/IOBuf.cpp: throw std::bad_alloc();
folly/experimental/io/IOBuf.cpp: throw std::bad_alloc();
folly/experimental/io/IOBuf.cpp: throw std::bad_alloc();
folly/experimental/io/IOBuf.cpp: throw std::bad_alloc();
folly/experimental/io/IOBufQueue.h: * @throws std::underflow_error if n exceeds the number of bytes
folly/experimental/io/IOBufQueue.h: throw std::invalid_argument("IOBufQueue: chain length not cached");
folly/experimental/io/IOBufQueue.cpp: throw std::underflow_error(
folly/experimental/io/IOBufQueue.cpp: throw std::underflow_error(
folly/experimental/io/IOBufQueue.cpp: throw std::underflow_error(
folly/Traits.h: struct has_nothrow_constructor< __VA_ARGS__ > : ::boost::true_type {};
folly/Traits.h: * above, and that it has a nothrow constructor. Most types can be
folly/Traits.h:struct has_nothrow_constructor< std::pair<T, U> >
folly/Traits.h: : ::boost::mpl::and_< has_nothrow_constructor<T>,
folly/Traits.h: has_nothrow_constructor<U> > {};
folly/Range.h: if (i >= size()) throw std::out_of_range("index out of range");
folly/Range.h: if (i >= size()) throw std::out_of_range("index out of range");
folly/FBVector.h: boost::has_nothrow_constructor<T>::value
folly/FBVector.h: !boost::has_nothrow_constructor<T>::value
folly/FBVector.h: * value. If the operation throws, destroys all objects constructed so
folly/FBVector.h: } else if (boost::has_nothrow_constructor<T>::value) {
folly/FBVector.h: throw;
folly/FBVector.h: * operation throws, destroys all objects constructed so far and calls
folly/FBVector.h: throw;
folly/FBVector.h: // Careful here, fill and uninitialized_fill may throw. The
folly/FBVector.h: throw std::out_of_range("fbvector: index is greater than size.");
folly/FBVector.h: throw;
folly/FBVector.h: throw;
folly/FBString.h: void (*throw_exc)(const char*),
folly/FBString.h: if (!condition) throw_exc(msg);
folly/FBString.h: std::__throw_logic_error(err.c_str());
folly/FBString.h: enforce(res_arg <= max_size(), std::__throw_length_error, "");
folly/FBString.h: enforce(n <= size(), std::__throw_out_of_range, "");
folly/FBString.h: enforce(n < size(), std::__throw_out_of_range, "");
folly/FBString.h: enforce(pos <= sz, std::__throw_out_of_range, "");
folly/FBString.h: enforce(pos <= sz, std::__throw_out_of_range, "");
folly/FBString.h: enforce(pos2 <= str.length(), std::__throw_out_of_range, "");
folly/FBString.h: enforce(pos <= length(), std::__throw_out_of_range, "");
folly/FBString.h: enforce(pos <= length(), std::__throw_out_of_range, "");
folly/FBString.h: enforce(pos <= length(), std::__throw_out_of_range, "");
folly/FBString.h: enforce(pos <= size(), std::__throw_out_of_range, "");
folly/FBString.h: enforce(pos2 <= str.length(), std::__throw_out_of_range, "");
folly/FBString.h: enforce(pos <= size(), std::__throw_out_of_range, "");
folly/FBString.h: enforce(pos <= size(), std::__throw_out_of_range, "");
folly/FBString.h: enforce(pos <= size(), std::__throw_out_of_range, "");
folly/FBString.h: enforce(pos1 <= size(), std::__throw_out_of_range, "");
folly/FBString.h: enforce(pos2 <= str.size(), std::__throw_out_of_range, "");
folly/detail/ThreadLocalDetail.h: throw std::runtime_error("pthread_key_create failed: " + msg);
folly/detail/ThreadLocalDetail.h: LOG(WARNING) << "Destructor discarding an exception that was thrown.";
folly/detail/ThreadLocalDetail.h: throw std::bad_alloc();
folly/AtomicHashMap-inl.h: throw AtomicHashMapFullError();
folly/AtomicHashArray-inl.h: throw;
folly/ScopeGuard.h: * // this will throw an exception upon error, which
folly/ScopeGuard.h: * // an exception was not thrown, so don't execute
folly/String.cpp: throw std::runtime_error(
folly/String.cpp: throw std::runtime_error(
folly/json.cpp: throw std::runtime_error("folly::decodeUtf8 empty/invalid string");
folly/json.cpp: throw std::runtime_error(
folly/json.cpp: throw std::runtime_error(
folly/json.cpp: throw std::runtime_error(
folly/json.cpp: throw std::runtime_error(
folly/json.cpp: throw std::runtime_error("folly::decodeUtf8 encoding length maxed out");
folly/json.cpp: throw std::runtime_error("folly::toJson: JSON object key was not a "
folly/json.cpp: throw ParseError(lineNum_, context(),
folly/json.cpp: throw ParseError(lineNum_, context(), what);
folly/Arena.h: * alignment required on your system; throw std::bad_alloc if the
folly/Arena.h: if (!mem) throw std::bad_alloc(); |
