void constraints() { function_requires< ForwardContainerConcept<ReversibleContainer> >(); function_requires< BidirectionalIteratorConcept<const_iterator> >(); function_requires< BidirectionalIteratorConcept<const_reverse_iterator> >(); const_constraints(c); }
void constraints() { b.push(t); b.pop(); typename B::value_type& v = b.top(); const_constraints(b); ignore_unused_variable_warning(v); }
void constraints() { // function_requires< CopyConstructibleConcept<Array> >(); // RG - a( CollectionArchetype) when available... value_type vt = a[ id ]; // Test slicing, keeping only the first dimension, losing the rest idgen_helper<NumDims-1>::call(a,idgen[range],id); // Test slicing, keeping all dimensions. idgen_helper<NumDims-1>::call(a,idgen[range],range); st = a.size(); st = a.num_dimensions(); st = a.num_elements(); stp = a.shape(); idp = a.strides(); idp = a.index_bases(); it = a.begin(); it = a.end(); rit = a.rbegin(); rit = a.rend(); eltp = a.origin(); const_constraints(a); }
void constraints() { // Matt Austern's book puts DefaultConstructible here, the C++ // standard places it in Container // function_requires< DefaultConstructible<Sequence> >(); function_requires< Mutable_ForwardContainerConcept<Sequence> >(); function_requires< DefaultConstructibleConcept<Sequence> >(); Sequence c(n), c2(n, t), c3(first, last); c.insert(p, t); c.insert(p, n, t); c.insert(p, first, last); c.erase(p); c.erase(p, q); reference r = c.front(); ignore_unused_variable_warning(c); ignore_unused_variable_warning(c2); ignore_unused_variable_warning(c3); ignore_unused_variable_warning(r); const_constraints(c); }
void constraints() { // function_requires< CopyConstructibleConcept<Array> >(); function_requires< boost_concepts::ForwardTraversalConcept<iterator> >(); function_requires< boost_concepts::ReadableIteratorConcept<iterator> >(); function_requires< boost_concepts::WritableIteratorConcept<iterator> >(); function_requires< boost_concepts::ForwardTraversalConcept<const_iterator> >(); function_requires< boost_concepts::ReadableIteratorConcept<const_iterator> >(); function_requires< boost::OutputIterator<iterator,value_type> >(); // RG - a( CollectionArchetype) when available... value_type vt = a[ id ]; // Test slicing, keeping only the first dimension, losing the rest detail::idgen_helper<NumDims-1>::call(a,idgen[range],id); // Test slicing, keeping all dimensions. detail::idgen_helper<NumDims-1>::call(a,idgen[range],range); st = a.size(); st = a.num_dimensions(); st = a.num_elements(); stp = a.shape(); idp = a.strides(); idp = a.index_bases(); it = a.begin(); it = a.end(); rit = a.rbegin(); rit = a.rend(); eltp = a.origin(); const_constraints(a); }
void constraints() { function_requires< ReversibleContainerConcept<RandomAccessContainer> >(); function_requires< RandomAccessIteratorConcept<const_iterator> >(); function_requires< RandomAccessIteratorConcept<const_reverse_iterator> >(); const_constraints(c); }
void constraints() { TT b(a); #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL a = a; // require assignment operator #endif const_constraints(a); ignore_unused_variable_warning(b); }
void constraints() { function_requires< GraphConcept<G> >(); function_requires< MultiPassInputIteratorConcept<adjacency_iterator> >(); p = adjacent_vertices(v, g); v = *p.first; const_constraints(g); }
void constraints() { function_requires< AdjacencyGraphConcept<G> >(); function_requires< IncidenceGraphConcept<G> >(); function_requires< MultiPassInputIteratorConcept<vertex_iterator> >(); p = vertices(g); v = *p.first; const_constraints(g); }
void constraints() { function_requires< IncidenceGraphConcept<G> >(); function_requires< MultiPassInputIteratorConcept<in_edge_iterator> >(); p = in_edges(v, g); n = in_degree(v, g); e = *p.first; const_constraints(g); }
void constraints() { function_requires< boost_concepts::SinglePassIteratorConcept< range_iterator > >(); i = boost::begin(a); i = boost::end(a); const_constraints(a); }
void constraints() { function_requires< ForwardContainerConcept<AssociativeContainer> >(); function_requires< DefaultConstructibleConcept<AssociativeContainer> >(); i = c.find(k); r = c.equal_range(k); c.erase(k); c.erase(i); c.erase(r.first, r.second); const_constraints(c); }
void constraints() { function_requires< GraphConcept<G> >(); function_requires< MultiPassInputIteratorConcept<edge_iterator> >(); function_requires< DefaultConstructibleConcept<edge_descriptor> >(); function_requires< EqualityComparableConcept<edge_descriptor> >(); function_requires< AssignableConcept<edge_descriptor> >(); p = edges(g); e = *p.first; u = source(e, g); v = target(e, g); const_constraints(g); }
void constraints() { function_requires< ForwardRangeConcept<T> >(); function_requires< boost_concepts::BidirectionalTraversalConcept< typename range_iterator<T>::type > >(); i = boost::rbegin(a); i = boost::rend(a); const_constraints(a); }
void constraints() { #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL a = a; // require assignment operator #endif const_constraints(a); }
void constraints() { const_constraints(f); }
void constraints() { function_requires< InputIteratorConcept<const_iterator> >(); function_requires< AssignableConcept<Container> >(); const_constraints(c); }
void constraints() { function_requires< GraphConcept<G> >(); function_requires< ReadablePropertyMapConcept<const_Map, X> >(); const_constraints(g); }
void constraints() { function_requires< GraphConcept<G> >(); p = edge(u, v, g); const_constraints(g); }
void constraints() { TT a(b); // require copy constructor TT* ptr = &a; // require address of operator const_constraints(a); ignore_unused_variable_warning(ptr); }