wibble Namespace Reference

Namespaces
namespace	commandline
namespace	exception
namespace	grcal
namespace	list
namespace	log
namespace	mixin
namespace	net
namespace	operators
namespace	param
namespace	str
namespace	stream
namespace	sys
namespace	tests
namespace	text

Classes
struct	Amorph
class	AmorphPadder
class	AmorphPadder< 0 >
struct	AssertFailed
struct	Baseless
struct	CastedRange
struct	Consumer
struct	ConsumerFromIterator
struct	ConsumerInterface
struct	ConsumerMixin
struct	ConsumerMorph
struct	DisableIf
struct	DisableIfC
struct	DisableIfC< false, Type >
class	Empty
struct	EnableIf
struct	EnableIfC
struct	EnableIfC< true, Type >
class	ERegexp
struct	Error
struct	ExpectFailure
struct	Fallback
struct	FilteredRange
struct	GeneratedRange
struct	IntersectionRange
struct	IsPolymorphic
struct	IsType
struct	IsZero
struct	IsZero< 0 >
struct	Iterator
struct	IteratorInterface
struct	IteratorMixin
struct	IteratorMorph
struct	IteratorProxy
struct	IteratorRange
struct	IteratorTraits
struct	IteratorTraits< T, typename std::multiset< T >::iterator >
struct	IteratorTraits< T, typename std::set< T >::iterator >
struct	Lexer
struct	Location
struct	Maybe
struct	Maybe< void >
struct	Morph
struct	MorphAllocator
	custom allocator for morph classes More...
struct	MorphBase
struct	MorphInterface
	An interface implemented by all morph classes. More...
struct	NotPreferred
struct	ParseContext
struct	Parser
struct	Position
struct	Preferred
struct	Range
struct	RangeInterface
struct	RangeIterator
struct	RangeMixin
struct	RangeMorph
class	Regexp
struct	ReturnType
struct	ReturnType< void >
struct	SanitizeResultType
struct	SanitizeReturn
struct	SanitizeReturn< F, void >
class	Singleton
class	Splitter
	Split a string using a regular expression to match the token separators. More...
struct	StlIterator
struct	StrongEnumFlags
struct	TAnd
struct	TAndC
struct	TAndC< true, true, true, true, true >
struct	TFalse
struct	TImply
struct	TImplyC
struct	TNot
struct	TNotC
struct	Token
class	Tokenizer
struct	TOr
struct	TOrC
struct	TOrC< false, false, false, false, false >
struct	TPair
struct	TransformedRange
struct	TSame
struct	TSame< A, A >
struct	TTrue
struct	UniqueRange
struct	Unit
struct	VirtualBase

Typedefs
typedef bool	SortabilityTag
template<typename E >
using	is_enum_class = std::integral_constant< bool, std::is_enum< E >::value &&!std::is_convertible< E, int >::value >

Functions
template<typename T , typename X >
X::template Convert< T >::type &	downcast (const X &a)
template<typename T , typename X >
T &	downcast (X *v)
template<typename T >
T::WrappedType &	unwrap (const T &x)
template<typename T >
T &	unwrap (T &x)
template<typename R >
Consumer< typename R::ConsumedType >	consumerMorph (R r)
template<typename Out >
Consumer< typename Out::container_type::value_type >	consumer (Out out)
template<typename T >
IsType< Consumer< typenameT::value_type >, typenameT::iterator >::T	consumer (T &c)
template<typename T >
Consumer< T >	consumer (const ConsumerInterface< T > &t)
template<typename T , typename I >
IteratorTraits< T, I >::Unsorted	isSortedT (I, I)
template<typename T , typename I >
IteratorTraits< T, I >::Sorted	isSortedT (I, I)
template<typename I >
Iterator< typename I::value_type >	iterator (I i)
template<typename X , typename Y >
std::ostream &	operator<< (std::ostream &o, const std::pair< X, Y > &x)
template<typename T , typename C >
Range< T >	castedRange (C r)
template<typename T , typename C >
Range< T >	upcastRange (C r)
template<typename In >
Range< typename In::value_type >	range (In b, In e)
template<typename C >
Range< typename C::iterator::value_type >	range (C &c)
template<typename R >
IntersectionRange< typename R::ElementType >	intersectionRange (R r1, R r2)
template<typename R , typename Pred >
FilteredRange< R, Pred >	filteredRange (R r, Pred p)
template<typename R >
UniqueRange< typename R::ElementType >	uniqueRange (R r1)
template<typename Trans >
TransformedRange< Trans >	transformedRange (Range< typename Trans::argument_type > r, Trans t)
template<typename T , typename A , typename E >
GeneratedRange< T, A, E >	generatedRange (T t, A a, E e)
template<typename T >
Singleton< T >	singleton (const T &value)
template<typename Self , typename = typename std::enable_if< is_enum_class< Self >::value >::type>
constexpr StrongEnumFlags< Self >	operator| (Self a, Self b) noexcept
template<typename Self , typename = typename std::enable_if< is_enum_class< Self >::value >::type>
constexpr StrongEnumFlags< Self >	operator& (Self a, Self b) noexcept
void	assert_die_fn (Location l)
template<typename X >
AssertFailed &	operator<< (AssertFailed &f, X x)
template<typename X >
void	assert_fn (Location l, X x)
template<typename X , typename Y >
void	assert_eq_fn (Location l, X x, Y y)
template<typename X , typename Y >
void	assert_leq_fn (Location l, X x, Y y)
template<typename X >
void	assert_pred_fn (Location l, X x, bool p)
template<typename X >
void	assert_list_eq_fn (Location loc, int c, X l, const typename X::Type check[])
template<typename X , typename Y >
void	assert_neq_fn (Location l, X x, Y y)
void	beginAssertFailure ()
void	endAssertFailure ()

Variables
int	assertFailure = 0

Typedef Documentation

is_enum_class

template<typename E >

using wibble::is_enum_class = typedef std::integral_constant< bool, std::is_enum< E >::value && !std::is_convertible< E, int >::value >

SortabilityTag

typedef bool wibble::SortabilityTag

Function Documentation

assert_die_fn()

void wibble::assert_die_fn

(

Location

l

)

assert_eq_fn()

template<typename X , typename Y >

void wibble::assert_eq_fn	(	Location	l,
		X	x,
		Y	y
	)

assert_fn()

template<typename X >

void wibble::assert_fn	(	Location	l,
		X	x
	)

assert_leq_fn()

template<typename X , typename Y >

void wibble::assert_leq_fn	(	Location	l,
		X	x,
		Y	y
	)

assert_list_eq_fn()

template<typename X >

void wibble::assert_list_eq_fn	(	Location	loc,
		int	c,
		X	l,
		const typename X::Type	check[]
	)

References wibble::str::fmt().

assert_neq_fn()

template<typename X , typename Y >

void wibble::assert_neq_fn	(	Location	l,
		X	x,
		Y	y
	)

assert_pred_fn()

template<typename X >

void wibble::assert_pred_fn	(	Location	l,
		X	x,
		bool	p
	)

beginAssertFailure()

void wibble::beginAssertFailure ( )

inline

References assertFailure.

Referenced by wibble::ExpectFailure::ExpectFailure().

castedRange()

template<typename T , typename C >

Range< T > wibble::castedRange

(

C

r

)

consumer() [1/3]

template<typename T >

Consumer< T > wibble::consumer

(

const ConsumerInterface< T > &

t

)

consumer() [2/3]

template<typename Out >

Consumer< typename Out::container_type::value_type > wibble::consumer

(

Out

out

)

References consumerMorph().

Referenced by consumer().

consumer() [3/3]

template<typename T >

IsType< Consumer< typenameT::value_type >, typenameT::iterator >::T wibble::consumer

(

T &

c

)

References consumer().

consumerMorph()

template<typename R >

Consumer< typename R::ConsumedType > wibble::consumerMorph

(

R

r

)

Referenced by consumer().

downcast() [1/2]

template<typename T , typename X >

X::template Convert< T >::type & wibble::downcast

(

const X &

a

)

downcast() [2/2]

template<typename T , typename X >

T & wibble::downcast

(

X *

v

)

endAssertFailure()

void wibble::endAssertFailure ( )

inline

References assert, and assertFailure.

Referenced by wibble::ExpectFailure::~ExpectFailure().

filteredRange()

template<typename R , typename Pred >

FilteredRange< R, Pred > wibble::filteredRange	(	R	r,
		Pred	p
	)

generatedRange()

template<typename T , typename A , typename E >

GeneratedRange< T, A, E > wibble::generatedRange	(	T	t,
		A	a,
		E	e
	)

intersectionRange()

template<typename R >

IntersectionRange< typename R::ElementType > wibble::intersectionRange	(	R	r1,
		R	r2
	)

isSortedT() [1/2]

template<typename T , typename I >

IteratorTraits< T, I >::Unsorted wibble::isSortedT	(	I	,
		I
	)

isSortedT() [2/2]

template<typename T , typename I >

IteratorTraits< T, I >::Sorted wibble::isSortedT	(	I	,
		I
	)

iterator()

template<typename I >

Iterator< typename I::value_type > wibble::iterator

(

I

i

)

Referenced by wibble::net::http::Params::add(), wibble::commandline::ArgList::eraseAndAdvance(), wibble::net::http::Params::field(), wibble::net::http::Params::obtain_field(), and wibble::net::http::Params::~Params().

operator&()

template<typename Self , typename = typename std::enable_if< is_enum_class< Self >::value >::type>

constexpr StrongEnumFlags< Self > wibble::operator& ( Self  a, Self  b  )

constexprnoexcept

operator<<() [1/2]

template<typename X >

AssertFailed & wibble::operator<< ( AssertFailed &  f, X  x  )

inline

References wibble::AssertFailed::str.

operator<<() [2/2]

template<typename X , typename Y >

std::ostream & wibble::operator<< ( std::ostream &  o, const std::pair< X, Y > &  x  )

inline

operator|()

template<typename Self , typename = typename std::enable_if< is_enum_class< Self >::value >::type>

constexpr StrongEnumFlags< Self > wibble::operator| ( Self  a, Self  b  )

constexprnoexcept

range() [1/2]

template<typename C >

Range< typename C::iterator::value_type > wibble::range

(

C &

c

)

References range().

range() [2/2]

template<typename In >

Range< typename In::value_type > wibble::range	(	In	b,
		In	e
	)

Referenced by range().

singleton()

template<typename T >

Singleton< T > wibble::singleton

(

const T &

value

)

transformedRange()

template<typename Trans >

TransformedRange< Trans > wibble::transformedRange	(	Range< typename Trans::argument_type >	r,
		Trans	t
	)

uniqueRange()

template<typename R >

UniqueRange< typename R::ElementType > wibble::uniqueRange

(

R

r1

)

unwrap() [1/2]

template<typename T >

T::WrappedType & wibble::unwrap

(

const T &

x

)

unwrap() [2/2]

template<typename T >

T & wibble::unwrap

(

T &

x

)

upcastRange()

template<typename T , typename C >

Range< T > wibble::upcastRange

(

C

r

)

Variable Documentation

assertFailure

int wibble::assertFailure = 0

Referenced by wibble::AssertFailed::AssertFailed(), beginAssertFailure(), endAssertFailure(), and wibble::AssertFailed::~AssertFailed().