openMSX
Classes | Namespaces | Typedefs | Functions
stl.hh File Reference
#include <algorithm>
#include <cassert>
#include <iterator>
#include <initializer_list>
#include <map>
#include <numeric>
#include <tuple>
#include <utility>
#include <vector>
Include dependency graph for stl.hh:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  LessDeref
 
struct  CmpTupleElement< N, CMP >
 
struct  EqualTupleValueImpl< N, T >
 

Namespaces

 detail
 

Typedefs

template<int N>
using LessTupleElement = CmpTupleElement< N, std::less<> >
 
template<typename T , typename Iterator >
using detail::ToVectorType = std::conditional_t< std::is_same_v< T, void >, typename std::iterator_traits< Iterator >::value_type, T >
 

Functions

template<int N, typename T >
constexpr auto EqualTupleValue (const T &t)
 
template<typename ITER , typename VAL >
constexpr bool contains (ITER first, ITER last, const VAL &val)
 Check if a range contains a given value, using linear search. More...
 
template<typename RANGE , typename VAL >
constexpr bool contains (const RANGE &range, const VAL &val)
 
template<typename ITER , typename VAL >
constexpr ITER find_unguarded (ITER first, ITER last, const VAL &val)
 Faster alternative to 'find' when it's guaranteed that the value will be found (if not the behavior is undefined). More...
 
template<typename RANGE , typename VAL >
constexpr auto find_unguarded (RANGE &range, const VAL &val)
 
template<typename ITER , typename PRED >
constexpr ITER find_if_unguarded (ITER first, ITER last, PRED pred)
 Faster alternative to 'find_if' when it's guaranteed that the predicate will be true for at least one element in the given range. More...
 
template<typename RANGE , typename PRED >
constexpr auto find_if_unguarded (RANGE &range, PRED pred)
 
template<typename RANGE , typename VAL >
constexpr auto rfind_unguarded (RANGE &range, const VAL &val)
 Similar to the find(_if)_unguarded functions above, but searches from the back to front. More...
 
template<typename RANGE , typename PRED >
constexpr auto rfind_if_unguarded (RANGE &range, PRED pred)
 
template<typename VECTOR >
void move_pop_back (VECTOR &v, typename VECTOR::iterator it)
 Erase the pointed to element from the given vector. More...
 
template<typename ForwardIt , typename OutputIt , typename UnaryPredicate >
std::pair< OutputIt, ForwardIt > partition_copy_remove (ForwardIt first, ForwardIt last, OutputIt out_true, UnaryPredicate p)
 This is like a combination of partition_copy() and remove(). More...
 
template<typename ForwardRange , typename OutputIt , typename UnaryPredicate >
auto partition_copy_remove (ForwardRange &&range, OutputIt out_true, UnaryPredicate p)
 
template<typename ForwardRange , typename UnaryOperation >
auto transform_in_place (ForwardRange &&range, UnaryOperation op)
 
template<typename InputIterator >
constexpr auto min_value (InputIterator first, InputIterator last)
 
template<typename InputRange >
constexpr auto min_value (InputRange &&range)
 
template<typename InputIterator >
constexpr auto max_value (InputIterator first, InputIterator last)
 
template<typename InputRange >
constexpr auto max_value (InputRange &&range)
 
template<typename InputRange >
auto sum (InputRange &&range)
 
template<typename T = void, typename Range >
auto to_vector (Range &&range) -> std::vector< detail::ToVectorType< T, decltype(std::begin(range))>>
 
template<typename T >
auto to_vector (std::vector< T > &&v)
 
template<typename... Ranges>
constexpr size_t detail::sum_of_sizes (const Ranges &... ranges)
 
template<typename Result >
void detail::append (Result &)
 
template<typename Result , typename Range , typename... Tail>
void detail::append (Result &x, Range &&y, Tail &&... tail)
 
template<typename Result , typename T2 , typename... Tail>
void detail::append (Result &x, std::vector< T2 > &&y, Tail &&... tail)
 
template<typename T , typename... Tail>
void append (std::vector< T > &v, Tail &&... tail)
 
template<typename T >
void append (std::vector< T > &v, std::vector< T > &&range)
 
template<typename T >
void append (std::vector< T > &x, std::initializer_list< T > list)
 
template<typename T = void, typename Range , typename... Tail>
auto concat (const Range &range, Tail &&... tail)
 
template<typename T , typename... Tail>
std::vector< T > concat (std::vector< T > &&v, Tail &&... tail)
 
template<typename Key , typename Value >
const Value * lookup (const std::map< Key, Value > &m, const Key &k)
 
template<typename Key , typename Value >
Value * lookup (std::map< Key, Value > &m, const Key &k)
 

Typedef Documentation

◆ LessTupleElement

template<int N>
using LessTupleElement = CmpTupleElement<N, std::less<> >

Definition at line 65 of file stl.hh.

Function Documentation

◆ append() [1/3]

template<typename T >
void append ( std::vector< T > &  v,
std::vector< T > &&  range 
)

Definition at line 394 of file stl.hh.

References begin(), and end().

◆ append() [2/3]

template<typename T , typename... Tail>
void append ( std::vector< T > &  v,
Tail &&...  tail 
)

Definition at line 379 of file stl.hh.

References detail::append(), gl::max(), and detail::sum_of_sizes().

Referenced by concat().

◆ append() [3/3]

template<typename T >
void append ( std::vector< T > &  x,
std::initializer_list< T >  list 
)

Definition at line 406 of file stl.hh.

References openmsx::x.

◆ concat() [1/2]

template<typename T = void, typename Range , typename... Tail>
auto concat ( const Range &  range,
Tail &&...  tail 
)

Definition at line 413 of file stl.hh.

References append(), and begin().

◆ concat() [2/2]

template<typename T , typename... Tail>
std::vector<T> concat ( std::vector< T > &&  v,
Tail &&...  tail 
)

Definition at line 422 of file stl.hh.

References append().

◆ contains() [1/2]

template<typename RANGE , typename VAL >
constexpr bool contains ( const RANGE &  range,
const VAL &  val 
)
constexpr

Definition at line 102 of file stl.hh.

References begin(), contains(), and end().

◆ contains() [2/2]

template<typename ITER , typename VAL >
constexpr bool contains ( ITER  first,
ITER  last,
const VAL &  val 
)
constexpr

Check if a range contains a given value, using linear search.

Equivalent to 'find(first, last, val) != last', though this algorithm is more convenient to use. Note: we don't need a variant that uses 'find_if' instead of 'find' because STL already has the 'any_of' algorithm.

Definition at line 92 of file stl.hh.

Referenced by openmsx::MSXMultiIODevice::addDevice(), openmsx::Display::attach(), contains(), openmsx::MSXMotherBoard::getUserName(), openmsx::FileContext::isUserContext(), openmsx::EventDistributor::registerEventListener(), and openmsx::Mixer::registerMixer().

◆ EqualTupleValue()

template<int N, typename T >
constexpr auto EqualTupleValue ( const T &  t)
constexpr

Definition at line 80 of file stl.hh.

References t.

◆ find_if_unguarded() [1/2]

template<typename ITER , typename PRED >
constexpr ITER find_if_unguarded ( ITER  first,
ITER  last,
PRED  pred 
)
constexpr

Faster alternative to 'find_if' when it's guaranteed that the predicate will be true for at least one element in the given range.

See also 'find_unguarded'.

Definition at line 136 of file stl.hh.

Referenced by find_if_unguarded(), openmsx::GLPostProcessor::paint(), openmsx::MSXCPUInterface::removeBreakPoint(), openmsx::Reactor::replaceBoard(), rfind_if_unguarded(), openmsx::HotKey::saveBindings(), openmsx::VideoSourceSetting::setSource(), and openmsx::MSXMixer::updateSoftwareVolume().

◆ find_if_unguarded() [2/2]

template<typename RANGE , typename PRED >
constexpr auto find_if_unguarded ( RANGE &  range,
PRED  pred 
)
constexpr

Definition at line 146 of file stl.hh.

References begin(), end(), and find_if_unguarded().

◆ find_unguarded() [1/2]

template<typename ITER , typename VAL >
constexpr ITER find_unguarded ( ITER  first,
ITER  last,
const VAL &  val 
)
constexpr

Faster alternative to 'find' when it's guaranteed that the value will be found (if not the behavior is undefined).

When asserts are enabled we check whether we really don't move beyond the end of the range. And this check is the only reason why you need to pass the 'last' parameter. Sometimes you see 'find_unguarded' without a 'last' parameter, we could consider providing such an overload as well.

Definition at line 116 of file stl.hh.

Referenced by find_unguarded(), and rfind_unguarded().

◆ find_unguarded() [2/2]

template<typename RANGE , typename VAL >
constexpr auto find_unguarded ( RANGE &  range,
const VAL &  val 
)
constexpr

Definition at line 126 of file stl.hh.

References begin(), end(), and find_unguarded().

◆ lookup() [1/2]

template<typename Key , typename Value >
const Value* lookup ( const std::map< Key, Value > &  m,
const Key &  k 
)

Definition at line 431 of file stl.hh.

◆ lookup() [2/2]

template<typename Key , typename Value >
Value* lookup ( std::map< Key, Value > &  m,
const Key &  k 
)

Definition at line 438 of file stl.hh.

◆ max_value() [1/2]

template<typename InputIterator >
constexpr auto max_value ( InputIterator  first,
InputIterator  last 
)
constexpr

Definition at line 272 of file stl.hh.

References gl::max().

Referenced by openmsx::MSXDevice::getVisibleMemRegion(), and max_value().

◆ max_value() [2/2]

template<typename InputRange >
constexpr auto max_value ( InputRange &&  range)
constexpr

Definition at line 283 of file stl.hh.

References begin(), end(), and max_value().

◆ min_value() [1/2]

template<typename InputIterator >
constexpr auto min_value ( InputIterator  first,
InputIterator  last 
)
constexpr

Definition at line 253 of file stl.hh.

References gl::min().

Referenced by openmsx::MSXDevice::getVisibleMemRegion(), and min_value().

◆ min_value() [2/2]

template<typename InputRange >
constexpr auto min_value ( InputRange &&  range)
constexpr

Definition at line 264 of file stl.hh.

References begin(), end(), and min_value().

◆ move_pop_back()

template<typename VECTOR >
void move_pop_back ( VECTOR &  v,
typename VECTOR::iterator  it 
)

◆ partition_copy_remove() [1/2]

template<typename ForwardIt , typename OutputIt , typename UnaryPredicate >
std::pair<OutputIt, ForwardIt> partition_copy_remove ( ForwardIt  first,
ForwardIt  last,
OutputIt  out_true,
UnaryPredicate  p 
)

This is like a combination of partition_copy() and remove().

Each element is tested against the predicate. If it matches, the element is copied to the output and removed from the input. So the output contains all elements for which the predicate gives true and the input is modified in-place to contain the elements for which the predicate gives false. (Like the remove() algorithm, it's still required to call erase() to also shrink the input).

This algorithm returns a pair of iterators. -first: one past the matching elements (in the output range). Similar to the return value of the partition_copy() algorithm. -second: one past the non-matching elements (in the input range). Similar to the return value of the remove() algorithm.

Definition at line 217 of file stl.hh.

References ranges::find_if().

Referenced by partition_copy_remove().

◆ partition_copy_remove() [2/2]

template<typename ForwardRange , typename OutputIt , typename UnaryPredicate >
auto partition_copy_remove ( ForwardRange &&  range,
OutputIt  out_true,
UnaryPredicate  p 
)

Definition at line 236 of file stl.hh.

References begin(), end(), and partition_copy_remove().

◆ rfind_if_unguarded()

template<typename RANGE , typename PRED >
constexpr auto rfind_if_unguarded ( RANGE &  range,
PRED  pred 
)
constexpr

◆ rfind_unguarded()

template<typename RANGE , typename VAL >
constexpr auto rfind_unguarded ( RANGE &  range,
const VAL &  val 
)
constexpr

◆ sum()

template<typename InputRange >
auto sum ( InputRange &&  range)

Definition at line 293 of file stl.hh.

References ranges::accumulate(), begin(), and end().

Referenced by openmsx::FilePoolCore::getSha1Sum(), openmsx::Paper::plot(), and TEST_CASE().

◆ to_vector() [1/2]

template<typename T = void, typename Range >
auto to_vector ( Range &&  range) -> std::vector<detail::ToVectorType<T, decltype(std::begin(range))>>

◆ to_vector() [2/2]

template<typename T >
auto to_vector ( std::vector< T > &&  v)

Definition at line 324 of file stl.hh.

◆ transform_in_place()

template<typename ForwardRange , typename UnaryOperation >
auto transform_in_place ( ForwardRange &&  range,
UnaryOperation  op 
)

Definition at line 244 of file stl.hh.

References begin(), end(), and ranges::transform().