// $Id: AnyScalar.h 59 2007-07-17 14:43:23Z tb $
/*
* STX Expression Parser C++ Framework v0.7
* Copyright (C) 2007 Timo Bingmann
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by the
* Free Software Foundation; either version 2.1 of the License, or (at your
* option) any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
* for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/** \file AnyScalar.h
* Definition of a typed scalar value class AnyScalar used by the parser to
* represent values.
*/
#ifndef _STX_AnyScalar_H_
#define _STX_AnyScalar_H_
#include <string>
#include <stdexcept>
#include <functional>
#include <ostream>
#include <assert.h>
namespace stx {
/** AnyScalar constructs objects holding a typed scalar value. It supports
* boolean values, integer values both signed and unsigned, floating point
* values and strings. The class provides operators which will compare scalars
* between other scalars by converting them into a common domain. Furthermore
* arithmetic operator will compose one or two scalars where the calculation is
* done in the "higher" domain. */
class AnyScalar
{
public:
/// Enumeration establishing identifiers for all supported types. All
/// "small" integer types are included, because the class use originally
/// designed for serializing large amounts of data.
enum attrtype_t
{
/// Flag identifier for an uninitialized object.
ATTRTYPE_INVALID = 0x00,
/// A boolean type holding only true and false.
ATTRTYPE_BOOL = 0x01,
/// Character type, not viewed as a letter or digit, but as 8 bit
/// signed integer.
ATTRTYPE_CHAR = 0x10,
/// Short signed integer type, 2 bytes long.
ATTRTYPE_SHORT = 0x11,
/// Medium signed integer type, 4 bytes long.
ATTRTYPE_INTEGER = 0x12,
/// Long (long) signed integer type, 8 bytes long.
ATTRTYPE_LONG = 0x13,
/// Byte type, not viewed as a letter or digit, but as 8 bit unsigned
/// integer.
ATTRTYPE_BYTE = 0x20,
/// Short unsigned integer type, 2 bytes long.
ATTRTYPE_WORD = 0x21,
/// Medium unsigned integer type, 4 bytes long.
ATTRTYPE_DWORD = 0x22,
/// Long (long) unsigned integer type, 8 bytes long.
ATTRTYPE_QWORD = 0x23,
/// Single precision floating point type, 4 bytes long.
ATTRTYPE_FLOAT = 0x30,
/// Double precision floating point type, 8 bytes long.
ATTRTYPE_DOUBLE = 0x31,
/// String type, variable length. Needs much extra care to handle
/// memory allocation.
ATTRTYPE_STRING = 0x40
};
private:
/// The currently set type in the union.
attrtype_t atype;
/// Union type to holding the current value of an AnyScalar.
union value_t
{
/// Used for ATTRTYPE_BOOL, ATTRTYPE_CHAR, ATTRTYPE_SHORT, ATTRTYPE_INTEGER
int _int;
/// Used for ATTRTYPE_BYTE, ATTRTYPE_WORD, ATTRTYPE_DWORD
unsigned int _uint;
/// Used for ATTRTYPE_LONG
long long _long;
/// Used for ATTRTYPE_QWORD
unsigned long long _ulong;
/// Used for ATTRTYPE_FLOAT
float _float;
/// Used for ATTRTYPE_DOUBLE
double _double;
/// Used for ATTRTYPE_STRING, make sure it get delete'ed correctly.
std::string* _string;
};
/// Union holding the current value of set type.
union value_t val;
public:
/// Create a new empty AnyScalar object of given type.
explicit inline AnyScalar(attrtype_t t = ATTRTYPE_INVALID)
: atype(t)
{
if (atype == ATTRTYPE_STRING) {
val._string = new std::string;
}
else {
val._ulong = 0;
}
}
// *** Constructors for the various types
/// Construct a new AnyScalar object of type ATTRTYPE_BOOL and set the given
/// boolean value.
inline AnyScalar(bool b)
: atype(ATTRTYPE_BOOL)
{
val._int = b;
}
#ifndef SWIG // This constructor confuses SWIG into calling it with
// one-character strings
/// Construct a new AnyScalar object of type ATTRTYPE_CHAR and set the given
/// char value.
inline AnyScalar(char c)
: atype(ATTRTYPE_CHAR)
{
val._int = c;
}
#endif
/// Construct a new AnyScalar object of type ATTRTYPE_SHORT and set the given
/// short value.
inline AnyScalar(short s)
: atype(ATTRTYPE_SHORT)
{
val._int = s;
}
/// Construct a new AnyScalar object of type ATTRTYPE_INTEGER and set the
/// given integer value.
inline AnyScalar(int i)
: atype(ATTRTYPE_INTEGER)
{
val._int = i;
}
/// Construct a new AnyScalar object of type ATTRTYPE_INTEGER and set the
/// given integer value.
inline AnyScalar(long i)
: atype(ATTRTYPE_INTEGER)
{
val._int = i;
}
/// Construct a new AnyScalar object of type ATTRTYPE_LONG and set the
/// given long value.
inline AnyScalar(long long l)
: atype(ATTRTYPE_LONG)
{
val._long = l;
}
/// Construct a new AnyScalar object of type ATTRTYPE_BYTE and set the given
/// unsigned value.
inline AnyScalar(unsigned char c)
: atype(ATTRTYPE_BYTE)
{
val._uint = c;
}
/// Construct a new AnyScalar object of type ATTRTYPE_WORD and set the given
/// unsigned value.
inline AnyScalar(unsigned short s)
: atype(ATTRTYPE_WORD)
{
val._uint = s;
}
/// Construct a new AnyScalar object of type ATTRTYPE_DWORD and set the given
/// unsigned value.
inline AnyScalar(unsigned int i)
: atype(ATTRTYPE_DWORD)
{
val._uint = i;
}
/// Construct a new AnyScalar object of type ATTRTYPE_DWORD and set the given
/// unsigned value.
inline AnyScalar(unsigned long i)
: atype(ATTRTYPE_DWORD)
{
val._uint = i;
}
/// Construct a new AnyScalar object of type ATTRTYPE_QWORD and set the given
/// unsigned value.
inline AnyScalar(unsigned long long l)
: atype(ATTRTYPE_QWORD)
{
val._ulong = l;
}
/// Construct a new AnyScalar object of type ATTRTYPE_FLOAT and set the given
/// floating point value.
inline AnyScalar(float f)
: atype(ATTRTYPE_FLOAT)
{
val._float = f;
}
/// Construct a new AnyScalar object of type ATTRTYPE_DOUBLE and set the
/// given floating point value.
inline AnyScalar(double d)
: atype(ATTRTYPE_DOUBLE)
{
val._double = d;
}
/// Construct a new AnyScalar object of type ATTRTYPE_STRING and set the
/// given string value.
inline AnyScalar(const char *s)
: atype(ATTRTYPE_STRING)
{
if (s == NULL)
val._string = new std::string;
else
val._string = new std::string(s);
}
/// Construct a new AnyScalar object of type ATTRTYPE_STRING and set the
/// given string value.
inline AnyScalar(const std::string &s)
: atype(ATTRTYPE_STRING)
{
val._string = new std::string(s);
}
/// Destroy the object: free associated string memory if necessary.
inline ~AnyScalar()
{
if (atype == ATTRTYPE_STRING) {
delete val._string;
val._string = NULL;
}
}
/// Copy-constructor to deal with enclosed strings. Transfers type and
/// value.
inline AnyScalar(const AnyScalar &a)
: atype(a.atype)
{
switch(atype)
{
case ATTRTYPE_INVALID:
break;
case ATTRTYPE_BOOL:
case ATTRTYPE_CHAR:
case ATTRTYPE_SHORT:
case ATTRTYPE_INTEGER:
val._int = a.val._int;
break;
case ATTRTYPE_BYTE:
case ATTRTYPE_WORD:
case ATTRTYPE_DWORD:
val._uint = a.val._uint;
break;
case ATTRTYPE_LONG:
val._long = a.val._long;
break;
case ATTRTYPE_QWORD:
val._ulong = a.val._ulong;
break;
case ATTRTYPE_FLOAT:
val._float = a.val._float;
break;
case ATTRTYPE_DOUBLE:
val._double = a.val._double;
break;
case ATTRTYPE_STRING:
val._string = new std::string(*a.val._string);
break;
}
}
/// Assignment operator to deal with enclosed strings. Transfers type and
/// value.
inline AnyScalar& operator=(const AnyScalar &a)
{
// check if we are to assign ourself
if (this == &a) return *this;
if (atype == ATTRTYPE_STRING) {
delete val._string;
val._string = NULL;
}
atype = a.atype;
switch(atype)
{
case ATTRTYPE_INVALID:
assert(0);
break;
case ATTRTYPE_BOOL:
case ATTRTYPE_CHAR:
case ATTRTYPE_SHORT:
case ATTRTYPE_INTEGER:
val._int = a.val._int;
break;
case ATTRTYPE_BYTE:
case ATTRTYPE_WORD:
case ATTRTYPE_DWORD:
val._uint = a.val._uint;
break;
case ATTRTYPE_LONG:
val._long = a.val._long;
break;
case ATTRTYPE_QWORD:
val._ulong = a.val._ulong;
break;
case ATTRTYPE_FLOAT:
val._float = a.val._float;
break;
case ATTRTYPE_DOUBLE:
val._double = a.val._double;
break;
case ATTRTYPE_STRING:
val._string = new std::string(*a.val._string);
break;
}
return *this;
}
/// Comparison operator. Directly compares type _and_ value. Does NOT
/// attempt to convert the values into a common domain.
bool operator==(const AnyScalar &a) const;
/// Comparison operator: Directly compares type _and_ value. Does NOT
/// attempt to convert the values into a common domain.
inline bool operator!=(const AnyScalar &a) const
{ return !(*this == a); }
/// Return the type identifier of the object.
inline attrtype_t getType() const
{
return atype;
}
/// Returns true if this object contains a boolean value.
inline bool isBooleanType() const
{
return (atype == ATTRTYPE_BOOL);
}
/// Returns true if this object contains one of the integer types.
inline bool isIntegerType() const
{
return (atype == ATTRTYPE_BOOL ||
atype == ATTRTYPE_CHAR || atype == ATTRTYPE_SHORT ||
atype == ATTRTYPE_INTEGER || atype == ATTRTYPE_LONG ||
atype == ATTRTYPE_BYTE || atype == ATTRTYPE_WORD ||
atype == ATTRTYPE_DWORD || atype == ATTRTYPE_QWORD);
}
/// Returns true if this object contains one of the floating point types.
inline bool isFloatingType() const
{
return (atype == ATTRTYPE_FLOAT || atype == ATTRTYPE_DOUBLE);
}
/// Attempts to convert the current type/value into the given type. Returns
/// false if the value could not be represented in the new type, the new
/// type is set nonetheless. See the getXXX below on how the new value is
/// computed from the old type.
bool convertType(attrtype_t t);
/// Changes the current type and resets the contents without attempting to
/// convert the enclosed value.
void resetType(attrtype_t t);
// *** attrtype_t to string and string to attrtype_t functions
/// Returns true if the attrtype_t is a valid type identifier.
static bool isValidAttrtype(attrtype_t at);
/// Returns the attrtype identifier of a string, throws ConversionException
/// if s does not specify a valid type name.
static attrtype_t stringToType(const std::string &s)
{
return stringToType(s.c_str());
}
/// Returns the attrtype identifier a string, throws ConversionException if
/// it does not specify a valid type name.
static attrtype_t stringToType(const char *s);
/// Returns a const char* for each attrtype_t.
static std::string getTypeString(attrtype_t at);
/// Returns a string for this AnyScalar's type.
inline std::string getTypeString() const
{
return getTypeString(atype);
}
// *** Type and Value Length Functions
/// Return the storage length of the type in bytes. Beware that
/// getTypeLength(bool) == 0.
inline int getTypeLength() const
{
return getTypeLength(atype);
}
/// Return the storage length of the type in bytes. Beware that
/// getTypeLength(bool) == 0.
static int getTypeLength(attrtype_t t);
/// Boolean check if this type is of fixed length.
static bool isFixedLength(attrtype_t t)
{
return getTypeLength(t) >= 0;
}
/// Boolean check if this type is of fixed length.
inline bool isFixedLength() const
{
return isFixedLength(atype);
}
/// Return the storage length of this value (mark the different to
/// getTypeLength())
unsigned int getValueLength() const;
// *** Setters
// Sets the value, converting the input to the currently set type if
// necessary. Returns false if the input could not be converted into the
// right type.
/** Change the value of the current object to i. Converting the integer
* to this object's type if necessary.
*
* - boolean: the integer i is cut to 0 or 1.
* - char: cut to -128..127 returns false if out of range.
* - short: cut to -32768..32767 return false if out of range.
* - byte: cut to 0..255 returns false if out of range.
* - word: cut to 0..65536 returns false if out of range.
* - int: no conversion.
* - dword: cut to 0..4294967295 return false if it was negative.
* - long: no cutting necessary.
* - qword: cut to positive number.
* - float: integer stored as floating point
* - double: integer stored as floating point
* - string: integer is stringified.
*/
bool setInteger(int i);
/** Change the value of the current object to l. Converting the long
* long integer to this object's type if necessary. If the long long does
* not fully fit into the current type, then this function returns false.
*
* - boolean: the long i is cut to 0 or 1.
* - char: cut to -128..127 returns false if out of range.
* - short: cut to -32768..32767 return false if out of range.
* - int: cut to -2147483646..2147483647 returns false if out of range.
* - byte: cut to 0..255 returns false if out of range.
* - word: cut to 0..65536 returns false if out of range.
* - dword: cut to 0..4294967295 return false if out of range.
* - long: no conversion
* - qword: cut to positive number.
* - float: long stored as floating point
* - double: long stored as floating point
* - string: long is stringified.
*/
bool setLong(long long l);
/** Change the value of the current object to d. Converting the floating
* point to this object's type if necessary.
*
* - boolean: [0:0.5] is false, (0.5:1] is true. else true and return false.
* - char: truncated to integer ranged -128..127 returns false if out of range.
* - short: truncated to integer ranged -32768..32767 return false if out of range.
* - int: truncated to integer ranged -2147483646..2147483647 returns false if out of range.
* - byte: truncated to integer ranged 0..255 returns false if out of range.
* - word: truncated to integer ranged 0..65536 returns false if out of range.
* - dword: truncated to integer ranged 0..4294967295 return false if out of range.
* - long: truncated to integer ranged -9223372036854775806..9223372036854775807
* - qword: truncated to integer ranged 0..18446744073709551615
* - float: truncated to single-precision
* - double: no conversion
* - string: double is stringified.
*/
bool setDouble(double d);
/** Change the value of the current object to s. Converting the string
* to this object's type if necessary. If this string cannot be converted
* to say an integer, then this function returns false.
*
* - boolean: "0", "f", "false", "n" and "no" are false,
* "1", "t", "true", "y" and "yes" are true. else returns false.
* - char: string read using strtol and truncated to -128..127
returns false if out of range or unparseable.
* - short: string read using strtol and truncated to -32768..32767
returns false if out of range or unparseable.
* - int: string read using strtol returns false if out of range or unparseable.
* - long: string read using strtoll returns false if out of range or unparseable.
* - byte: string read using strtoul and truncated to 0..255
returns false if out of range or unparseable.
* - word: string read using strtoul and truncated to 0..65535
returns false if out of range or unparseable.
* - dword: string read using strtoul returns false if out of range or unparseable.
* - qword: string read using strtoull returns false if out of range or unparseable.
* - float: string read using strtod and converted to single-precision
returns false if unparseable.
* - double: string read using strtod returns false if unparseable.
* - string: no conversion
*/
bool setString(const std::string &s);
/// Change the value of the current object to s. This string s must be
/// quoted: "str". This function resolves escape sequences like \n.
bool setStringQuoted(const std::string &s);
/** Change the type _and_ value of the current object to s. The current
* type is set if the given string can be converted to an integer or a
* floating point number. This was required because e.g. the usual input
* from files or perl are all untyped strings. The following input
* conversions are tested and yield the given types:
*
* - boolean: no boolean strings are matched!
* - int: input was readable by strtoll and is small enough.
* - long: input was readable by strtoll
* - double: input was readble by strtod
* - string: all above failed.
*
* @return reference to this for chaining.
*/
AnyScalar& setAutoString(const std::string &input);
// *** Getters
// Return the enclosed value in different types, converting if
// necessary. If the enclosed value cannot be converted these functions
// throw a ConversionError exception.
/** Return the value converted to a boolean. If the enclosed value could
* not be converted this function throws a ConversionException.
*
* - boolean: no conversion
* - char/short/int/long: test integer != 0
* - byte/word/dword/qword: test integer != 0
* - float/double: test float != 0.0
* - string: "0", "f", "false", "n", "no" are false,
* "1", "t", "true", "y", "yes" are true
* other strings throw ConversionException.
*/
bool getBoolean() const;
/** Return the value converted to an integer. If the enclosed value could
* not be converted this function throws a ConversionException.
*
* - boolean: returns 0 or 1.
* - char/short/int: return the integer
* - byte/word/dword: return the integer (possibly as a negative number)
* - long: cut to -2147483646..2147483647.
* - qword: cut to 0..4294967295
* - float/double: machine-conversion floating point to integer
* - string: Attempt to strtol the string, throws ConversionException if this fails.
*/
int getInteger() const;
/** Return the value converted to an unsigned integer. If the enclosed
* value could not be converted this function throws a ConversionException.
*
* - boolean: returns 0 or 1.
* - char/short/int: return the integer (possibly representing a negative number as positive)
* - byte/word/dword: return the unsigned integer
* - long: cut to 0..4294967295 (also misrepresenting because of machine-conversion)
* - qword: cut to 0..4294967295
* - float/double: machine-conversion floating point to unsigned integer.
* - string: Attempt to strtoul the string, throws ConversionException if this fails.
*/
unsigned int getUnsignedInteger() const;
/// Alias for getInteger()
inline int getInt() const
{
return getInteger();
}
/// Alias for getUnsignedInteger()
inline unsigned int getUInt() const
{
return getUnsignedInteger();
}
/** Return the value converted to a long integer. If the enclosed value
* could not be converted this function throws a ConversionException.
*
* - boolean: returns 0 or 1.
* - char/short/int: return the integer (possibly representing a negative number as positive)
* - byte/word/dword: return the unsigned integer
* - long: no conversion
* - qword: return the integer (possibly converting a large long to a negative)
* - float/double: machine-conversion floating point to long long.
* - string: Attempt to strtoll the string, throws ConversionException if this fails.
*/
long long getLong() const;
/** Return the value converted to an unsigned long integer. If the enclosed
* value could not be converted this function throws a ConversionException.
*
* - boolean: returns 0 or 1.
* - char/short/int: return the integer (possibly representing a negative number as positive)
* - byte/word/dword: return the unsigned integer
* - long: return the long (possibly interpreting a negative long as a large positive)
* - qword: no conversion
* - float/double: machine-conversion floating point to unsigned long long.
* - string: Attempt to strtoull the string, throws ConversionException if this fails.
*/
unsigned long long getUnsignedLong() const;
/// Alias for getUnsignedLong()
unsigned long long getULong() const
{
return getUnsignedLong();
}
/** Return the value converted to a double. If the enclosed value could not
* be converted this function throws a ConversionException.
*
* - boolean: returns 0 or 1.0.
* - char/short/int/long: return the integer as a float
* - byte/word/dword/qword: return the unsigned integer as a float
* - float: cast to double.
* - double: no conversion
* - string: Attempt to strtod the string, throws ConversionException if this fails.
*/
double getDouble() const;
/** Return the value converted to a string. This function never throws
* ConversionException.
*
* - boolean: returns "false" or "true"
* - char/short/int/long: return the integer as a string using boost::lexical_cast
* - byte/word/dword/qword: return the unsigned integer as a string using boost::lexical_cast
* - float/double: return float as a string using boost::lexical_cast
* - string: return the string.
*/
std::string getString() const;
/** Return the value converted to a quoted string. This function never
* throws ConversionException. It calls getString() and adds " and escape
* sequences. */
std::string getStringQuoted() const;
// *** Unary Operators
/** Unary prefix - operator. Attempts to convert the AnyScalar to a numeric
* value.
*
* - bool: invert the boolean value
* - char/short/int/long: switch sign
* - byte/word/dword/qword: negated the number even tho it doesn't make sense.
* - float/double: switch sign
* - string: attempt to convert the string to a double and negate it!
* May throw a ConversionException
*/
AnyScalar operator-() const;
// *** Binary Operators
// These will convert the two operands to the largest common type of the
// same field.
#ifndef SWIG // obviously too strange for SWIG
private:
/** Binary arithmetic template operator. Converts the two AnyScalars into the
* largest type of their common field. If a string cannot be converted to a
* numeric of the same field as the other operand a ConversionException is
* thrown.
* Conversion chart: * signifies the operator
- bool * (any): ConversionException. Don't consider boolean as the field F_2.
- char|short|int * char|short|int: return AnyScalar is an integer.
- byte|word|dword * char|short|int: returned AnyScalar is a signed integer.
- byte|word|dword * byte|word|dword: returned AnyScalar is an unsigned integer.
- long * char|short|int|long|byte|word|dword|qword: returned AnyScalar is a signed long (long).
- qword * char|short|int|long: : returned AnyScalar is a signed long (long).
- qword * byte|word|dword|qword: : returned AnyScalar is an unsigned long (long).
- float|double * char|short|int|long|byte|word|dword|qword: calculate as floating point number
- string * char|short|int: convert string to integer, calculate as signed integer.
- string * byte|word|dword: convert string to unsigned integer, calculate as unsigned integer.
- string * long: convert string to long integer, calculate as long.
- string * qword: convert string to unsigned long integer, calculate as unsigned long.
- string * float|double: convert string to floating point, calculate as floating point.
- string * string: only valid for "+" operator as string concatenation.
*/
template <template <typename Type> class Operator, char OpName>
AnyScalar binary_arith_op(const AnyScalar &b) const;
#endif
public:
/// Instantiation of binary_arith_op for "+" plus.
inline AnyScalar operator+(const AnyScalar &b) const
{
return binary_arith_op<std::plus, '+'>(b);
}
/// Instantiation of binary_arith_op for "-" minus.
inline AnyScalar operator-(const AnyScalar &b) const
{
return binary_arith_op<std::minus, '-'>(b);
}
/// Instantiation of binary_arith_op for "*" multiplication.
inline AnyScalar operator*(const AnyScalar &b) const
{
return binary_arith_op<std::multiplies, '*'>(b);
}
/// Instantiation of binary_arith_op for "/" division.
inline AnyScalar operator/(const AnyScalar &b) const
{
return binary_arith_op<std::divides, '/'>(b);
}
/// Alias for operator+ in script languages
inline AnyScalar add(const AnyScalar &b) const
{
return (*this + b);
}
/// Alias for operator- in script languages
inline AnyScalar subtract(const AnyScalar &b) const
{
return (*this - b);
}
/// Alias for operator* in script languages
inline AnyScalar multiply(const AnyScalar &b) const
{
return (*this * b);
}
/// Alias for operator/ in script languages
inline AnyScalar divide(const AnyScalar &b) const
{
return (*this / b);
}
#ifndef SWIG // obviously too strange for SWIG
private:
/** Binary comparison template operator. Converts the two AnyScalars into the
* largest type of their common field. If a string cannot be converted to a
* numeric of the same field as the other operand a ConversionException is
* thrown. Operator is the STL operator class. OpNum is an identifier for
* the operator name string within the template.
* Conversion chart: * signifies the operator
- bool * bool: usual comparison
- bool * (any): ConversionException. Don't consider boolean as the field F_2.
- char|short|int * char|short|int: compare as signed integers.
- byte|word|dword * char|short|int: compare as signed integers.
- byte|word|dword * byte|word|dword: compare as unsigned integers.
- long * char|short|int|long|byte|word|dword|qword: compare as signed long integer
- qword * char|short|int|long: : compare as signed long integer
- qword * byte|word|dword|qword: : compare an unsigned long (long).
- float|double * char|short|int|long|byte|word|dword|qword: compare as floating point numbers
- string * char|short|int: convert string to integer, compare as signed integer.
- string * byte|word|dword: convert string to unsigned integer, compare as unsigned integer.
- string * long: convert string to long integer, compare as long.
- string * qword: convert string to unsigned long integer, compare as unsigned long.
- string * float|double: convert string to floating point, compare as floating point.
- string * string: usual string comparison operators.
*/
template <template <typename Type> class Operator, int OpNum>
bool binary_comp_op(const AnyScalar &b) const;
#endif
// *** Don't use the operators themselves, because operator== is defined
// *** differently above.
public:
/// Instantiation of binary_comp_op for "==" equality.
inline bool equal_to(const AnyScalar &b) const
{
return binary_comp_op<std::equal_to, 0>(b);
}
/// Instantiation of binary_comp_op for "!=" inequality.
inline bool not_equal_to(const AnyScalar &b) const
{
return binary_comp_op<std::not_equal_to, 1>(b);
}
/// Instantiation of binary_comp_op for "<" less-than.
inline bool less(const AnyScalar &b) const
{
return binary_comp_op<std::less, 2>(b);
}
/// Instantiation of binary_comp_op for ">" greater-than.
inline bool greater(const AnyScalar &b) const
{
return binary_comp_op<std::greater, 3>(b);
}
/// Instantiation of binary_comp_op for "<=" less-or-equal-than.
inline bool less_equal(const AnyScalar &b) const
{
return binary_comp_op<std::less_equal, 4>(b);
}
/// Instantiation of binary_comp_op for ">=" greater-or-equal-than.
inline bool greater_equal(const AnyScalar &b) const
{
return binary_comp_op<std::greater_equal, 5>(b);
}
};
/// Make AnyScalar outputtable to ostream
static inline std::ostream& operator<< (std::ostream &stream, const AnyScalar &as)
{
return stream << as.getString();
}
} // namespace stx
#endif // VGS_AnyScalar_H
