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

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

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

Function Documentation

void wibble::assert_die_fn ( Location  l)
template<typename X , typename Y >
void wibble::assert_eq_fn ( Location  l,
x,
y 
)
template<typename X >
void wibble::assert_fn ( Location  l,
x 
)
template<typename X , typename Y >
void wibble::assert_leq_fn ( Location  l,
x,
y 
)
template<typename X >
void wibble::assert_list_eq_fn ( Location  loc,
int  c,
l,
const typename X::Type  check[] 
)

References wibble::str::fmt().

template<typename X , typename Y >
void wibble::assert_neq_fn ( Location  l,
x,
y 
)
template<typename X >
void wibble::assert_pred_fn ( Location  l,
x,
bool  p 
)
void wibble::beginAssertFailure ( )
inline
template<typename T , typename C >
Range< T > wibble::castedRange ( r)
template<typename Out >
Consumer< typename Out::container_type::value_type > wibble::consumer ( Out  out)

References consumerMorph().

Referenced by consumer().

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

References consumer().

template<typename T >
Consumer< T > wibble::consumer ( const ConsumerInterface< T > &  t)
template<typename R >
Consumer< typename R::ConsumedType > wibble::consumerMorph ( r)

Referenced by consumer().

template<typename T , typename X >
T& wibble::downcast ( X *  v)
template<typename T , typename X >
X::template Convert<T>::type& wibble::downcast ( const X &  a)
void wibble::endAssertFailure ( )
inline
template<typename R , typename Pred >
FilteredRange< R, Pred > wibble::filteredRange ( r,
Pred  p 
)
template<typename T , typename A , typename E >
GeneratedRange< T, A, E > wibble::generatedRange ( t,
a,
e 
)
template<typename R >
IntersectionRange< typename R::ElementType > wibble::intersectionRange ( r1,
r2 
)
template<typename T , typename I >
IteratorTraits< T, I >::Unsorted wibble::isSortedT ( ,
 
)
template<typename T , typename I >
IteratorTraits< T, I >::Sorted wibble::isSortedT ( ,
 
)
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::Singleton< T >::begin(), TestCommandlineEngine::clusteredShortOpts(), TestCommandlineEngine::commandsWithoutCommand(), TestCommandlineEngine::commandsWithOverlappingArgs(), TestCommandlineEngine::commandWithArg(), wibble::Lexer< Token, IOStream >::consume(), TestCommandlineEngine::creationShortcuts(), wibble::Empty< T >::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-=(), TestCommandlineEngine::optsAndArgs(), TestCommandlineEngine::optsOnly(), wibble::commandline::Engine::parse(), wibble::commandline::Engine::parseFirstIfKnown(), wibble::commandline::Engine::parseKnownSwitches(), 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().

template<typename Self , typename = typename std::enable_if< is_enum_class< Self >::value >::type>
constexpr StrongEnumFlags< Self > wibble::operator& ( Self  a,
Self  b 
)
noexcept
template<typename X , typename Y >
std::ostream& wibble::operator<< ( std::ostream &  o,
const std::pair< X, Y > &  x 
)
inline
template<typename X >
AssertFailed& wibble::operator<< ( AssertFailed &  f,
x 
)
inline
template<typename Self , typename = typename std::enable_if< is_enum_class< Self >::value >::type>
constexpr StrongEnumFlags< Self > wibble::operator| ( Self  a,
Self  b 
)
noexcept
template<typename In >
Range< typename In::value_type > wibble::range ( In  b,
In  e 
)

Referenced by range().

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

References range().

template<typename T >
Singleton<T> wibble::singleton ( const T &  value)
template<typename Trans >
TransformedRange< Trans > wibble::transformedRange ( Range< typename Trans::argument_type >  r,
Trans  t 
)
template<typename R >
UniqueRange< typename R::ElementType > wibble::uniqueRange ( r1)
template<typename T >
T::WrappedType& wibble::unwrap ( const T &  x)
template<typename T >
T& wibble::unwrap ( T &  x)
template<typename T , typename C >
Range< T > wibble::upcastRange ( r)

Variable Documentation

int wibble::assertFailure = 0