namespace Poco::Dynamic

Overview

namespace Dynamic {

// namespaces

namespace Poco::Dynamic::Impl;

// typedefs

typedef std::vector<Var> Vector;
typedef std::deque<Var> Deque;
typedef std::list<Var> List;
typedef Vector Array;

// classes

template <typename K>
class Pair;

template <typename K>
class Struct;

class Var;
class VarHolder;

template <typename T>
class VarHolderImpl<std::vector<T>>;

template <>
class VarHolderImpl<std::string>;

template <typename T>
class VarHolderImpl<std::list<T>>;

template <typename T>
class VarHolderImpl<std::deque<T>>;

template <>
class VarHolderImpl<Pair<std::string>>;

template <>
class VarHolderImpl<Struct<int>>;

template <>
class VarHolderImpl<Struct<std::string>>;

template <>
class VarHolderImpl<Timestamp>;

template <>
class VarHolderImpl<UInt16>;

template <>
class VarHolderImpl<unsigned long>;

template <>
class VarHolderImpl<Pair<int>>;

template <>
class VarHolderImpl<UInt8>;

template <>
class VarHolderImpl<UInt32>;

template <>
class VarHolderImpl<UInt64>;

template <>
class VarHolderImpl<long>;

template <>
class VarHolderImpl<JSON::Object::Ptr>;

template <>
class VarHolderImpl<UTF16String>;

template <>
class VarHolderImpl<DateTime>;

template <>
class VarHolderImpl<double>;

template <>
class VarHolderImpl<float>;

template <>
class VarHolderImpl<char>;

template <typename T>
class VarHolderImpl;

template <>
class VarHolderImpl<bool>;

template <>
class VarHolderImpl<LocalDateTime>;

template <>
class VarHolderImpl<Int16>;

template <>
class VarHolderImpl<Int64>;

template <>
class VarHolderImpl<JSON::Object>;

template <>
class VarHolderImpl<Int32>;

template <>
class VarHolderImpl<JSON::Array::Ptr>;

template <>
class VarHolderImpl<Int8>;

template <>
class VarHolderImpl<JSON::Array>;

class VarIterator;

// global functions

const Var
operator+(
    const char* other,
    const Var& da
    );

char
operator+(
    const char& other,
    const Var& da
    );

char
operator-(
    const char& other,
    const Var& da
    );

char
operator*(
    const char& other,
    const Var& da
    );

char
operator/(
    const char& other,
    const Var& da
    );

char
operator+=(
    char& other,
    const Var& da
    );

char
operator-=(
    char& other,
    const Var& da
    );

char
operator*=(
    char& other,
    const Var& da
    );

char
operator/=(
    char& other,
    const Var& da
    );

bool
operator==(
    const char& other,
    const Var& da
    );

bool
operator!=(
    const char& other,
    const Var& da
    );

bool
operator<(
    const char& other,
    const Var& da
    );

bool
operator<=(
    const char& other,
    const Var& da
    );

bool
operator>(
    const char& other,
    const Var& da
    );

bool
operator>=(
    const char& other,
    const Var& da
    );

Poco::Int8
operator+(
    const Poco::Int8& other,
    const Var& da
    );

Poco::Int8
operator-(
    const Poco::Int8& other,
    const Var& da
    );

Poco::Int8
operator*(
    const Poco::Int8& other,
    const Var& da
    );

Poco::Int8
operator/(
    const Poco::Int8& other,
    const Var& da
    );

Poco::Int8
operator+=(
    Poco::Int8& other,
    const Var& da
    );

Poco::Int8
operator-=(
    Poco::Int8& other,
    const Var& da
    );

Poco::Int8
operator*=(
    Poco::Int8& other,
    const Var& da
    );

Poco::Int8
operator/=(
    Poco::Int8& other,
    const Var& da
    );

bool
operator==(
    const Poco::Int8& other,
    const Var& da
    );

bool
operator!=(
    const Poco::Int8& other,
    const Var& da
    );

bool
operator<(
    const Poco::Int8& other,
    const Var& da
    );

bool
operator<=(
    const Poco::Int8& other,
    const Var& da
    );

bool
operator>(
    const Poco::Int8& other,
    const Var& da
    );

bool
operator>=(
    const Poco::Int8& other,
    const Var& da
    );

Poco::UInt8
operator+(
    const Poco::UInt8& other,
    const Var& da
    );

Poco::UInt8
operator-(
    const Poco::UInt8& other,
    const Var& da
    );

Poco::UInt8
operator*(
    const Poco::UInt8& other,
    const Var& da
    );

Poco::UInt8
operator/(
    const Poco::UInt8& other,
    const Var& da
    );

Poco::UInt8
operator+=(
    Poco::UInt8& other,
    const Var& da
    );

Poco::UInt8
operator-=(
    Poco::UInt8& other,
    const Var& da
    );

Poco::UInt8
operator*=(
    Poco::UInt8& other,
    const Var& da
    );

Poco::UInt8
operator/=(
    Poco::UInt8& other,
    const Var& da
    );

bool
operator==(
    const Poco::UInt8& other,
    const Var& da
    );

bool
operator!=(
    const Poco::UInt8& other,
    const Var& da
    );

bool
operator<(
    const Poco::UInt8& other,
    const Var& da
    );

bool
operator<=(
    const Poco::UInt8& other,
    const Var& da
    );

bool
operator>(
    const Poco::UInt8& other,
    const Var& da
    );

bool
operator>=(
    const Poco::UInt8& other,
    const Var& da
    );

Poco::Int16
operator+(
    const Poco::Int16& other,
    const Var& da
    );

Poco::Int16
operator-(
    const Poco::Int16& other,
    const Var& da
    );

Poco::Int16
operator*(
    const Poco::Int16& other,
    const Var& da
    );

Poco::Int16
operator/(
    const Poco::Int16& other,
    const Var& da
    );

Poco::Int16
operator+=(
    Poco::Int16& other,
    const Var& da
    );

Poco::Int16
operator-=(
    Poco::Int16& other,
    const Var& da
    );

Poco::Int16
operator*=(
    Poco::Int16& other,
    const Var& da
    );

Poco::Int16
operator/=(
    Poco::Int16& other,
    const Var& da
    );

bool
operator==(
    const Poco::Int16& other,
    const Var& da
    );

bool
operator!=(
    const Poco::Int16& other,
    const Var& da
    );

bool
operator<(
    const Poco::Int16& other,
    const Var& da
    );

bool
operator<=(
    const Poco::Int16& other,
    const Var& da
    );

bool
operator>(
    const Poco::Int16& other,
    const Var& da
    );

bool
operator>=(
    const Poco::Int16& other,
    const Var& da
    );

Poco::UInt16
operator+(
    const Poco::UInt16& other,
    const Var& da
    );

Poco::UInt16
operator-(
    const Poco::UInt16& other,
    const Var& da
    );

Poco::UInt16
operator*(
    const Poco::UInt16& other,
    const Var& da
    );

Poco::UInt16
operator/(
    const Poco::UInt16& other,
    const Var& da
    );

Poco::UInt16
operator+=(
    Poco::UInt16& other,
    const Var& da
    );

Poco::UInt16
operator-=(
    Poco::UInt16& other,
    const Var& da
    );

Poco::UInt16
operator*=(
    Poco::UInt16& other,
    const Var& da
    );

Poco::UInt16
operator/=(
    Poco::UInt16& other,
    const Var& da
    );

bool
operator==(
    const Poco::UInt16& other,
    const Var& da
    );

bool
operator!=(
    const Poco::UInt16& other,
    const Var& da
    );

bool
operator<(
    const Poco::UInt16& other,
    const Var& da
    );

bool
operator<=(
    const Poco::UInt16& other,
    const Var& da
    );

bool
operator>(
    const Poco::UInt16& other,
    const Var& da
    );

bool
operator>=(
    const Poco::UInt16& other,
    const Var& da
    );

Poco::Int32
operator+(
    const Poco::Int32& other,
    const Var& da
    );

Poco::Int32
operator-(
    const Poco::Int32& other,
    const Var& da
    );

Poco::Int32
operator*(
    const Poco::Int32& other,
    const Var& da
    );

Poco::Int32
operator/(
    const Poco::Int32& other,
    const Var& da
    );

Poco::Int32
operator+=(
    Poco::Int32& other,
    const Var& da
    );

Poco::Int32
operator-=(
    Poco::Int32& other,
    const Var& da
    );

Poco::Int32
operator*=(
    Poco::Int32& other,
    const Var& da
    );

Poco::Int32
operator/=(
    Poco::Int32& other,
    const Var& da
    );

bool
operator==(
    const Poco::Int32& other,
    const Var& da
    );

bool
operator!=(
    const Poco::Int32& other,
    const Var& da
    );

bool
operator<(
    const Poco::Int32& other,
    const Var& da
    );

bool
operator<=(
    const Poco::Int32& other,
    const Var& da
    );

bool
operator>(
    const Poco::Int32& other,
    const Var& da
    );

bool
operator>=(
    const Poco::Int32& other,
    const Var& da
    );

Poco::UInt32
operator+(
    const Poco::UInt32& other,
    const Var& da
    );

Poco::UInt32
operator-(
    const Poco::UInt32& other,
    const Var& da
    );

Poco::UInt32
operator*(
    const Poco::UInt32& other,
    const Var& da
    );

Poco::UInt32
operator/(
    const Poco::UInt32& other,
    const Var& da
    );

Poco::UInt32
operator+=(
    Poco::UInt32& other,
    const Var& da
    );

Poco::UInt32
operator-=(
    Poco::UInt32& other,
    const Var& da
    );

Poco::UInt32
operator*=(
    Poco::UInt32& other,
    const Var& da
    );

Poco::UInt32
operator/=(
    Poco::UInt32& other,
    const Var& da
    );

bool
operator==(
    const Poco::UInt32& other,
    const Var& da
    );

bool
operator!=(
    const Poco::UInt32& other,
    const Var& da
    );

bool
operator<(
    const Poco::UInt32& other,
    const Var& da
    );

bool
operator<=(
    const Poco::UInt32& other,
    const Var& da
    );

bool
operator>(
    const Poco::UInt32& other,
    const Var& da
    );

bool
operator>=(
    const Poco::UInt32& other,
    const Var& da
    );

Poco::Int64
operator+(
    const Poco::Int64& other,
    const Var& da
    );

Poco::Int64
operator-(
    const Poco::Int64& other,
    const Var& da
    );

Poco::Int64
operator*(
    const Poco::Int64& other,
    const Var& da
    );

Poco::Int64
operator/(
    const Poco::Int64& other,
    const Var& da
    );

Poco::Int64
operator+=(
    Poco::Int64& other,
    const Var& da
    );

Poco::Int64
operator-=(
    Poco::Int64& other,
    const Var& da
    );

Poco::Int64
operator*=(
    Poco::Int64& other,
    const Var& da
    );

Poco::Int64
operator/=(
    Poco::Int64& other,
    const Var& da
    );

bool
operator==(
    const Poco::Int64& other,
    const Var& da
    );

bool
operator!=(
    const Poco::Int64& other,
    const Var& da
    );

bool
operator<(
    const Poco::Int64& other,
    const Var& da
    );

bool
operator<=(
    const Poco::Int64& other,
    const Var& da
    );

bool
operator>(
    const Poco::Int64& other,
    const Var& da
    );

bool
operator>=(
    const Poco::Int64& other,
    const Var& da
    );

Poco::UInt64
operator+(
    const Poco::UInt64& other,
    const Var& da
    );

Poco::UInt64
operator-(
    const Poco::UInt64& other,
    const Var& da
    );

Poco::UInt64
operator*(
    const Poco::UInt64& other,
    const Var& da
    );

Poco::UInt64
operator/(
    const Poco::UInt64& other,
    const Var& da
    );

Poco::UInt64
operator+=(
    Poco::UInt64& other,
    const Var& da
    );

Poco::UInt64
operator-=(
    Poco::UInt64& other,
    const Var& da
    );

Poco::UInt64
operator*=(
    Poco::UInt64& other,
    const Var& da
    );

Poco::UInt64
operator/=(
    Poco::UInt64& other,
    const Var& da
    );

bool
operator==(
    const Poco::UInt64& other,
    const Var& da
    );

bool
operator!=(
    const Poco::UInt64& other,
    const Var& da
    );

bool
operator<(
    const Poco::UInt64& other,
    const Var& da
    );

bool
operator<=(
    const Poco::UInt64& other,
    const Var& da
    );

bool
operator>(
    const Poco::UInt64& other,
    const Var& da
    );

bool
operator>=(
    const Poco::UInt64& other,
    const Var& da
    );

float
operator+(
    const float& other,
    const Var& da
    );

float
operator-(
    const float& other,
    const Var& da
    );

float
operator*(
    const float& other,
    const Var& da
    );

float
operator/(
    const float& other,
    const Var& da
    );

float
operator+=(
    float& other,
    const Var& da
    );

float
operator-=(
    float& other,
    const Var& da
    );

float
operator*=(
    float& other,
    const Var& da
    );

float
operator/=(
    float& other,
    const Var& da
    );

bool
operator==(
    const float& other,
    const Var& da
    );

bool
operator!=(
    const float& other,
    const Var& da
    );

bool
operator<(
    const float& other,
    const Var& da
    );

bool
operator<=(
    const float& other,
    const Var& da
    );

bool
operator>(
    const float& other,
    const Var& da
    );

bool
operator>=(
    const float& other,
    const Var& da
    );

double
operator+(
    const double& other,
    const Var& da
    );

double
operator-(
    const double& other,
    const Var& da
    );

double
operator*(
    const double& other,
    const Var& da
    );

double
operator/(
    const double& other,
    const Var& da
    );

double
operator+=(
    double& other,
    const Var& da
    );

double
operator-=(
    double& other,
    const Var& da
    );

double
operator*=(
    double& other,
    const Var& da
    );

double
operator/=(
    double& other,
    const Var& da
    );

bool
operator==(
    const double& other,
    const Var& da
    );

bool
operator!=(
    const double& other,
    const Var& da
    );

bool
operator<(
    const double& other,
    const Var& da
    );

bool
operator<=(
    const double& other,
    const Var& da
    );

bool
operator>(
    const double& other,
    const Var& da
    );

bool
operator>=(
    const double& other,
    const Var& da
    );

bool
operator==(
    const bool& other,
    const Var& da
    );

bool
operator!=(
    const bool& other,
    const Var& da
    );

bool
operator==(
    const std::string& other,
    const Var& da
    );

bool
operator!=(
    const std::string& other,
    const Var& da
    );

bool
operator==(
    const UTF16String& other,
    const Var& da
    );

bool
operator!=(
    const UTF16String& other,
    const Var& da
    );

bool
operator==(
    const char* other,
    const Var& da
    );

bool
operator!=(
    const char* other,
    const Var& da
    );

long
operator+(
    const long& other,
    const Var& da
    );

long
operator-(
    const long& other,
    const Var& da
    );

long
operator*(
    const long& other,
    const Var& da
    );

long
operator/(
    const long& other,
    const Var& da
    );

long
operator+=(
    long& other,
    const Var& da
    );

long
operator-=(
    long& other,
    const Var& da
    );

long
operator*=(
    long& other,
    const Var& da
    );

long
operator/=(
    long& other,
    const Var& da
    );

bool
operator==(
    const long& other,
    const Var& da
    );

bool
operator!=(
    const long& other,
    const Var& da
    );

bool
operator<(
    const long& other,
    const Var& da
    );

bool
operator<=(
    const long& other,
    const Var& da
    );

bool
operator>(
    const long& other,
    const Var& da
    );

bool
operator>=(
    const long& other,
    const Var& da
    );

} // namespace Dynamic

Detailed Documentation

Global Functions

const Var
operator+(
    const char* other,
    const Var& da
    )

Addition operator for adding Var to const char*.

char
operator+(
    const char& other,
    const Var& da
    )

Addition operator for adding Var to char.

char
operator-(
    const char& other,
    const Var& da
    )

Subtraction operator for subtracting Var from char.

char
operator*(
    const char& other,
    const Var& da
    )

Multiplication operator for multiplying Var with char.

char
operator/(
    const char& other,
    const Var& da
    )

Division operator for dividing Var with char.

char
operator+=(
    char& other,
    const Var& da
    )

Addition asignment operator for adding Var to char.

char
operator-=(
    char& other,
    const Var& da
    )

Subtraction asignment operator for subtracting Var from char.

char
operator*=(
    char& other,
    const Var& da
    )

Multiplication asignment operator for multiplying Var with char.

char
operator/=(
    char& other,
    const Var& da
    )

Division asignment operator for dividing Var with char.

bool
operator==(
    const char& other,
    const Var& da
    )

Equality operator for comparing Var with char.

bool
operator!=(
    const char& other,
    const Var& da
    )

Inequality operator for comparing Var with char.

bool
operator<(
    const char& other,
    const Var& da
    )

Less than operator for comparing Var with char.

bool
operator<=(
    const char& other,
    const Var& da
    )

Less than or equal operator for comparing Var with char.

bool
operator>(
    const char& other,
    const Var& da
    )

Greater than operator for comparing Var with char.

bool
operator>=(
    const char& other,
    const Var& da
    )

Greater than or equal operator for comparing Var with char.

Poco::Int8
operator+(
    const Poco::Int8& other,
    const Var& da
    )

Addition operator for adding Var to Poco::Int8.

Poco::Int8
operator-(
    const Poco::Int8& other,
    const Var& da
    )

Subtraction operator for subtracting Var from Poco::Int8.

Poco::Int8
operator*(
    const Poco::Int8& other,
    const Var& da
    )

Multiplication operator for multiplying Var with Poco::Int8.

Poco::Int8
operator/(
    const Poco::Int8& other,
    const Var& da
    )

Division operator for dividing Var with Poco::Int8.

Poco::Int8
operator+=(
    Poco::Int8& other,
    const Var& da
    )

Addition asignment operator for adding Var to Poco::Int8.

Poco::Int8
operator-=(
    Poco::Int8& other,
    const Var& da
    )

Subtraction asignment operator for subtracting Var from Poco::Int8.

Poco::Int8
operator*=(
    Poco::Int8& other,
    const Var& da
    )

Multiplication asignment operator for multiplying Var with Poco::Int8.

Poco::Int8
operator/=(
    Poco::Int8& other,
    const Var& da
    )

Division asignment operator for dividing Var with Poco::Int8.

bool
operator==(
    const Poco::Int8& other,
    const Var& da
    )

Equality operator for comparing Var with Poco::Int8.

bool
operator!=(
    const Poco::Int8& other,
    const Var& da
    )

Inequality operator for comparing Var with Poco::Int8.

bool
operator<(
    const Poco::Int8& other,
    const Var& da
    )

Less than operator for comparing Var with Poco::Int8.

bool
operator<=(
    const Poco::Int8& other,
    const Var& da
    )

Less than or equal operator for comparing Var with Poco::Int8.

bool
operator>(
    const Poco::Int8& other,
    const Var& da
    )

Greater than operator for comparing Var with Poco::Int8.

bool
operator>=(
    const Poco::Int8& other,
    const Var& da
    )

Greater than or equal operator for comparing Var with Poco::Int8.

Poco::UInt8
operator+(
    const Poco::UInt8& other,
    const Var& da
    )

Addition operator for adding Var to Poco::UInt8.

Poco::UInt8
operator-(
    const Poco::UInt8& other,
    const Var& da
    )

Subtraction operator for subtracting Var from Poco::UInt8.

Poco::UInt8
operator*(
    const Poco::UInt8& other,
    const Var& da
    )

Multiplication operator for multiplying Var with Poco::UInt8.

Poco::UInt8
operator/(
    const Poco::UInt8& other,
    const Var& da
    )

Division operator for dividing Var with Poco::UInt8.

Poco::UInt8
operator+=(
    Poco::UInt8& other,
    const Var& da
    )

Addition asignment operator for adding Var to Poco::UInt8.

Poco::UInt8
operator-=(
    Poco::UInt8& other,
    const Var& da
    )

Subtraction asignment operator for subtracting Var from Poco::UInt8.

Poco::UInt8
operator*=(
    Poco::UInt8& other,
    const Var& da
    )

Multiplication asignment operator for multiplying Var with Poco::UInt8.

Poco::UInt8
operator/=(
    Poco::UInt8& other,
    const Var& da
    )

Division asignment operator for dividing Var with Poco::UInt8.

bool
operator==(
    const Poco::UInt8& other,
    const Var& da
    )

Equality operator for comparing Var with Poco::UInt8.

bool
operator!=(
    const Poco::UInt8& other,
    const Var& da
    )

Inequality operator for comparing Var with Poco::UInt8.

bool
operator<(
    const Poco::UInt8& other,
    const Var& da
    )

Less than operator for comparing Var with Poco::UInt8.

bool
operator<=(
    const Poco::UInt8& other,
    const Var& da
    )

Less than or equal operator for comparing Var with Poco::UInt8.

bool
operator>(
    const Poco::UInt8& other,
    const Var& da
    )

Greater than operator for comparing Var with Poco::UInt8.

bool
operator>=(
    const Poco::UInt8& other,
    const Var& da
    )

Greater than or equal operator for comparing Var with Poco::UInt8.

Poco::Int16
operator+(
    const Poco::Int16& other,
    const Var& da
    )

Addition operator for adding Var to Poco::Int16.

Poco::Int16
operator-(
    const Poco::Int16& other,
    const Var& da
    )

Subtraction operator for subtracting Var from Poco::Int16.

Poco::Int16
operator*(
    const Poco::Int16& other,
    const Var& da
    )

Multiplication operator for multiplying Var with Poco::Int16.

Poco::Int16
operator/(
    const Poco::Int16& other,
    const Var& da
    )

Division operator for dividing Var with Poco::Int16.

Poco::Int16
operator+=(
    Poco::Int16& other,
    const Var& da
    )

Addition asignment operator for adding Var to Poco::Int16.

Poco::Int16
operator-=(
    Poco::Int16& other,
    const Var& da
    )

Subtraction asignment operator for subtracting Var from Poco::Int16.

Poco::Int16
operator*=(
    Poco::Int16& other,
    const Var& da
    )

Multiplication asignment operator for multiplying Var with Poco::Int16.

Poco::Int16
operator/=(
    Poco::Int16& other,
    const Var& da
    )

Division asignment operator for dividing Var with Poco::Int16.

bool
operator==(
    const Poco::Int16& other,
    const Var& da
    )

Equality operator for comparing Var with Poco::Int16.

bool
operator!=(
    const Poco::Int16& other,
    const Var& da
    )

Inequality operator for comparing Var with Poco::Int16.

bool
operator<(
    const Poco::Int16& other,
    const Var& da
    )

Less than operator for comparing Var with Poco::Int16.

bool
operator<=(
    const Poco::Int16& other,
    const Var& da
    )

Less than or equal operator for comparing Var with Poco::Int16.

bool
operator>(
    const Poco::Int16& other,
    const Var& da
    )

Greater than operator for comparing Var with Poco::Int16.

bool
operator>=(
    const Poco::Int16& other,
    const Var& da
    )

Greater than or equal operator for comparing Var with Poco::Int16.

Poco::UInt16
operator+(
    const Poco::UInt16& other,
    const Var& da
    )

Addition operator for adding Var to Poco::UInt16.

Poco::UInt16
operator-(
    const Poco::UInt16& other,
    const Var& da
    )

Subtraction operator for subtracting Var from Poco::UInt16.

Poco::UInt16
operator*(
    const Poco::UInt16& other,
    const Var& da
    )

Multiplication operator for multiplying Var with Poco::UInt16.

Poco::UInt16
operator/(
    const Poco::UInt16& other,
    const Var& da
    )

Division operator for dividing Var with Poco::UInt16.

Poco::UInt16
operator+=(
    Poco::UInt16& other,
    const Var& da
    )

Addition asignment operator for adding Var to Poco::UInt16.

Poco::UInt16
operator-=(
    Poco::UInt16& other,
    const Var& da
    )

Subtraction asignment operator for subtracting Var from Poco::UInt16.

Poco::UInt16
operator*=(
    Poco::UInt16& other,
    const Var& da
    )

Multiplication asignment operator for multiplying Var with Poco::UInt16.

Poco::UInt16
operator/=(
    Poco::UInt16& other,
    const Var& da
    )

Division asignment operator for dividing Var with Poco::UInt16.

bool
operator==(
    const Poco::UInt16& other,
    const Var& da
    )

Equality operator for comparing Var with Poco::UInt16.

bool
operator!=(
    const Poco::UInt16& other,
    const Var& da
    )

Inequality operator for comparing Var with Poco::UInt16.

bool
operator<(
    const Poco::UInt16& other,
    const Var& da
    )

Less than operator for comparing Var with Poco::UInt16.

bool
operator<=(
    const Poco::UInt16& other,
    const Var& da
    )

Less than or equal operator for comparing Var with Poco::UInt16.

bool
operator>(
    const Poco::UInt16& other,
    const Var& da
    )

Greater than operator for comparing Var with Poco::UInt16.

bool
operator>=(
    const Poco::UInt16& other,
    const Var& da
    )

Greater than or equal operator for comparing Var with Poco::UInt16.

Poco::Int32
operator+(
    const Poco::Int32& other,
    const Var& da
    )

Addition operator for adding Var to Poco::Int32.

Poco::Int32
operator-(
    const Poco::Int32& other,
    const Var& da
    )

Subtraction operator for subtracting Var from Poco::Int32.

Poco::Int32
operator*(
    const Poco::Int32& other,
    const Var& da
    )

Multiplication operator for multiplying Var with Poco::Int32.

Poco::Int32
operator/(
    const Poco::Int32& other,
    const Var& da
    )

Division operator for dividing Var with Poco::Int32.

Poco::Int32
operator+=(
    Poco::Int32& other,
    const Var& da
    )

Addition asignment operator for adding Var to Poco::Int32.

Poco::Int32
operator-=(
    Poco::Int32& other,
    const Var& da
    )

Subtraction asignment operator for subtracting Var from Poco::Int32.

Poco::Int32
operator*=(
    Poco::Int32& other,
    const Var& da
    )

Multiplication asignment operator for multiplying Var with Poco::Int32.

Poco::Int32
operator/=(
    Poco::Int32& other,
    const Var& da
    )

Division asignment operator for dividing Var with Poco::Int32.

bool
operator==(
    const Poco::Int32& other,
    const Var& da
    )

Equality operator for comparing Var with Poco::Int32.

bool
operator!=(
    const Poco::Int32& other,
    const Var& da
    )

Inequality operator for comparing Var with Poco::Int32.

bool
operator<(
    const Poco::Int32& other,
    const Var& da
    )

Less than operator for comparing Var with Poco::Int32.

bool
operator<=(
    const Poco::Int32& other,
    const Var& da
    )

Less than or equal operator for comparing Var with Poco::Int32.

bool
operator>(
    const Poco::Int32& other,
    const Var& da
    )

Greater than operator for comparing Var with Poco::Int32.

bool
operator>=(
    const Poco::Int32& other,
    const Var& da
    )

Greater than or equal operator for comparing Var with Poco::Int32.

Poco::UInt32
operator+(
    const Poco::UInt32& other,
    const Var& da
    )

Addition operator for adding Var to Poco::UInt32.

Poco::UInt32
operator-(
    const Poco::UInt32& other,
    const Var& da
    )

Subtraction operator for subtracting Var from Poco::UInt32.

Poco::UInt32
operator*(
    const Poco::UInt32& other,
    const Var& da
    )

Multiplication operator for multiplying Var with Poco::UInt32.

Poco::UInt32
operator/(
    const Poco::UInt32& other,
    const Var& da
    )

Division operator for dividing Var with Poco::UInt32.

Poco::UInt32
operator+=(
    Poco::UInt32& other,
    const Var& da
    )

Addition asignment operator for adding Var to Poco::UInt32.

Poco::UInt32
operator-=(
    Poco::UInt32& other,
    const Var& da
    )

Subtraction asignment operator for subtracting Var from Poco::UInt32.

Poco::UInt32
operator*=(
    Poco::UInt32& other,
    const Var& da
    )

Multiplication asignment operator for multiplying Var with Poco::UInt32.

Poco::UInt32
operator/=(
    Poco::UInt32& other,
    const Var& da
    )

Division asignment operator for dividing Var with Poco::UInt32.

bool
operator==(
    const Poco::UInt32& other,
    const Var& da
    )

Equality operator for comparing Var with Poco::UInt32.

bool
operator!=(
    const Poco::UInt32& other,
    const Var& da
    )

Inequality operator for comparing Var with Poco::UInt32.

bool
operator<(
    const Poco::UInt32& other,
    const Var& da
    )

Less than operator for comparing Var with Poco::UInt32.

bool
operator<=(
    const Poco::UInt32& other,
    const Var& da
    )

Less than or equal operator for comparing Var with Poco::UInt32.

bool
operator>(
    const Poco::UInt32& other,
    const Var& da
    )

Greater than operator for comparing Var with Poco::UInt32.

bool
operator>=(
    const Poco::UInt32& other,
    const Var& da
    )

Greater than or equal operator for comparing Var with Poco::UInt32.

Poco::Int64
operator+(
    const Poco::Int64& other,
    const Var& da
    )

Addition operator for adding Var to Poco::Int64.

Poco::Int64
operator-(
    const Poco::Int64& other,
    const Var& da
    )

Subtraction operator for subtracting Var from Poco::Int64.

Poco::Int64
operator*(
    const Poco::Int64& other,
    const Var& da
    )

Multiplication operator for multiplying Var with Poco::Int64.

Poco::Int64
operator/(
    const Poco::Int64& other,
    const Var& da
    )

Division operator for dividing Var with Poco::Int64.

Poco::Int64
operator+=(
    Poco::Int64& other,
    const Var& da
    )

Addition asignment operator for adding Var to Poco::Int64.

Poco::Int64
operator-=(
    Poco::Int64& other,
    const Var& da
    )

Subtraction asignment operator for subtracting Var from Poco::Int64.

Poco::Int64
operator*=(
    Poco::Int64& other,
    const Var& da
    )

Multiplication asignment operator for multiplying Var with Poco::Int64.

Poco::Int64
operator/=(
    Poco::Int64& other,
    const Var& da
    )

Division asignment operator for dividing Var with Poco::Int64.

bool
operator==(
    const Poco::Int64& other,
    const Var& da
    )

Equality operator for comparing Var with Poco::Int64.

bool
operator!=(
    const Poco::Int64& other,
    const Var& da
    )

Inequality operator for comparing Var with Poco::Int64.

bool
operator<(
    const Poco::Int64& other,
    const Var& da
    )

Less than operator for comparing Var with Poco::Int64.

bool
operator<=(
    const Poco::Int64& other,
    const Var& da
    )

Less than or equal operator for comparing Var with Poco::Int64.

bool
operator>(
    const Poco::Int64& other,
    const Var& da
    )

Greater than operator for comparing Var with Poco::Int64.

bool
operator>=(
    const Poco::Int64& other,
    const Var& da
    )

Greater than or equal operator for comparing Var with Poco::Int64.

Poco::UInt64
operator+(
    const Poco::UInt64& other,
    const Var& da
    )

Addition operator for adding Var to Poco::UInt64.

Poco::UInt64
operator-(
    const Poco::UInt64& other,
    const Var& da
    )

Subtraction operator for subtracting Var from Poco::UInt64.

Poco::UInt64
operator*(
    const Poco::UInt64& other,
    const Var& da
    )

Multiplication operator for multiplying Var with Poco::UInt64.

Poco::UInt64
operator/(
    const Poco::UInt64& other,
    const Var& da
    )

Division operator for dividing Var with Poco::UInt64.

Poco::UInt64
operator+=(
    Poco::UInt64& other,
    const Var& da
    )

Addition asignment operator for adding Var to Poco::UInt64.

Poco::UInt64
operator-=(
    Poco::UInt64& other,
    const Var& da
    )

Subtraction asignment operator for subtracting Var from Poco::UInt64.

Poco::UInt64
operator*=(
    Poco::UInt64& other,
    const Var& da
    )

Multiplication asignment operator for multiplying Var with Poco::UInt64.

Poco::UInt64
operator/=(
    Poco::UInt64& other,
    const Var& da
    )

Division asignment operator for dividing Var with Poco::UInt64.

bool
operator==(
    const Poco::UInt64& other,
    const Var& da
    )

Equality operator for comparing Var with Poco::UInt64.

bool
operator!=(
    const Poco::UInt64& other,
    const Var& da
    )

Inequality operator for comparing Var with Poco::UInt64.

bool
operator<(
    const Poco::UInt64& other,
    const Var& da
    )

Less than operator for comparing Var with Poco::UInt64.

bool
operator<=(
    const Poco::UInt64& other,
    const Var& da
    )

Less than or equal operator for comparing Var with Poco::UInt64.

bool
operator>(
    const Poco::UInt64& other,
    const Var& da
    )

Greater than operator for comparing Var with Poco::UInt64.

bool
operator>=(
    const Poco::UInt64& other,
    const Var& da
    )

Greater than or equal operator for comparing Var with Poco::UInt64.

float
operator+(
    const float& other,
    const Var& da
    )

Addition operator for adding Var to float.

float
operator-(
    const float& other,
    const Var& da
    )

Subtraction operator for subtracting Var from float.

float
operator*(
    const float& other,
    const Var& da
    )

Multiplication operator for multiplying Var with float.

float
operator/(
    const float& other,
    const Var& da
    )

Division operator for dividing Var with float.

float
operator+=(
    float& other,
    const Var& da
    )

Addition asignment operator for adding Var to float.

float
operator-=(
    float& other,
    const Var& da
    )

Subtraction asignment operator for subtracting Var from float.

float
operator*=(
    float& other,
    const Var& da
    )

Multiplication asignment operator for multiplying Var with float.

float
operator/=(
    float& other,
    const Var& da
    )

Division asignment operator for dividing Var with float.

bool
operator==(
    const float& other,
    const Var& da
    )

Equality operator for comparing Var with float.

bool
operator!=(
    const float& other,
    const Var& da
    )

Inequality operator for comparing Var with float.

bool
operator<(
    const float& other,
    const Var& da
    )

Less than operator for comparing Var with float.

bool
operator<=(
    const float& other,
    const Var& da
    )

Less than or equal operator for comparing Var with float.

bool
operator>(
    const float& other,
    const Var& da
    )

Greater than operator for comparing Var with float.

bool
operator>=(
    const float& other,
    const Var& da
    )

Greater than or equal operator for comparing Var with float.

double
operator+(
    const double& other,
    const Var& da
    )

Addition operator for adding Var to double.

double
operator-(
    const double& other,
    const Var& da
    )

Subtraction operator for subtracting Var from double.

double
operator*(
    const double& other,
    const Var& da
    )

Multiplication operator for multiplying Var with double.

double
operator/(
    const double& other,
    const Var& da
    )

Division operator for dividing Var with double.

double
operator+=(
    double& other,
    const Var& da
    )

Addition asignment operator for adding Var to double.

double
operator-=(
    double& other,
    const Var& da
    )

Subtraction asignment operator for subtracting Var from double.

double
operator*=(
    double& other,
    const Var& da
    )

Multiplication asignment operator for multiplying Var with double.

double
operator/=(
    double& other,
    const Var& da
    )

Division asignment operator for dividing Var with double.

bool
operator==(
    const double& other,
    const Var& da
    )

Equality operator for comparing Var with double.

bool
operator!=(
    const double& other,
    const Var& da
    )

Inequality operator for comparing Var with double.

bool
operator<(
    const double& other,
    const Var& da
    )

Less than operator for comparing Var with double.

bool
operator<=(
    const double& other,
    const Var& da
    )

Less than or equal operator for comparing Var with double.

bool
operator>(
    const double& other,
    const Var& da
    )

Greater than operator for comparing Var with double.

bool
operator>=(
    const double& other,
    const Var& da
    )

Greater than or equal operator for comparing Var with double.

bool
operator==(
    const bool& other,
    const Var& da
    )

Equality operator for comparing Var with bool.

bool
operator!=(
    const bool& other,
    const Var& da
    )

Inequality operator for comparing Var with bool.

bool
operator==(
    const std::string& other,
    const Var& da
    )

Equality operator for comparing Var with std::string.

bool
operator!=(
    const std::string& other,
    const Var& da
    )

Inequality operator for comparing Var with std::string.

bool
operator==(
    const UTF16String& other,
    const Var& da
    )

Equality operator for comparing Var with UTF16String.

bool
operator!=(
    const UTF16String& other,
    const Var& da
    )

Inequality operator for comparing Var with UTF16String.

bool
operator==(
    const char* other,
    const Var& da
    )

Equality operator for comparing Var with const char*.

bool
operator!=(
    const char* other,
    const Var& da
    )

Inequality operator for comparing Var with const char*.

long
operator+(
    const long& other,
    const Var& da
    )

Addition operator for adding Var to long.

long
operator-(
    const long& other,
    const Var& da
    )

Subtraction operator for subtracting Var from long.

long
operator*(
    const long& other,
    const Var& da
    )

Multiplication operator for multiplying Var with long.

long
operator/(
    const long& other,
    const Var& da
    )

Division operator for dividing Var with long.

long
operator+=(
    long& other,
    const Var& da
    )

Addition asignment operator for adding Var to long.

long
operator-=(
    long& other,
    const Var& da
    )

Subtraction asignment operator for subtracting Var from long.

long
operator*=(
    long& other,
    const Var& da
    )

Multiplication asignment operator for multiplying Var with long.

long
operator/=(
    long& other,
    const Var& da
    )

Division asignment operator for dividing Var with long.

bool
operator==(
    const long& other,
    const Var& da
    )

Equality operator for comparing Var with long.

bool
operator!=(
    const long& other,
    const Var& da
    )

Inequality operator for comparing Var with long.

bool
operator<(
    const long& other,
    const Var& da
    )

Less than operator for comparing Var with long.

bool
operator<=(
    const long& other,
    const Var& da
    )

Less than or equal operator for comparing Var with long.

bool
operator>(
    const long& other,
    const Var& da
    )

Greater than operator for comparing Var with long.

bool
operator>=(
    const long& other,
    const Var& da
    )

Greater than or equal operator for comparing Var with long.