elm Namespace Reference

Namespaces
	array
	avl
	block
	checksum
	color
	concept
	dtd
	dyndata
	genstruct
	imm
	inhstruct
	ini
	intern
	io
	json
	log
	meta
	net
	option
	rtti
	serial2
	stree
	sys
	t
	utf16
	utf8
	variant
	win
	xom

Classes
struct	_false
struct	_if
struct	_if< false, T, E >
struct	_n
struct	_true
class	AbstractBlockAllocatorWithGC
class	AbstractGC
struct	Add
class	AllocArray
class	AllocatorDelegate
class	Array
class	ArrayDelegate
class	ArrayList
class	AssocComparator
class	AssocEquiv
class	AssocHashKey
class	AutoCleaner
class	AutoString
class	AutoStringStartup
class	BadAlloc
class	Bag
class	BiDiList
class	BinomialQueue
class	BitVector
class	BlockAllocator
class	BlockAllocatorWithGC
class	Buffer
class	BufferException
class	builder
class	Char
struct	class_one
struct	class_zero
class	Cleaner
class	CleanList
class	Comparator
class	Comparator< cstring >
class	Comparator< Pair< K, T > >
class	Comparator< string >
class	ComparatorDelegate
class	CompareEquiv
class	CompareManager
class	ConstPreIter
class	CrashHandler
class	CrashMonitor
class	CString
class	Default
struct	default_t
class	DefaultAllocator
class	DefaultAllocatorDelegate
class	DefaultField
class	Deletor
class	DynamicComparator
struct	enum_info
struct	enum_t
class	EqualsEquiv
class	Equiv
class	EquivDelegate
class	EquivManager
class	ErrorBase
class	ErrorHandler
class	Exception
class	Field
class	Flags
class	Formatter
class	FragTable
class	GCManager
class	GDBCrashHandler
class	GlobalComparator
class	GroupedGC
class	HashDelegate
class	Hasher
class	HashKey
class	HashKey< const T * >
class	HashKey< CString >
class	HashKey< inode_t >
class	HashKey< int >
class	HashKey< Pair< T1, T2 > >
class	HashKey< String >
class	HashKey< sys::Path >
class	HashKey< T * >
class	HashManager
class	HashMap
class	HashSet
class	HashTable
class	IdAdapter
class	IndexedIterator
class	Initializer
class	InplacePreIterator
class	iter
class	Iterable
class	KeyException
class	List
class	ListGC
class	ListMap
class	ListQueue
class	ListSet
class	Lock
class	LockPtr
class	MapDelegate
class	MessageException
struct	Mul
class	MutPreIter
class	NoCrashHandler
class	NoInfoHandler
class	NumIter
class	NumRange
class	Option
class	OptionalNone
class	OrderedInitializer
class	Pair
class	PairAdapter
class	PreIter
class	PreIterator
class	QuietHandler
class	Range
class	Ref
class	ref_t
class	RefPair
class	ReverseComparator
struct	scalar_one
struct	scalar_t
struct	scalar_zero
class	SelectIter
class	SelfHashKey
class	SharedPtr
struct	signed_info
class	SimpleGC
class	Slice
class	SortedList
class	StackAllocator
class	StaticComparator
class	StaticStack
class	StrictMapDelegate
class	String
class	StringBuffer
class	StringSplit
class	Temp
class	TempPtr
class	TestCase
class	TestSet
struct	ti
class	Time
class	Tree
class	TreeBag
class	TreeMap
struct	true_pred
class	type_info
struct	type_info< bool >
struct	type_info< char >
struct	type_info< const T & >
struct	type_info< const T * >
struct	type_info< cstring >
struct	type_info< double >
struct	type_info< float >
struct	type_info< long double >
struct	type_info< string >
struct	type_info< T & >
struct	type_info< T * >
struct	type_info< t::int16 >
struct	type_info< t::int32 >
struct	type_info< t::int64 >
struct	type_info< t::int8 >
struct	type_info< t::uint16 >
struct	type_info< t::uint32 >
struct	type_info< t::uint64 >
struct	type_info< t::uint8 >
struct	type_info< void >
struct	type_t
class	UniquePtr
struct	unsigned_info
class	VarArg
class	Variant
class	Vector
class	VectorQueue
class	Version
class	WAHVector

Typedefs
typedef DefaultAllocatorDelegate	DefaultAlloc
typedef CString	cstring
typedef String	string
typedef elm::sys::Path	Path
typedef struct elm::default_t	default_t
typedef elm::type_t	type_t
typedef enum elm::error_level_t	error_level_t
typedef xom::String	xstring
typedef WAHVector::word_t	word_t

Enumerations
enum	error_level_t {   level_none = 0, level_info, level_warning, level_error,   level_fatal }

Functions
void	crash (void)
template<class T >
const T &	min (const T &x, const T &y)
template<class T , class C >
const T &	min (const T &x, const T &y, const C &c=single< C >())
template<class T >
const T &	max (const T &x, const T &y)
template<class T , class C >
const T &	max (const T &x, const T &y, const C &c=single< C >())
template<class C >
C::t	min (const C &c)
template<class C , class CC >
C::t	min (const C &c, const CC &cc)
template<class C >
C::t	max (const C &c)
template<class T >
Array< T >	_array (int n, T t[])
template<class T , class E , class A >
bool	operator<= (const T &v, const FragTable< T, E, A > &t)
template<class K , class T , class M >
bool	operator<= (const T &v, const ListMap< K, T, M > &m)
template<class T , class M >
bool	operator<= (const T &val, const ListSet< T, M > &set)
template<class A , class C = Comparator<typename A::t>>
void	quicksort (A &array, const C &c=Comparator< typename A::t >())
template<class I >
Range< I >	range (const I &begin, const I &end)
template<class C >
Slice< C >	slice (C &a, int fst, int cnt)
template<class C , class P >
int	count (const C &c, const P &p)
template<class C , class P >
bool	forall (const C &c, const P &p)
template<class C , class P >
bool	exists (const C &c, const P &p)
template<class C , class P >
C::Iter	find (const C &c, const P &p)
template<class C , class F , class D >
void	map (const C &c, const F &f, D &d)
template<class C , class F >
void	iter (const C &c, const F &f)
template<class C , class F , class T >
T	fold (const C &c, const F &f, T t)
template<class C1 , class C2 >
bool	equals (const C1 &c1, const C2 &c2)
template<class C1 , class C2 >
Pair< typename C1::Iter, typename C2::Iter >	mismatch (const C1 &c1, const C2 &c2)
template<class C1 , class C2 , class P >
Pair< typename C1::Iter, typename C2::Iter >	mismatch (const C1 &c1, const C2 &c2, P p)
template<class C >
void	deleteAll (const C &c)
template<class C >
C::t	sum (const C &c)
template<class C >
C::t	product (const C &c)
template<class C >
void	fill (C &c, int n, const typename C::t v=type_info< typename C::t >::null)
template<class T >
NumRange< T >	nrange (T i, T j, T s=1)
template<class I , class P >
SelectIter< I, P >	select_iter (const I &i, const P &p)
template<class C , class P >
Range< SelectIter< typename C::Iter, P > >	select (const C &c, const P &p)
template<class I >
Iterable< I >	subiter (const I &b, const I &e)
void	trace (CString file, int line, CString fun)
template<class T >
T	elm_spy (cstring comment, T value)
t::hash	hash_string (const char *chars, int length)
t::hash	hash_cstring (const char *chars)
t::hash	hash_jenkins (const void *block, int size)
t::hash	hash_ptr (const void *p)
bool	hash_equals (const void *p1, const void *p2, int size)
template<class T >
t::hash	hash (const T &x)
int	ones (t::uint8 i)
int	countOnes (t::uint16 i)
int	countOnes (t::uint32 i)
int	countOnes (t::uint64 i)
int	msb (t::uint32 i)
int	msb (t::int32 i)
int	msb (t::uint64 i)
int	msb (t::int64 i)
t::uint32	leastUpperPowerOf2 (t::uint32 v)
t::uint64	leastUpperPowerOf2 (t::uint64 v)
t::uint32	abs (t::int32 v)
t::uint64	abs (t::int64 v)
t::uint32	roundup (t::uint32 v, t::uint32 m)
t::uint32	rounddown (t::uint32 v, t::uint32 m)
t::uint32	mult (t::uint32 a, t::uint32, bool &over)
t::uint64	mult (t::uint64 a, t::uint64, bool &over)
int	ones (t::uint16 i)
int	ones (t::uint32 i)
int	ones (t::uint64 i)
template<class T >
const rtti::Type &	type_of (void)
template<class T >
const rtti::Type &	type_of (const T &v)
template<class T >
const rtti::Type &	template_of (void)
template<class T >
const rtti::Type &	template_of (const T &v)
template<class T >
Field< T >	field (CString name, T &value)
template<class T >
DefaultField< T >	field (CString name, T &value, const T &def)
template<class T >
DefaultField< T >	field (CString name, const T &value, const T &def)
CString	_unqualify (CString name)
template<class T >
AutoString &	operator<< (CString str, const T &value)
template<class T >
AutoString &	operator<< (const String &str, const T &value)
template<class T >
io::StringInput	operator>> (const string &str, T &val)
template<class T >
io::StringInput	operator>> (cstring str, T &val)
cstring	cstr (const char *s)
string	str (const char *s)
bool	operator== (const CString &s1, const CString &s2)
bool	operator!= (const CString &s1, const CString &s2)
bool	operator< (const CString s1, const CString s2)
bool	operator<= (const CString s1, const CString s2)
bool	operator> (const CString s1, const CString s2)
bool	operator>= (const CString s1, const CString s2)
bool	operator== (const String &s1, const CString s2)
bool	operator!= (const String &s1, const CString s2)
bool	operator< (const String &s1, const CString s2)
bool	operator<= (const String &s1, const CString s2)
bool	operator> (const String &s1, const CString s2)
bool	operator>= (const String &s1, const CString s2)
bool	operator== (const String &s1, const String &s2)
bool	operator!= (const String &s1, const String &s2)
bool	operator< (const String &s1, const String &s2)
bool	operator<= (const String &s1, const String &s2)
bool	operator> (const String &s1, const String &s2)
bool	operator>= (const String &s1, const String &s2)
bool	operator== (const CString s1, const String &s2)
bool	operator!= (const CString s1, const String &s2)
bool	operator< (const CString s1, const String &s2)
bool	operator<= (const CString s1, const String &s2)
bool	operator> (const CString s1, const String &s2)
bool	operator>= (const CString s1, const String &s2)
bool	operator== (const String &s1, const char *s2)
bool	operator!= (const String &s1, const char *s2)
bool	operator< (const String &s1, const char *s2)
bool	operator<= (const String &s1, const char *s2)
bool	operator> (const String &s1, const char *s2)
bool	operator>= (const String &s1, const char *s2)
bool	operator== (const CString s1, const char *s2)
bool	operator!= (const CString s1, const char *s2)
bool	operator< (const CString s1, const char *s2)
bool	operator<= (const CString s1, const char *s2)
bool	operator> (const CString s1, const char *s2)
bool	operator>= (const CString s1, const char *s2)
bool	operator== (const char *s1, const CString s2)
bool	operator!= (const char *s1, const CString s2)
bool	operator< (const char *s1, const CString s2)
bool	operator<= (const char *s1, const CString s2)
bool	operator> (const char *s1, const CString s2)
bool	operator>= (const char *s1, const CString s2)
bool	operator== (const char *s1, const String &s2)
bool	operator!= (const char *s1, const String &s2)
bool	operator< (const char *s1, const String &s2)
bool	operator<= (const char *s1, const String &s2)
bool	operator> (const char *s1, const String &s2)
bool	operator>= (const char *s1, const String &s2)
String	operator+ (const CString &s1, const CString &s2)
String	operator+ (const CString &s1, const char *s2)
String	operator+ (const CString s1, const String &s2)
String	operator+ (const cstring &s, char c)
String	operator+ (const String &s1, const CString s2)
String	operator+ (const String &s1, const char *s2)
String	operator+ (const String &s1, const String &s2)
String	operator+ (const string &s, char c)
String	operator+ (const char *s1, const CString s2)
String	operator+ (const char *s1, const String &s2)
String	operator+ (char c, const cstring s)
String	operator+ (char c, const String &s)
template<class T >
T &	single (void)
template<class T >
T *	null (void)
io::Output &	operator<< (io::Output &out, const BitVector &bvec)
template<class T >
void	swap (T &x, T &y)
template<class T >
Option< T >	some (const T &val)
template<class T1 , class T2 >
Pair< T1, T2 >	pair (const T1 &v1, const T2 &v2)
template<class T1 , class T2 >
io::Output &	operator<< (io::Output &out, const Pair< T1, T2 > &p)
template<class T1 , class T2 >
RefPair< T1, T2 >	let (T1 &v1, T2 &v2)
template<class T1 , class T2 >
io::Input &	operator>> (io::Input &in, Pair< T1, T2 > &p)
template<class T >
Output &	operator<< (Output &out, const Ref< T > &ref)
io::Output &	operator<< (io::Output &out, const Time &t)
template<class T >
UniquePtr< T >	unique (T *p)
io::Output &	operator<< (io::Output &out, const Version &version)
io::Output &	operator<< (io::Output &out, const WAHVector &v)
static void	handle_SIGSEGV (int sig, siginfo_t *info, void *context)
static void	handle_SIGILL (int sig, siginfo_t *info, void *context)
static void	handle_SIGABRT (int sig, siginfo_t *info, void *context)
static void	handle_SIGFPE (int sig, siginfo_t *info, void *context)
static void	handle_SIGINT (int sig, siginfo_t *info, void *context)
static bool	is (unsigned char c, t::uint64 set[])
	STRONG_TYPE (inode_t, ino_t)
io::Output	cout (buf_out)
io::Output	cerr (buf_err)
bool	isFill (word_t w)
bool	isLite (word_t w)
bool	isOnes (word_t w)
bool	isZeroes (word_t w)
word_t	fillCount (word_t w)
word_t	mask (int n)
word_t	lite (word_t w)
word_t	fill (int size, bool init)
int	times (int v)
int	div (int v)
int	mod (int v)

Variables
io::Output	cout
io::Output	cerr
io::Input	cin
io::Monitor	monitor
AutoStringStartup	autostr
AutoStringStartup &	_ = autostr
const OptionalNone	none = OptionalNone()
static t::uint64	bin_set [] = { 0x3000000000000, 0x00000000, 0x00000000, 0x00000000 }
static t::uint64	dec_set [] = { 0x3ff000000000000, 0x00000000, 0x00000000, 0x00000000 }
static t::uint64	hex_set [] = { 0x3ff000000000000, 0x7e0000007e, 0x00000000, 0x00000000 }
static t::uint64	space_set [] = { 0x100002e00, 0x00000000, 0x00000000, 0x00000000 }
static t::uint64	letter_set [] = { 0x00000000, 0x7fffffe07fffffe, 0x00000000, 0x00000000 }
static t::uint64	lower_set [] = { 0x00000000, 0x7fffffe00000000, 0x00000000, 0x00000000 }
static t::uint64	upper_set [] = { 0x00000000, 0x07fffffe, 0x00000000, 0x00000000 }
static HashMap< inode_t, sys::FileItem * > *	files = 0
static io::BufferedOutStream	buf_out (io::out)
static io::BufferedOutStream	buf_err (io::err)
static NoInfoHandler	NO_INFO_HANDLER
static QuietHandler	QUIET_HANDLER
static const word_t	FILL = 0x80000000
static const word_t	ONES = 0x40000000
static const word_t	ALL_ONES = 0x7fffffff
static const word_t	ALL_ZEROES = 0x00000000
static int	WORD_SIZE = 31

Typedef Documentation

cstring

typedef CString cstring

default_t

typedef struct elm::default_t default_t

DefaultAlloc

typedef DefaultAllocatorDelegate DefaultAlloc

error_level_t

typedef enum elm::error_level_t error_level_t

Path

typedef elm::sys::Path Path

string

typedef String string

type_t

typedef elm::type_t type_t

word_t

typedef WAHVector::word_t word_t

xstring

typedef xom::String xstring

Enumeration Type Documentation

error_level_t

enum error_level_t

Enumerator
level_none
level_info
level_warning
level_error
level_fatal

Function Documentation

_unqualify()

CString elm::_unqualify ( CString  name )

inline

References CString::lastIndexOf(), and CString::substring().

abs() [1/2]

t::uint32 elm::abs ( t::int32  v )

inline

abs() [2/2]

t::uint64 elm::abs ( t::int64  v )

inline

countOnes() [1/3]

int elm::countOnes ( t::uint16  i )

inline

References ones().

Referenced by ones(), rounddown(), and roundup().

countOnes() [2/3]

int elm::countOnes ( t::uint32  i )

inline

References ones().

countOnes() [3/3]

int elm::countOnes ( t::uint64  i )

inline

References ones().

crash()

void crash

(

void

)

@degroup debug Debugging Support

ELM provides several facilities to debug your own application.

crash Automatic Crash Support

As it is a tedious task to restart a program from a debugger after a crash, ELM provides CrashHandler class to associate an action with such an event.

Basically, the behavior of this handler depends on the configuration of the environment. Two environment variable are taken in account :

• if ELM_DEBUG=yes, the handler is invoked when an error signal is sent,
• if ELM_INT=yes, the handler is invoked when the program is interrupted (usually by Control-C on Unix platform).

The used handler depends on the configuration of the ELM library. The handler to use is defined by the CRASH_HANDLER definition variable and may be changed in the config.h file at the source root of ELM. As a defaut, the GDBCrashHandler::DEFAULT handler is used on Unix systems. For the time being, there is no other crash handler but the user may provide its own crash handler by calling the method CrashHandler::set().

The GDBCrashHandler invokes the GDB debugger on the current process when a crash arises.

debug_helper Debug Helper Macros

These macros help obtaining log during debugging phase. They are all de-activated as soon as the macro NDEBUG is defined (as for standard C assert macro).

• TRACE – print current source file, line and container function.
• HERE – put an empty instruction making easier for the debugger to mark break lines.
• BREAK(c) – if condition c evaluates to false, executes the following code (HERE for example to get conditional breakpoint).
• SPY(c, v) – displays string comment followed by the given value and returns this one. Useful to spy values in an expression. This function cause a crash of the program. According the system, it may cause a core dump, GDB invocation or any other debugging solution.

References CrashHandler::crash().

cstr()

cstring elm::cstr ( const char *  s )

inline

div()

int elm::div ( int  v )

inline

Referenced by WAHVector::clear(), mod(), WAHVector::set(), and WAHVector::WAHVector().

elm_spy()

T elm::elm_spy ( cstring  comment, T  value  )

inline

References cerr, and elm::io::endl.

field() [1/3]

DefaultField<T> elm::field ( CString  name, const T &  value, const T &  def  )

inline

field() [2/3]

Field<T> elm::field ( CString  name, T &  value  )

inline

Referenced by elm::serial2::__serialize(), elm::serial2::__unserialize(), elm::serial2::operator&(), and elm::serial2::operator>>().

field() [3/3]

DefaultField<T> elm::field ( CString  name, T &  value, const T &  def  )

inline

fill()

word_t elm::fill ( int  size, bool  init  )

inline

References FILL, and ONES.

fillCount()

word_t elm::fillCount ( word_t  w )

inline

References FILL, and ONES.

Referenced by builder::pushFill().

find()

C::Iter elm::find ( const C &  c, const P &  p  )

inline

References elm::io::p().

fold()

T elm::fold ( const C &  c, const F &  f, T  t  )

inline

Referenced by product(), and sum().

handle_SIGABRT()

static void elm::handle_SIGABRT ( int  sig, siginfo_t *  info, void *  context  )

static

References CrashHandler::crash().

Referenced by CrashHandler::setup().

handle_SIGFPE()

static void elm::handle_SIGFPE ( int  sig, siginfo_t *  info, void *  context  )

static

References CrashHandler::crash().

Referenced by CrashHandler::setup().

handle_SIGILL()

static void elm::handle_SIGILL ( int  sig, siginfo_t *  info, void *  context  )

static

References CrashHandler::crash().

Referenced by CrashHandler::setup().

handle_SIGINT()

static void elm::handle_SIGINT ( int  sig, siginfo_t *  info, void *  context  )

static

References CrashHandler::crash().

Referenced by CrashHandler::setup().

handle_SIGSEGV()

static void elm::handle_SIGSEGV ( int  sig, siginfo_t *  info, void *  context  )

static

References CrashHandler::crash().

Referenced by CrashHandler::setup().

hash_ptr()

t::hash hash_ptr ( const void *  p )

inline

Perform hashing of the given pointer. Currently, it removes bits of current OS alignments constrains.

Parameters

p	Pointer to hash.

Returns

Hashed pointer.

References elm::io::p().

Referenced by HashKey< T * >::hash(), and HashKey< const T * >::hash().

is()

static bool elm::is ( unsigned char  c, t::uint64  set[]  )

inlinestatic

Referenced by Char::isBin(), Char::isDec(), Char::isHex(), Char::isLetter(), Char::isLowerCase(), Char::isSpace(), Char::isUpperCase(), and Set< T, C >::meet().

isFill()

bool elm::isFill ( word_t  w )

inline

References FILL.

isLite()

bool elm::isLite ( word_t  w )

inline

References FILL.

Referenced by builder::fix().

isOnes()

bool elm::isOnes ( word_t  w )

inline

References ONES.

Referenced by builder::fix(), and WAHVector::isFull().

isZeroes()

bool elm::isZeroes ( word_t  w )

inline

References ONES.

Referenced by builder::fix(), and WAHVector::isEmpty().

let()

RefPair<T1, T2> elm::let ( T1 &  v1, T2 &  v2  )

inline

lite()

word_t elm::lite ( word_t  w )

inline

Referenced by WAHVector::clear(), builder::fix(), and WAHVector::set().

mask()

word_t elm::mask ( int  n )

inline

Referenced by WAHVector::countOnes(), and builder::fix().

max() [1/2]

C::t elm::max ( const C &  c )

inline

max() [2/2]

const T& elm::max ( const T &  x, const T &  y, const C &  c = single<C>()  )

inline

min() [1/3]

C::t elm::min ( const C &  c )

inline

min() [2/3]

C::t elm::min ( const C &  c, const CC &  cc  )

inline

min() [3/3]

const T& elm::min ( const T &  x, const T &  y, const C &  c = single<C>()  )

inline

mod()

int elm::mod ( int  v )

inline

References div(), and times().

Referenced by WAHVector::bit(), WAHVector::clear(), System::getUnitPath(), and WAHVector::set().

msb() [1/2]

int elm::msb ( t::int32  i )

inline

References msb().

msb() [2/2]

int elm::msb ( t::int64  i )

inline

References msb().

nrange()

NumRange< T > nrange	(	T	i,
		T	j,
		T	s = 1
	)

Creates a range over a numeric domain spanning from i to j using a step of s.

Parameters

i	Lower bound of the range (inclusive).
j	Upper bound of the range (inclusive).
s	Step in the range.

Returns

Range from i to j (with a step of s).

operator!=() [1/8]

bool elm::operator!= ( const char *  s1, const CString  s2  )

inline

References CString::compare().

operator!=() [2/8]

bool elm::operator!= ( const char *  s1, const String &  s2  )

inline

References String::compare().

operator!=() [3/8]

bool elm::operator!= ( const CString &  s1, const CString &  s2  )

inline

References CString::compare().

operator!=() [4/8]

bool elm::operator!= ( const CString  s1, const char *  s2  )

inline

References CString::compare().

operator!=() [5/8]

bool elm::operator!= ( const CString  s1, const String &  s2  )

inline

References String::compare().

operator!=() [6/8]

bool elm::operator!= ( const String &  s1, const char *  s2  )

inline

References String::compare().

operator!=() [7/8]

bool elm::operator!= ( const String &  s1, const CString  s2  )

inline

References String::compare().

operator!=() [8/8]

bool elm::operator!= ( const String &  s1, const String &  s2  )

inline

References String::compare().

operator+() [1/12]

String elm::operator+ ( char  c, const cstring  s  )

inline

References CString::concat().

operator+() [2/12]

String elm::operator+ ( char  c, const String &  s  )

inline

References CString::concat().

operator+() [3/12]

String elm::operator+ ( const char *  s1, const CString  s2  )

inline

References CString::concat().

operator+() [4/12]

String elm::operator+ ( const char *  s1, const String &  s2  )

inline

References CString::concat().

operator+() [5/12]

String elm::operator+ ( const cstring &  s, char  c  )

inline

References CString::concat().

operator+() [6/12]

String elm::operator+ ( const CString &  s1, const char *  s2  )

inline

References CString::concat().

operator+() [7/12]

String elm::operator+ ( const CString &  s1, const CString &  s2  )

inline

References CString::concat().

operator+() [8/12]

String elm::operator+ ( const CString  s1, const String &  s2  )

inline

References CString::concat().

operator+() [9/12]

String elm::operator+ ( const string &  s, char  c  )

inline

operator+() [10/12]

String elm::operator+ ( const String &  s1, const char *  s2  )

inline

operator+() [11/12]

String elm::operator+ ( const String &  s1, const CString  s2  )

inline

operator+() [12/12]

String elm::operator+ ( const String &  s1, const String &  s2  )

inline

operator<() [1/8]

bool elm::operator< ( const char *  s1, const CString  s2  )

inline

References CString::compare().

operator<() [2/8]

bool elm::operator< ( const char *  s1, const String &  s2  )

inline

References String::compare().

operator<() [3/8]

bool elm::operator< ( const CString  s1, const char *  s2  )

inline

References CString::compare().

operator<() [4/8]

bool elm::operator< ( const CString  s1, const CString  s2  )

inline

References CString::compare().

operator<() [5/8]

bool elm::operator< ( const CString  s1, const String &  s2  )

inline

References String::compare().

operator<() [6/8]

bool elm::operator< ( const String &  s1, const char *  s2  )

inline

References String::compare().

operator<() [7/8]

bool elm::operator< ( const String &  s1, const CString  s2  )

inline

References String::compare().

operator<() [8/8]

bool elm::operator< ( const String &  s1, const String &  s2  )

inline

References String::compare().

operator<<() [1/8]

AutoString& elm::operator<< ( const String &  str, const T &  value  )

inline

References autostr, and str().

operator<<() [2/8]

AutoString& elm::operator<< ( CString  str, const T &  value  )

inline

References autostr, and str().

operator<<() [3/8]

io::Output& elm::operator<< ( io::Output &  out, const BitVector &  bvec  )

inline

References BitVector::print().

operator<<() [4/8]

io::Output& elm::operator<<	(	io::Output &	out,
		const Pair< T1, T2 > &	p
	)

References elm::io::p().

operator<<() [5/8]

io::Output & operator<<	(	io::Output &	out,
		const Time &	t
	)

Display a time.

Parameters

out	Output stream to use.
t	Time to display.

References Time::ONE_D, Time::ONE_H, Time::ONE_M, Time::ONE_MS, Time::ONE_S, Time::ONE_Y, and Time::time().

operator<<() [6/8]

io::Output & operator<<	(	io::Output &	out,
		const Version &	version
	)

References Version::major(), Version::minor(), and Version::release().

operator<<() [7/8]

io::Output& elm::operator<< ( io::Output &  out, const WAHVector &  v  )

inline

References WAHVector::__dump().

operator<<() [8/8]

Output& elm::operator<< ( Output &  out, const Ref< T > &  ref  )

inline

References elm::io::out, and elm::t::ref().

operator<=() [1/11]

bool elm::operator<= ( const char *  s1, const CString  s2  )

inline

References CString::compare().

operator<=() [2/11]

bool elm::operator<= ( const char *  s1, const String &  s2  )

inline

References String::compare().

operator<=() [3/11]

bool elm::operator<= ( const CString  s1, const char *  s2  )

inline

References CString::compare().

operator<=() [4/11]

bool elm::operator<= ( const CString  s1, const CString  s2  )

inline

References CString::compare().

operator<=() [5/11]

bool elm::operator<= ( const CString  s1, const String &  s2  )

inline

References String::compare().

operator<=() [6/11]

bool elm::operator<= ( const String &  s1, const char *  s2  )

inline

References String::compare().

operator<=() [7/11]

bool elm::operator<= ( const String &  s1, const CString  s2  )

inline

References String::compare().

operator<=() [8/11]

bool elm::operator<= ( const String &  s1, const String &  s2  )

inline

References String::compare().

operator<=() [9/11]

bool elm::operator<= ( const T &  v, const FragTable< T, E, A > &  t  )

inline

References FragTable< T, E, A >::contains().

operator<=() [10/11]

bool elm::operator<= ( const T &  v, const ListMap< K, T, M > &  m  )

inline

operator<=() [11/11]

bool elm::operator<= ( const T &  val, const ListSet< T, M > &  set  )

inline

operator==() [1/8]

bool elm::operator== ( const char *  s1, const CString  s2  )

inline

References CString::compare().

operator==() [2/8]

bool elm::operator== ( const char *  s1, const String &  s2  )

inline

References String::compare().

operator==() [3/8]

bool elm::operator== ( const CString &  s1, const CString &  s2  )

inline

References CString::compare().

Referenced by AbstractAttribute::operator!=(), and Element::operator!=().

operator==() [4/8]

bool elm::operator== ( const CString  s1, const char *  s2  )

inline

References CString::compare().

operator==() [5/8]

bool elm::operator== ( const CString  s1, const String &  s2  )

inline

References String::compare().

operator==() [6/8]

bool elm::operator== ( const String &  s1, const char *  s2  )

inline

References String::compare().

operator==() [7/8]

bool elm::operator== ( const String &  s1, const CString  s2  )

inline

References String::compare().

operator==() [8/8]

bool elm::operator== ( const String &  s1, const String &  s2  )

inline

References String::compare().

operator>() [1/8]

bool elm::operator> ( const char *  s1, const CString  s2  )

inline

References CString::compare().

operator>() [2/8]

bool elm::operator> ( const char *  s1, const String &  s2  )

inline

References String::compare().

operator>() [3/8]

bool elm::operator> ( const CString  s1, const char *  s2  )

inline

References CString::compare().

operator>() [4/8]

bool elm::operator> ( const CString  s1, const CString  s2  )

inline

References CString::compare().

operator>() [5/8]

bool elm::operator> ( const CString  s1, const String &  s2  )

inline

References String::compare().

operator>() [6/8]

bool elm::operator> ( const String &  s1, const char *  s2  )

inline

References String::compare().

operator>() [7/8]

bool elm::operator> ( const String &  s1, const CString  s2  )

inline

References String::compare().

operator>() [8/8]

bool elm::operator> ( const String &  s1, const String &  s2  )

inline

References String::compare().

operator>=() [1/8]

bool elm::operator>= ( const char *  s1, const CString  s2  )

inline

References CString::compare().

operator>=() [2/8]

bool elm::operator>= ( const char *  s1, const String &  s2  )

inline

References String::compare().

operator>=() [3/8]

bool elm::operator>= ( const CString  s1, const char *  s2  )

inline

References CString::compare().

operator>=() [4/8]

bool elm::operator>= ( const CString  s1, const CString  s2  )

inline

References CString::compare().

operator>=() [5/8]

bool elm::operator>= ( const CString  s1, const String &  s2  )

inline

References String::compare().

operator>=() [6/8]

bool elm::operator>= ( const String &  s1, const char *  s2  )

inline

References String::compare().

operator>=() [7/8]

bool elm::operator>= ( const String &  s1, const CString  s2  )

inline

References String::compare().

operator>=() [8/8]

bool elm::operator>= ( const String &  s1, const String &  s2  )

inline

References String::compare().

operator>>() [1/3]

io::StringInput elm::operator>> ( const string &  str, T &  val  )

inline

References str().

operator>>() [2/3]

io::StringInput elm::operator>> ( cstring  str, T &  val  )

inline

References str().

operator>>() [3/3]

io::Input& elm::operator>>	(	io::Input &	in,
		Pair< T1, T2 > &	p
	)

References elm::io::p().

pair()

Pair<T1, T2> elm::pair ( const T1 &  v1, const T2 &  v2  )

inline

Referenced by SegmentBuilder< K, T, C >::add(), HashMap< elm::CString, void * >::add(), HashMap< elm::CString, void * >::fetch(), XOMUnserializer::flush(), TreeMap< K, T, C, E, A >::get(), mismatch(), TextSerializer::onPointer(), XOMElementSerializer::onPointer(), XOMUnserializer::onPointer(), Pair< const elm::rtti::Type *, const void * >::operator!=(), Pair< const elm::rtti::Type *, const void * >::operator=(), Pair< const elm::rtti::Type *, const void * >::operator==(), Pair< const elm::rtti::Type *, const void * >::operator>(), Pair< const elm::rtti::Type *, const void * >::operator>=(), System::pipe(), AbstractTree::Stack::push(), ListMap< string, Section * >::put(), HashMap< elm::CString, void * >::put(), TreeMap< K, T, C, E, A >::remove(), and EnumOption< T >::Make::val().

select()

Range< SelectIter< typename C::Iter, P > > select ( const C &  c, const P &  p  )

inline

Creates a range over items of collection c that satisfies the predicate p.

Parameters

c	Collection to select items in.
p	Predicate to select items of c.

Returns

Range on c items satisfying p.

References elm::io::p(), range(), and select_iter().

select_iter()

SelectIter<I, P> elm::select_iter ( const I &  i, const P &  p  )

inline

References elm::io::p().

Referenced by select().

slice()

Slice<C> elm::slice	(	C &	a,
		int	fst,
		int	cnt
	)

some()

Option< T > some ( const T &  val )

inline

This function makes easier the construction of optional value with an available value.

Referenced by HashMap< elm::CString, void * >::get(), Map< Pair< K, K >, T, segment_comparator_t >::get(), ListMap< string, Section * >::get(), HashMap< elm::CString, void * >::get_const(), and Element::getAttributeValue().

str()

string elm::str ( const char *  s )

inline

Referenced by BlockInStream::BlockInStream(), CString::compare(), String::compare(), CString::concat(), String::concat(), CString::endsWith(), String::endsWith(), String::lastIndexOf(), String::make(), StringFormat::operator()(), Fletcher::operator<<(), MD5::operator<<(), elm::xom::operator<<(), AutoStringStartup::operator<<(), operator<<(), CString::operator=(), String::operator=(), Path::operator=(), operator>>(), Output::print(), Fletcher::put(), MD5::put(), BufferedInStream::setStream(), BufferedOutStream::setStream(), CString::startsWith(), String::startsWith(), String::String(), Input::swallow(), and Saver::write().

STRONG_TYPE()

elm::STRONG_TYPE	(	inode_t	,
		ino_t
	)

subiter()

Iterable<I> elm::subiter	(	const I &	b,
		const I &	e
	)

Referenced by HashMap< elm::CString, void * >::keys(), TreeMap< K, T, C, E, A >::keys(), ListMap< string, Section * >::keys(), Map< Pair< K, K >, T, segment_comparator_t >::keys(), HashMap< elm::CString, void * >::pairs(), ListMap< string, Section * >::pairs(), TreeMap< K, T, C, E, A >::pairs(), and Map< Pair< K, K >, T, segment_comparator_t >::pairs().

swap()

void elm::swap	(	T &	x,
		T &	y
	)

Referenced by quicksort(), and elm::array::reverse().

template_of() [1/2]

const rtti::Type& elm::template_of ( const T &  v )

inline

template_of() [2/2]

const rtti::Type& elm::template_of ( void  )

inline

times()

int elm::times ( int  v )

inline

Referenced by iter::consume(), WAHVector::countOnes(), mod(), and WAHVector::size().

trace()

void elm::trace ( CString  file, int  line, CString  fun  )

inline

References cerr, and Output::flush().

type_of()

const rtti::Type& elm::type_of ( const T &  v )

inline

References _type< T >::_().

unique()

UniquePtr<T> elm::unique

(

T *

p

)

References elm::io::p().

Variable Documentation

ALL_ONES

const word_t ALL_ONES = 0x7fffffff

static

Referenced by builder::pushLite().

ALL_ZEROES

const word_t ALL_ZEROES = 0x00000000

static

bin_set

t::uint64 bin_set[] = { 0x3000000000000, 0x00000000, 0x00000000, 0x00000000 }

static

Referenced by Char::isBin().

buf_err

io::BufferedOutStream buf_err(io::err)

static

buf_out

io::BufferedOutStream buf_out(io::out)

static

dec_set

t::uint64 dec_set[] = { 0x3ff000000000000, 0x00000000, 0x00000000, 0x00000000 }

static

Referenced by Char::isDec().

files

HashMap<inode_t, sys::FileItem *>* files = 0

static

Referenced by FileItem::get(), and FileItem::~FileItem().

FILL

const word_t FILL = 0x80000000

static

Referenced by fill(), fillCount(), isFill(), isLite(), builder::push(), and builder::pushFill().

hex_set

t::uint64 hex_set[] = { 0x3ff000000000000, 0x7e0000007e, 0x00000000, 0x00000000 }

static

Referenced by Char::isHex().

letter_set

t::uint64 letter_set[] = { 0x00000000, 0x7fffffe07fffffe, 0x00000000, 0x00000000 }

static

Referenced by Char::isLetter().

lower_set

t::uint64 lower_set[] = { 0x00000000, 0x7fffffe00000000, 0x00000000, 0x00000000 }

static

Referenced by Char::isLowerCase().

monitor

io::Monitor monitor

NO_INFO_HANDLER

NoInfoHandler NO_INFO_HANDLER

static

none

const OptionalNone none = OptionalNone()

This special value cause the construction of an optional value without value available.

Referenced by HashMap< elm::CString, void * >::get(), TreeMap< K, T, C, E, A >::get(), Map< Pair< K, K >, T, segment_comparator_t >::get(), ListMap< string, Section * >::get(), HashMap< elm::CString, void * >::get_const(), and Element::getAttributeValue().

ONES

const word_t ONES = 0x40000000

static

Referenced by fill(), fillCount(), isOnes(), isZeroes(), and builder::pushFill().

QUIET_HANDLER

QuietHandler QUIET_HANDLER

static

space_set

t::uint64 space_set[] = { 0x100002e00, 0x00000000, 0x00000000, 0x00000000 }

static

Referenced by Char::isSpace().

upper_set

t::uint64 upper_set[] = { 0x00000000, 0x07fffffe, 0x00000000, 0x00000000 }

static

Referenced by Char::isUpperCase().

WORD_SIZE

int WORD_SIZE = 31

static