inline std::string key_qvalue_pairs(std::initializer_list<kv_pair> pairs) { return key_qvalue_pairs(array_view<kv_pair>{pairs.begin(), pairs.end()}); }
Value Object::callAsFunction(const Object& thisObj, std::initializer_list<JSValueRef> args) const { return callAsFunction((JSObjectRef)thisObj, args.size(), args.begin()); }
constexpr ranges::reverse_iterator<T const*> operator()(std::initializer_list<T> il) const noexcept { return ranges::reverse_iterator<T const*>(il.begin()); }
inline bool in(std::initializer_list<file_type> types, file_type value) { return find(types.begin(), types.end(), value) != types.end(); }
void add(std::initializer_list<AssemblyStage*> stages) { for (auto it = stages.begin(), et = stages.end(); it != et; ++it) add(*it); }
inline lstring::lstring(std::initializer_list<string> list) { for(const string *s = list.begin(); s != list.end(); ++s) { operator<<(*s); } }
//! <b>Effects</b>: Constructs an empty set using the specified //! allocator, and inserts elements from the range [il.begin(), il.end()). //! //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using //! comp and otherwise N logN, where N is il.begin() - il.end(). set(std::initializer_list<value_type> il, const allocator_type& a) : base_t(true, il.begin(), il.end(), Compare(), a) {}
void Assign(std::initializer_list<Char> rhs) noexcept { Assign(rhs.begin(), rhs.end()); }
inline Heap<T, Compare>::Heap(std::initializer_list<T> list): Heap<T, Compare>(list.begin(), list.end()) {}
// initializer_list constuctor segmented_map(std::initializer_list<value_type> il) : segmented_map{il.begin(), il.end()} {}
constexpr StringObserver(std::initializer_list<Char> rhs) noexcept : StringObserver(rhs.begin(), rhs.size()) { }
explicit Polygon(std::initializer_list<Vec2> outer) : Polygon(outer.begin(), outer.size()) {}
Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1]) { TEST_THROW(6);}
constexpr Y(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1]) {}
flat_map( std::initializer_list<value_type> init, CompareF const &comp = CompareF(), Alloc const &a = Alloc() ) : flat_map(init.begin(), init.end(), comp, a) {}
static void test_insertion_erasure_and_searching() { map<int, int> m; const auto& cb = m; std::map<int, int> sm; const auto& csm = sm; int i = 0; for (const auto& x : il) { if (i++ & 2) m.insert(x); else m[x.first] = x.second; sm.insert(x); test_equality(m, sm); test_copying(m); test_searching(m .lower_bound(1), m .end(), sm .lower_bound(1), sm .end()); test_searching(m .lower_bound(2), m .end(), sm .lower_bound(2), sm .end()); test_searching(cb.lower_bound(1), cb.end(), csm.lower_bound(1), csm.end()); test_searching(cb.lower_bound(2), cb.end(), csm.lower_bound(2), csm.end()); test_searching(m .upper_bound(1), m .end(), sm .upper_bound(1), sm .end()); test_searching(m .upper_bound(2), m .end(), sm .upper_bound(2), sm .end()); test_searching(cb.upper_bound(1), cb.end(), csm.upper_bound(1), csm.end()); test_searching(cb.upper_bound(2), cb.end(), csm.upper_bound(2), csm.end()); test_searching(m .find(1), m .end(), sm .find(1), sm .end()); test_searching(m .find(2), m .end(), sm .find(2), sm .end()); test_searching(cb.find(1), cb.end(), csm.find(1), csm.end()); test_searching(cb.find(2), cb.end(), csm.find(2), csm.end()); } for (const auto& x : il) { auto im = m.find(x.first); auto ism = sm.find(x.first); assert((im == m.end()) == (ism == sm.end())); if (im != m.end()) { im = m.erase(im); ism = sm.erase(ism); } assert((im == m.end()) == (ism == sm.end())); assert(im == m.end() || *im == *ism); } m.insert(il.begin(), il.end()); sm = il; test_equality(m, sm); assert(m.erase(m.begin(), m.end()) == m.end()); test_emptiness(m); m = il; auto it = --m.end(); assert(m.erase(++m.begin(), it) == it); sm = il; sm.erase(++sm.begin(), --sm.end()); test_equality(m, sm); }
int_vector::int_vector(std::initializer_list<value_type> ilist) : int_vector(static_cast<size_type>(ilist.size()), needed_bits(ilist)) { std::copy(ilist.begin(), ilist.end(), begin()); }
array_view(const std::initializer_list<T>& l) : size_(l.size()), data_(l.begin()) {}
PLOTLIB_INLINE PMat::PMat( const std::initializer_list< std::initializer_list< double > > &data ) : mData( data.begin(), data.end() ) { mDimension = CheckDimensions( mData ); }
Vector::Vector(const std::initializer_list<GLfloat>& coordArray) { for (std::initializer_list<GLfloat>::const_iterator it = coordArray.begin(); it != coordArray.end(); ++it) { coords.push_back(*it); } }
//! <b>Effects</b>: Constructs an empty set using the specified comparison object and //! allocator, and inserts elements from the ordered unique range [il.begin(), il.end()). This function //! is more efficient than the normal range creation for ordered ranges. //! //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be //! unique values. //! //! <b>Complexity</b>: Linear in N. //! //! <b>Note</b>: Non-standard extension. set( ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare() , const allocator_type& a = allocator_type()) : base_t(ordered_range, il.begin(), il.end(), comp, a) {}
GLSLStrings(const std::initializer_list<const GLchar*>& l) : _count(GLsizei(l.size())) , _strs(l.begin()) , _lens(nullptr) { }
void NPC::assignDialog(const std::initializer_list<std::string> &dialog) { mDialog.assign(dialog.begin(), dialog.end()); }
Geom (std::initializer_list <Attrib> attribs, uint index_buffer, uint index_count, uint index_type) : Geom (attribs.begin (), attribs.size (), index_buffer, index_count, index_type) { }
Value Object::callAsFunction(std::initializer_list<JSValueRef> args) const { return callAsFunction(nullptr, args.size(), args.begin()); }
BoVector(const std::initializer_list<int>& v) { for (std::initializer_list<int>::iterator itr = v.begin(); itr!=v.end(); ++ itr) m_vec.push_back(*itr); }
/* Braced initialization You use this for creating a polynomial with specific degree coefficients. Solves requirement 1b, as well as the braced initializer support from requirement 5. */ template <typename C> Polynomial<C>::Polynomial(std::initializer_list<C> list) : pImpl(std::make_unique<Polynomial<C>::PolynomialData>()) { this->SetCoefficientRange<std::initializer_list<C>>(list.begin(), list.end()); }
void insert(std::initializer_list<value_type> init) { insert(init.begin(), init.end()); }
inline tmatnm(std::initializer_list<S> list) { auto il = list.begin(); for(int i = 0; i < N*N && il != list.end(); ++i, ++il) { data[i] = static_cast<T>(*il); } }
array_view_const_char assign(charp_or_string type, std::initializer_list<kv_pair> pairs) { return this->assign(type, array_view<kv_pair>{pairs.begin(), pairs.end()}); }