wibble 1.1
Namespaces | Classes | Typedefs | Functions | Variables
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, PredfilteredRange (R r, Pred p)
 
template<typename R >
UniqueRange< typename R::ElementType > uniqueRange (R r1)
 
template<typename Trans >
TransformedRange< TranstransformedRange (Range< typename Trans::argument_type > r, Trans t)
 
template<typename T , typename A , typename E >
GeneratedRange< T, A, EgeneratedRange (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< Selfoperator| (Self a, Self b) noexcept
 
template<typename Self , typename = typename std::enable_if< is_enum_class< Self >::value >::type>
constexpr StrongEnumFlags< Selfoperator& (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

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

◆ 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

◆ 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,
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)

◆ 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

◆ 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