ManaPlus
Data Structures | Enumerations | Functions
Catch::Internal Namespace Reference

Data Structures

struct  OperatorTraits
 
struct  OperatorTraits< IsEqualTo >
 
struct  OperatorTraits< IsNotEqualTo >
 
struct  OperatorTraits< IsLessThan >
 
struct  OperatorTraits< IsGreaterThan >
 
struct  OperatorTraits< IsLessThanOrEqualTo >
 
struct  OperatorTraits< IsGreaterThanOrEqualTo >
 
class  Evaluator
 
struct  Evaluator< T1, T2, IsEqualTo >
 
struct  Evaluator< T1, T2, IsNotEqualTo >
 
struct  Evaluator< T1, T2, IsLessThan >
 
struct  Evaluator< T1, T2, IsGreaterThan >
 
struct  Evaluator< T1, T2, IsGreaterThanOrEqualTo >
 
struct  Evaluator< T1, T2, IsLessThanOrEqualTo >
 

Enumerations

enum  Operator {
  IsEqualTo , IsNotEqualTo , IsLessThan , IsGreaterThan ,
  IsLessThanOrEqualTo , IsGreaterThanOrEqualTo
}
 

Functions

template<typename T >
T & opCast (T const &t)
 
template<Operator Op, typename T1 , typename T2 >
bool applyEvaluator (T1 const &lhs, T2 const &rhs)
 
template<Operator Op, typename T1 , typename T2 >
bool compare (T1 const &lhs, T2 const &rhs)
 
template<Operator Op>
bool compare (unsigned int lhs, int rhs)
 
template<Operator Op>
bool compare (unsigned long lhs, int rhs)
 
template<Operator Op>
bool compare (unsigned char lhs, int rhs)
 
template<Operator Op>
bool compare (unsigned int lhs, long rhs)
 
template<Operator Op>
bool compare (unsigned long lhs, long rhs)
 
template<Operator Op>
bool compare (unsigned char lhs, long rhs)
 
template<Operator Op>
bool compare (int lhs, unsigned int rhs)
 
template<Operator Op>
bool compare (int lhs, unsigned long rhs)
 
template<Operator Op>
bool compare (int lhs, unsigned char rhs)
 
template<Operator Op>
bool compare (long lhs, unsigned int rhs)
 
template<Operator Op>
bool compare (long lhs, unsigned long rhs)
 
template<Operator Op>
bool compare (long lhs, unsigned char rhs)
 
template<Operator Op, typename T >
bool compare (long lhs, T *rhs)
 
template<Operator Op, typename T >
bool compare (T *lhs, long rhs)
 
template<Operator Op, typename T >
bool compare (int lhs, T *rhs)
 
template<Operator Op, typename T >
bool compare (T *lhs, int rhs)
 

Enumeration Type Documentation

◆ Operator

Enumerator
IsEqualTo 
IsNotEqualTo 
IsLessThan 
IsGreaterThan 
IsLessThanOrEqualTo 
IsGreaterThanOrEqualTo 

Definition at line 1301 of file catch.hpp.

1301  {
1302  IsEqualTo,
1303  IsNotEqualTo,
1304  IsLessThan,
1305  IsGreaterThan,
1308  };
@ IsGreaterThanOrEqualTo
Definition: catch.hpp:1307

Function Documentation

◆ applyEvaluator()

template<Operator Op, typename T1 , typename T2 >
bool Catch::Internal::applyEvaluator ( T1 const &  lhs,
T2 const &  rhs 
)

Definition at line 1369 of file catch.hpp.

1369  {
1370  return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
1371  }

◆ compare() [1/17]

template<Operator Op, typename T >
bool Catch::Internal::compare ( int  lhs,
T *  rhs 
)

Definition at line 1435 of file catch.hpp.

1435  {
1436  return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
1437  }

◆ compare() [2/17]

template<Operator Op>
bool Catch::Internal::compare ( int  lhs,
unsigned char  rhs 
)

Definition at line 1411 of file catch.hpp.

1411  {
1412  return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
1413  }

◆ compare() [3/17]

template<Operator Op>
bool Catch::Internal::compare ( int  lhs,
unsigned int  rhs 
)

Definition at line 1405 of file catch.hpp.

1405  {
1406  return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
1407  }

◆ compare() [4/17]

template<Operator Op>
bool Catch::Internal::compare ( int  lhs,
unsigned long  rhs 
)

Definition at line 1408 of file catch.hpp.

1408  {
1409  return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
1410  }

◆ compare() [5/17]

template<Operator Op, typename T >
bool Catch::Internal::compare ( long  lhs,
T *  rhs 
)

Definition at line 1427 of file catch.hpp.

1427  {
1428  return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
1429  }

◆ compare() [6/17]

template<Operator Op>
bool Catch::Internal::compare ( long  lhs,
unsigned char  rhs 
)

Definition at line 1422 of file catch.hpp.

1422  {
1423  return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
1424  }

◆ compare() [7/17]

template<Operator Op>
bool Catch::Internal::compare ( long  lhs,
unsigned int  rhs 
)

Definition at line 1416 of file catch.hpp.

1416  {
1417  return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
1418  }

◆ compare() [8/17]

template<Operator Op>
bool Catch::Internal::compare ( long  lhs,
unsigned long  rhs 
)

Definition at line 1419 of file catch.hpp.

1419  {
1420  return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
1421  }

◆ compare() [9/17]

template<Operator Op, typename T >
bool Catch::Internal::compare ( T *  lhs,
int  rhs 
)

Definition at line 1438 of file catch.hpp.

1438  {
1439  return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
1440  }

◆ compare() [10/17]

template<Operator Op, typename T >
bool Catch::Internal::compare ( T *  lhs,
long  rhs 
)

Definition at line 1430 of file catch.hpp.

1430  {
1431  return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
1432  }

◆ compare() [11/17]

template<Operator Op, typename T1 , typename T2 >
bool Catch::Internal::compare ( T1 const &  lhs,
T2 const &  rhs 
)

Definition at line 1378 of file catch.hpp.

1378  {
1379  return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
1380  }

◆ compare() [12/17]

template<Operator Op>
bool Catch::Internal::compare ( unsigned char  lhs,
int  rhs 
)

Definition at line 1389 of file catch.hpp.

1389  {
1390  return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
1391  }

◆ compare() [13/17]

template<Operator Op>
bool Catch::Internal::compare ( unsigned char  lhs,
long  rhs 
)

Definition at line 1400 of file catch.hpp.

1400  {
1401  return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
1402  }

◆ compare() [14/17]

template<Operator Op>
bool Catch::Internal::compare ( unsigned int  lhs,
int  rhs 
)

Definition at line 1383 of file catch.hpp.

1383  {
1384  return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
1385  }

◆ compare() [15/17]

template<Operator Op>
bool Catch::Internal::compare ( unsigned int  lhs,
long  rhs 
)

Definition at line 1394 of file catch.hpp.

1394  {
1395  return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
1396  }

◆ compare() [16/17]

template<Operator Op>
bool Catch::Internal::compare ( unsigned long  lhs,
int  rhs 
)

Definition at line 1386 of file catch.hpp.

1386  {
1387  return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
1388  }

◆ compare() [17/17]

template<Operator Op>
bool Catch::Internal::compare ( unsigned long  lhs,
long  rhs 
)

Definition at line 1397 of file catch.hpp.

1397  {
1398  return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
1399  }

◆ opCast()

template<typename T >
T& Catch::Internal::opCast ( T const &  t)
inline