wibble  1.1
Namespaces | Classes | Typedefs | Functions | Variables
wibble Namespace Reference

Namespaces

 commandline
 
 exception
 
 grcal
 
 list
 
 log
 
 mixin
 
 net
 
 operators
 
 param
 
 str
 
 stream
 
 sys
 
 tests
 
 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< typename T::value_type >, typename T::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 >
AssertFailedoperator<< (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)

Referenced by assert_fn().

◆ assert_eq_fn()

template<typename X , typename Y >
void wibble::assert_eq_fn ( Location  l,
x,
y 
)

◆ assert_fn()

template<typename X >
void wibble::assert_fn ( Location  l,
x 
)

References assert_die_fn().

◆ assert_leq_fn()

template<typename X , typename Y >
void wibble::assert_leq_fn ( Location  l,
x,
y 
)

◆ assert_list_eq_fn()

template<typename X >
void wibble::assert_list_eq_fn ( Location  loc,
int  c,
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,
y 
)

◆ assert_pred_fn()

template<typename X >
void wibble::assert_pred_fn ( Location  l,
x,
bool  p 
)

◆ beginAssertFailure()

void wibble::beginAssertFailure ( )
inline

◆ castedRange()

template<typename T , typename C >
Range< T > wibble::castedRange ( r)

◆ consumer() [1/3]

template<typename Out >
Consumer< typename Out::container_type::value_type > wibble::consumer ( Out  out)

References consumerMorph().

Referenced by consumer().

◆ consumer() [2/3]

template<typename T >
IsType< Consumer< typename T::value_type >, typename T::iterator >::T wibble::consumer ( T &  c)

References consumer().

◆ consumer() [3/3]

template<typename T >
Consumer< T > wibble::consumer ( const ConsumerInterface< T > &  t)

◆ consumerMorph()

template<typename R >
Consumer< typename R::ConsumedType > wibble::consumerMorph ( r)

Referenced by consumer().

◆ downcast() [1/2]

template<typename T , typename X >
T& wibble::downcast ( X *  v)

◆ downcast() [2/2]

template<typename T , typename X >
X::template Convert<T>::type& wibble::downcast ( const X &  a)

◆ endAssertFailure()

void wibble::endAssertFailure ( )
inline

◆ filteredRange()

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

◆ generatedRange()

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

◆ intersectionRange()

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

◆ isSortedT() [1/2]

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

◆ isSortedT() [2/2]

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

◆ iterator()

template<typename I >
Iterator< typename I::value_type > wibble::iterator ( i)

Referenced by wibble::commandline::Engine::add(), wibble::net::http::Params::add(), wibble::commandline::Engine::addWithoutAna(), wibble::Empty< T >::begin(), wibble::RangeMixin< T, GeneratedRange< T, _Advance, _End > >::begin(), wibble::Singleton< T >::begin(), TestCommandlineEngine::clusteredShortOpts(), TestCommandlineEngine::commandsWithoutCommand(), TestCommandlineEngine::commandsWithOverlappingArgs(), TestCommandlineEngine::commandWithArg(), wibble::Lexer< Token, IOStream >::consume(), TestCommandlineEngine::creationShortcuts(), wibble::Empty< T >::end(), wibble::RangeMixin< T, GeneratedRange< T, _Advance, _End > >::end(), wibble::Singleton< T >::end(), TestCommandlineCore::eraseAndAdvance(), wibble::commandline::ArgList::eraseAndAdvance(), wibble::ParseContext< Token, Stream >::errors(), wibble::net::http::Params::field(), wibble::net::http::Params::file_field(), TestCommandlineEngine::longOptsWithArgs(), TestCommandlineEngine::longOptsWithDashes(), wibble::Lexer< Token, IOStream >::match(), wibble::sys::Pipe::nextLine(), TestCommandlineEngine::noSwitchesAfterFirstArg(), wibble::net::http::Params::obtain_field(), wibble::net::http::Params::obtain_file_field(), wibble::operators::operator&=(), wibble::operators::operator-=(), wibble::commandline::Option::Option(), TestCommandlineEngine::optsAndArgs(), TestCommandlineEngine::optsOnly(), wibble::commandline::Engine::parse(), wibble::commandline::Engine::parseFirstIfKnown(), wibble::commandline::Engine::parseKnownSwitches(), wibble::commandline::Engine::parseList(), wibble::net::http::FileParam::FileInfo::read(), wibble::net::mime::Reader::read_headers(), tut::test_runner::register_group(), wibble::log::Tee::send(), wibble::Lexer< Token, IOStream >::window(), 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 
)
noexcept

◆ operator<<() [1/2]

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

◆ operator<<() [2/2]

template<typename X >
AssertFailed& wibble::operator<< ( AssertFailed f,
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 
)
noexcept

◆ range() [1/2]

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

Referenced by range().

◆ range() [2/2]

template<typename C >
Range< typename C::iterator::value_type > wibble::range ( C &  c)

References 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 ( 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 ( r)

Variable Documentation

◆ assertFailure

int wibble::assertFailure = 0