Elm  2
ELM is a library providing generic data structures, OS-independent interface, plugins and XML.
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 >
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 >
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::Typetype_of (void)
 
template<class T >
const rtti::Typetype_of (const T &v)
 
template<class T >
const rtti::Typetemplate_of (void)
 
template<class T >
const rtti::Typetemplate_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 >
AutoStringoperator<< (CString str, const T &value)
 
template<class T >
AutoStringoperator<< (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::Outputoperator<< (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::Outputoperator<< (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::Inputoperator>> (io::Input &in, Pair< T1, T2 > &p)
 
template<class T >
Outputoperator<< (Output &out, const Ref< T > &ref)
 
io::Outputoperator<< (io::Output &out, const Time &t)
 
template<class T >
UniquePtr< T > unique (T *p)
 
io::Outputoperator<< (io::Output &out, const Version &version)
 
io::Outputoperator<< (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

◆ error_level_t

◆ Path

◆ string

typedef String string

◆ type_t

◆ word_t

◆ xstring

Enumeration Type Documentation

◆ error_level_t

Enumerator
level_none 
level_info 
level_warning 
level_error 
level_fatal 

Function Documentation

◆ _unqualify()

CString elm::_unqualify ( CString  name)
inline

◆ 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

◆ elm_spy()

T elm::elm_spy ( cstring  comment,
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() [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 
)
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
pPointer 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

◆ 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

◆ mask()

word_t elm::mask ( int  n)
inline

◆ 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

◆ 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 ( i,
j,
s = 1 
)

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

Parameters
iLower bound of the range (inclusive).
jUpper bound of the range (inclusive).
sStep 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
outOutput stream to use.
tTime 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 
)

◆ 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

◆ 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

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

◆ 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
cCollection to select items in.
pPredicate 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

◆ str()

◆ STRONG_TYPE()

elm::STRONG_TYPE ( inode_t  ,
ino_t   
)

◆ subiter()

◆ 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

◆ 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

◆ FILL

const word_t FILL = 0x80000000
static

◆ 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

◆ ONES

const word_t ONES = 0x40000000
static

◆ 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