utils.hxx File Reference

#include <cstddef>
#include <functional>
#include <map>
#include <ostream>
#include <type_traits>
#include <variant>
#include <vector>

Go to the source code of this file.

Classes
class	cosmos::NamedBool< _, def >
	Strong template type to wrap boolean values in a named type. More...
class	cosmos::ResourceGuard< R >
	Helper class to guard arbitrary resources. More...
struct	cosmos::Identity< T >
class	cosmos::Twice
	Helper for iterating twice over a for loop. More...
class	cosmos::TwiceIterator

Typedefs
template<typename T >
using	cosmos::IdentityT = typename Identity<T>::type

Functions
template<typename T1 >
bool	cosmos::in_range (const T1 &v, const IdentityT< T1 > &_min, const IdentityT< T1 > &_max)
	Checks whether v is within the given (inclusive) range.
template<typename T >
bool	cosmos::in_list (const T &v, const std::initializer_list< T > &l)
	Checks whether the value v is found in the given list of values l.
template<typename T >
constexpr size_t	cosmos::num_elements (const T &v)
	Returns the number of elements in a C style array.
template<typename T1 , typename T2 >
T1 &	cosmos::append (T1 &v1, const T2 &v2)
	Append iterable sequence v2 to sequence v1.
template<typename ENUM >
constexpr auto	cosmos::to_integral (const ENUM e) -> typename std::underlying_type< ENUM >::type
	Casts an enum constant value into its underlying primitive type.
template<typename ENUM >
auto	cosmos::to_raw_ptr (ENUM *e)
	Returns a pointer casted to the underlying type of the given enum.
template<typename VARIANT >
bool	cosmos::is_empty_variant (const VARIANT &var)
template<typename VARIANT >
bool	cosmos::variant_holds_value (const VARIANT &var)
TwiceIterator	cosmos::begin (Twice &)
TwiceIterator	cosmos::end (Twice &)
template<typename T >
std::ostream &	operator<< (std::ostream &o, const std::vector< T > &sv)
	Output all the elements of a vector as a comma separated list.
template<typename K , typename V >
std::ostream &	operator<< (std::ostream &o, const std::map< K, V > &m)
	Output all the elements of a map as a "key:value" newline separated list.

Detailed Description

This header contains some helper algorithm-like functions for dealing with STL containers, types and more.

Furthermore some general convenience types used across libcosmos.

Definition in file utils.hxx.

Typedef Documentation

IdentityT

template<typename T >

using cosmos::IdentityT = typename Identity<T>::type

Definition at line 105 of file utils.hxx.

Function Documentation

append()

template<typename T1 , typename T2 >

T1 & cosmos::append	(	T1 &	v1,
		const T2 &	v2 )

Append iterable sequence v2 to sequence v1.

Definition at line 134 of file utils.hxx.

                                 {
        v1.insert(std::end(v1), std::begin(v2), std::end(v2));
        return v1;
}

begin()

TwiceIterator cosmos::begin ( Twice & )

inline

Definition at line 199 of file utils.hxx.

                                    {
        return TwiceIterator{};
}

end()

TwiceIterator cosmos::end ( Twice & )

inline

Definition at line 203 of file utils.hxx.

                                  {
        return TwiceIterator{2};
}

in_list()

template<typename T >

bool cosmos::in_list	(	const T &	v,
		const std::initializer_list< T > &	l )

Checks whether the value v is found in the given list of values l.

Definition at line 117 of file utils.hxx.

                                                          {
        for (const auto &cmp: l) {
                if (v == cmp)
                        return true;
        }
 
        return false;
}

in_range()

template<typename T1 >

bool cosmos::in_range	(	const T1 &	v,
		const IdentityT< T1 > &	_min,
		const IdentityT< T1 > &	_max )

Checks whether v is within the given (inclusive) range.

Definition at line 111 of file utils.hxx.

                                                                                 {
        return _min <= v && v <= _max;
}

is_empty_variant()

template<typename VARIANT >

bool cosmos::is_empty_variant

(

const VARIANT &

var

)

Definition at line 153 of file utils.hxx.

                                          {
        return std::holds_alternative<std::monostate>(var);
}

num_elements()

template<typename T >

size_t cosmos::num_elements ( const T & v )

constexpr

Returns the number of elements in a C style array.

Definition at line 128 of file utils.hxx.

                                          {
        return sizeof(v) / sizeof(v[0]);
}

operator<<() [1/2]

template<typename K , typename V >

std::ostream & operator<< ( std::ostream & o, const std::map< K, V > & m )

inline

Output all the elements of a map as a "key:value" newline separated list.

Definition at line 223 of file utils.hxx.

                                                                   {
        for (auto it: m) {
                o << it.first << ": " << it.second << "\n";
        }
 
        return o;
}

operator<<() [2/2]

template<typename T >

std::ostream & operator<< ( std::ostream & o, const std::vector< T > & sv )

inline

Output all the elements of a vector as a comma separated list.

Definition at line 211 of file utils.hxx.

                                                                     {
        for (auto it = sv.begin(); it != sv.end(); it++) {
                if (it != sv.begin())
                        o << ", ";
                o << *it;
        }
 
        return o;
}

to_integral()

template<typename ENUM >

auto cosmos::to_integral ( const ENUM e ) -> typename std::underlying_type<ENUM>::type

constexpr

Casts an enum constant value into its underlying primitive type.

Definition at line 141 of file utils.hxx.

                                                                                  {
        return static_cast<typename std::underlying_type<ENUM>::type>(e);
}

to_raw_ptr()

template<typename ENUM >

auto cosmos::to_raw_ptr

(

ENUM *

e

)

Returns a pointer casted to the underlying type of the given enum.

Definition at line 147 of file utils.hxx.

                         {
        using UT = typename std::underlying_type<ENUM>::type;
        return reinterpret_cast<UT*>(e);
}

variant_holds_value()

template<typename VARIANT >

bool cosmos::variant_holds_value

(

const VARIANT &

var

)

Definition at line 158 of file utils.hxx.

                                             {
        return !is_empty_variant(var);
}