String<Ch,Tr,Capacity>& String<Ch,Tr,Capacity>::operator+=(const Ch* x) { size_t n = Tr::length(x); if(n + sz > Capacity) throw length_error("String::operator+="); Tr::copy(s + sz, x, n); sz += n; s[sz] = 0; }
int Pop() { if (Empty()) { throw length_error("Pop(): empty stack"); } int pop_element = element_with_cached_max_.top().first; element_with_cached_max_.pop(); return pop_element; }
int dequeue() { if (!count_) { throw length_error("empty queue"); } --count_; int ret = data_[head_]; head_ = (head_ + 1) % data_.size(); return ret; }
int max() const { if (!A_.empty()) { return B_.empty() ? A_.max() : std::max(A_.max(), B_.max()); } else { // A_.empty() == true. if (!B_.empty()) { return B_.max(); } throw length_error("empty queue"); } }
int dequeue() { if (B_.empty()) { while (!A_.empty()) { B_.push(A_.pop()); } } if (!B_.empty()) { return B_.pop(); } throw length_error("empty queue"); }
T pop() { if (empty()) { throw length_error("empty stack"); } T ret = s_.top(); s_.pop(); if (ret == aux_.top().first) { --aux_.top().second; if (aux_.top().second == 0) { aux_.pop(); } } return ret; }
int Pop() { if (Empty()) { throw length_error("Pop(): empty stack"); } int pop_element = element_.top(); element_.pop(); const int kCurrentMax = cached_max_with_count_.top().first; if (pop_element == kCurrentMax) { int& max_frequency = cached_max_with_count_.top.second; --max_frequency; if (max_frequency == 0) { cached_max_with_count_.pop(); } } return pop_element; }
// @include const BinaryTreeNode<int>* FindKthNodeBinaryTree( const unique_ptr<BinaryTreeNode<int>>& root, int k) { const auto* n = root.get(); while (n) { int left_size = n->left ? n->left->size : 0; if (left_size < k - 1) { k -= (left_size + 1); n = n->right.get(); } else if (left_size == k - 1) { return n; } else { // left_size > k - 1. n = n->left.get(); } } throw length_error("no k-th node in binary tree"); }
// @include int find_k_th_largest(vector<int> A, int k) { int left = 0, right = A.size() - 1; while (left <= right) { default_random_engine gen((random_device())()); // Generates random int in [left, right]. uniform_int_distribution<int> dis(left, right); int p = partition(left, right, dis(gen), &A); if (p == k - 1) { return A[p]; } else if (p > k - 1) { right = p - 1; } else { // p < k - 1. left = p + 1; } } // @exclude throw length_error("no k-th node in array A"); // @include }
/** * Rethrow an exception of type specified by the dynamic type of * the specified exception, adding the specified line number to * the specified exception's message. * * @param[in] e original exception * @param[in] line line number in Stan source program where * exception originated * @param[in] reader trace of how program was included from files */ inline void rethrow_located(const std::exception& e, int line, const io::program_reader& reader = stan::io::program_reader()) { using std::bad_alloc; // -> exception using std::bad_cast; // -> exception using std::bad_exception; // -> exception using std::bad_typeid; // -> exception using std::ios_base; // ::failure -> exception using std::domain_error; // -> logic_error using std::invalid_argument; // -> logic_error using std::length_error; // -> logic_error using std::out_of_range; // -> logic_error using std::logic_error; // -> exception using std::overflow_error; // -> runtime_error using std::range_error; // -> runtime_error using std::underflow_error; // -> runtime_error using std::runtime_error; // -> exception using std::exception; // create message with trace of includes and location of error std::stringstream o; o << "Exception: " << e.what(); if (line < 1) { o << " Found before start of program."; } else { io::program_reader::trace_t tr = reader.trace(line); o << " (in '" << tr[tr.size() - 1].first << "' at line " << tr[tr.size() - 1].second; for (int i = tr.size() - 1; --i >= 0; ) o << "; included from '" << tr[i].first << "' at line " << tr[i].second; o << ")" << std::endl; } std::string s = o.str(); if (is_type<bad_alloc>(e)) throw located_exception<bad_alloc>(s, "bad_alloc"); if (is_type<bad_cast>(e)) throw located_exception<bad_cast>(s, "bad_cast"); if (is_type<bad_exception>(e)) throw located_exception<bad_exception>(s, "bad_exception"); if (is_type<bad_typeid>(e)) throw located_exception<bad_typeid>(s, "bad_typeid"); if (is_type<domain_error>(e)) throw domain_error(s); if (is_type<invalid_argument>(e)) throw invalid_argument(s); if (is_type<length_error>(e)) throw length_error(s); if (is_type<out_of_range>(e)) throw out_of_range(s); if (is_type<logic_error>(e)) throw logic_error(s); if (is_type<overflow_error>(e)) throw overflow_error(s); if (is_type<range_error>(e)) throw range_error(s); if (is_type<underflow_error>(e)) throw underflow_error(s); if (is_type<runtime_error>(e)) throw runtime_error(s); throw located_exception<exception>(s, "unknown original type"); }
int Max() const { if (!Empty()) { return element_with_cached_max_.top().second; } throw length_error("Max(): empty stack"); }
String<Ch,Tr,Capacity>& String<Ch,Tr,Capacity>::operator+=(Ch c) { if(sz == Capacity) throw length_error("String::operator+="); s[sz++] = c; s[sz] = 0; }
const T& max() const { if (!empty()) { return aux_.top().first; } throw length_error("empty stack"); }
int Max() const { if (!Empty()) { return cached_max_with_count_.top().first; } throw length_error("Max(): empty stack"); }