/*****************************************************************************/
/** DO NOT MODIFY THIS FILE **/
/** generated using xsl transformation: EeekSoft.CLinq.Typed.xsl **/
/*****************************************************************************/
#pragma once
#include "clinqcore.h"
using namespace System;
using namespace System::Reflection;
using namespace System::Collections::Generic;
using namespace EeekSoft::CLinq;
namespace EeekSoft {
namespace CLinq {
/// <summary>
/// Template specialization for the 'bool' expresion. Implements operators !=, == and logical operators (&&, ||) and unary !.
/// </summary>
template<> public ref class Expr<bool> : ExpressionWrapper<bool>
{
public:
static property Type^ WrappedType { Type^ get() { return bool::typeid; } }
public:
Expr<bool>() { }
Expr<bool>(bool val) { _value = gcnew Literal<bool>(val); }
Expr<bool>(Expression<bool>^ value) { _value = value; }
Expr<bool>(Expr<bool>% b) { _value = b._value; }
operator Expression<bool>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<bool>(Expression<bool>^ value) { return Expr<bool>(value); }
static operator Expr<bool>(bool b) { return Expr<bool>(b); }
public:
static Expr<bool> Typed(GenericExpression^ value)
{
return Expr<bool>(gcnew TypedExpression<bool>(value));
}
static Expr<bool> Convert(GenericExpression^ value)
{
return Expr<bool>(gcnew ConvertExpression<bool>(value));
}
public:
/// <summary>
/// Returns negation of the logical value.
/// </summary>
static Expr<bool> operator!(Expr<bool> value)
{
return Expr<bool>(gcnew UnaryExpression<bool,bool>
(value, System::Expressions::ExpressionType::Not));
}
/// <summary>
/// Test values for equality.
/// </summary>
static Expr<bool> operator==(Expr<bool> left, Expr<bool> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,bool,bool>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Test values for inequality.
/// </summary>
static Expr<bool> operator!=(Expr<bool> left, Expr<bool> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,bool,bool>
(left, right, System::Expressions::ExpressionType::NE));
}
/// <summary>
/// Performs logical 'and' operation.
/// </summary>
static Expr<bool> operator&&(Expr<bool> left, Expr<bool> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,bool,bool>
(left, right, System::Expressions::ExpressionType::And));
}
/// <summary>
/// Performs logical 'or' operation.
/// </summary>
static Expr<bool> operator||(Expr<bool> left, Expr<bool> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,bool,bool>
(left, right, System::Expressions::ExpressionType::Or));
}
public:
};
/// <summary>
/// Template specialization for the 'Nullable<double>' expresion. Supports standard math and comparison operators.
/// </summary>
template<> public ref class Expr<Nullable<double>> : ExpressionWrapper<Nullable<double>>
{
public:
static property Type^ WrappedType { Type^ get() { return Nullable<double>::typeid; } }
public:
Expr<Nullable<double>>() { }
Expr<Nullable<double>>(Nullable<double> val) { _value = gcnew Literal<Nullable<double>>(val); }
Expr<Nullable<double>>(Expression<Nullable<double>>^ value) { _value = value; }
Expr<Nullable<double>>(Expr<Nullable<double>>% b) { _value = b._value; }
operator Expression<Nullable<double>>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<Nullable<double>>(Expression<Nullable<double>>^ value) { return Expr<Nullable<double>>(value); }
static operator Expr<Nullable<double>>(Nullable<double> b) { return Expr<Nullable<double>>(b); }
public:
static Expr<Nullable<double>> Typed(GenericExpression^ value)
{
return Expr<Nullable<double>>(gcnew TypedExpression<Nullable<double>>(value));
}
static Expr<Nullable<double>> Convert(GenericExpression^ value)
{
return Expr<Nullable<double>>(gcnew ConvertExpression<Nullable<double>>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<Nullable<double>> types.
/// </summary>
static Expr<Nullable<double>> operator+(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
{
return Expr<Nullable<double>>(gcnew BinaryExpression<Nullable<double>,Nullable<double>,Nullable<double>>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<Nullable<double>> types.
/// </summary>
static Expr<Nullable<double>> operator*(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
{
return Expr<Nullable<double>>(gcnew BinaryExpression<Nullable<double>,Nullable<double>,Nullable<double>>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<Nullable<double>> types.
/// </summary>
static Expr<Nullable<double>> operator/(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
{
return Expr<Nullable<double>>(gcnew BinaryExpression<Nullable<double>,Nullable<double>,Nullable<double>>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<Nullable<double>> types.
/// </summary>
static Expr<Nullable<double>> operator-(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
{
return Expr<Nullable<double>>(gcnew BinaryExpression<Nullable<double>,Nullable<double>,Nullable<double>>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<Nullable<double>> types.
/// </summary>
static Expr<bool> operator==(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<double>,Nullable<double>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<Nullable<double>> types.
/// </summary>
static Expr<bool> operator!=(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<double>,Nullable<double>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<Nullable<double>> types.
/// </summary>
static Expr<bool> operator<(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<double>,Nullable<double>>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<Nullable<double>> types.
/// </summary>
static Expr<bool> operator>(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<double>,Nullable<double>>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<Nullable<double>> types.
/// </summary>
static Expr<bool> operator<=(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<double>,Nullable<double>>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<Nullable<double>> types.
/// </summary>
static Expr<bool> operator>=(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<double>,Nullable<double>>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'Nullable<float>' expresion. Supports standard math and comparison operators.
/// </summary>
template<> public ref class Expr<Nullable<float>> : ExpressionWrapper<Nullable<float>>
{
public:
static property Type^ WrappedType { Type^ get() { return Nullable<float>::typeid; } }
public:
Expr<Nullable<float>>() { }
Expr<Nullable<float>>(Nullable<float> val) { _value = gcnew Literal<Nullable<float>>(val); }
Expr<Nullable<float>>(Expression<Nullable<float>>^ value) { _value = value; }
Expr<Nullable<float>>(Expr<Nullable<float>>% b) { _value = b._value; }
operator Expression<Nullable<float>>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<Nullable<float>>(Expression<Nullable<float>>^ value) { return Expr<Nullable<float>>(value); }
static operator Expr<Nullable<float>>(Nullable<float> b) { return Expr<Nullable<float>>(b); }
public:
static Expr<Nullable<float>> Typed(GenericExpression^ value)
{
return Expr<Nullable<float>>(gcnew TypedExpression<Nullable<float>>(value));
}
static Expr<Nullable<float>> Convert(GenericExpression^ value)
{
return Expr<Nullable<float>>(gcnew ConvertExpression<Nullable<float>>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<Nullable<float>> types.
/// </summary>
static Expr<Nullable<float>> operator+(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
{
return Expr<Nullable<float>>(gcnew BinaryExpression<Nullable<float>,Nullable<float>,Nullable<float>>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<Nullable<float>> types.
/// </summary>
static Expr<Nullable<float>> operator*(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
{
return Expr<Nullable<float>>(gcnew BinaryExpression<Nullable<float>,Nullable<float>,Nullable<float>>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<Nullable<float>> types.
/// </summary>
static Expr<Nullable<float>> operator/(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
{
return Expr<Nullable<float>>(gcnew BinaryExpression<Nullable<float>,Nullable<float>,Nullable<float>>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<Nullable<float>> types.
/// </summary>
static Expr<Nullable<float>> operator-(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
{
return Expr<Nullable<float>>(gcnew BinaryExpression<Nullable<float>,Nullable<float>,Nullable<float>>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<Nullable<float>> types.
/// </summary>
static Expr<bool> operator==(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<float>,Nullable<float>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<Nullable<float>> types.
/// </summary>
static Expr<bool> operator!=(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<float>,Nullable<float>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<Nullable<float>> types.
/// </summary>
static Expr<bool> operator<(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<float>,Nullable<float>>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<Nullable<float>> types.
/// </summary>
static Expr<bool> operator>(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<float>,Nullable<float>>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<Nullable<float>> types.
/// </summary>
static Expr<bool> operator<=(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<float>,Nullable<float>>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<Nullable<float>> types.
/// </summary>
static Expr<bool> operator>=(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<float>,Nullable<float>>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'Nullable<System::Decimal>' expresion. Supports standard math and comparison operators.
/// </summary>
template<> public ref class Expr<Nullable<System::Decimal>> : ExpressionWrapper<Nullable<System::Decimal>>
{
public:
static property Type^ WrappedType { Type^ get() { return Nullable<System::Decimal>::typeid; } }
public:
Expr<Nullable<System::Decimal>>() { }
Expr<Nullable<System::Decimal>>(Nullable<System::Decimal> val) { _value = gcnew Literal<Nullable<System::Decimal>>(val); }
Expr<Nullable<System::Decimal>>(Expression<Nullable<System::Decimal>>^ value) { _value = value; }
Expr<Nullable<System::Decimal>>(Expr<Nullable<System::Decimal>>% b) { _value = b._value; }
operator Expression<Nullable<System::Decimal>>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<Nullable<System::Decimal>>(Expression<Nullable<System::Decimal>>^ value) { return Expr<Nullable<System::Decimal>>(value); }
static operator Expr<Nullable<System::Decimal>>(Nullable<System::Decimal> b) { return Expr<Nullable<System::Decimal>>(b); }
public:
static Expr<Nullable<System::Decimal>> Typed(GenericExpression^ value)
{
return Expr<Nullable<System::Decimal>>(gcnew TypedExpression<Nullable<System::Decimal>>(value));
}
static Expr<Nullable<System::Decimal>> Convert(GenericExpression^ value)
{
return Expr<Nullable<System::Decimal>>(gcnew ConvertExpression<Nullable<System::Decimal>>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<Nullable<System::Decimal>> types.
/// </summary>
static Expr<Nullable<System::Decimal>> operator+(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
{
return Expr<Nullable<System::Decimal>>(gcnew BinaryExpression<Nullable<System::Decimal>,Nullable<System::Decimal>,Nullable<System::Decimal>>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<Nullable<System::Decimal>> types.
/// </summary>
static Expr<Nullable<System::Decimal>> operator*(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
{
return Expr<Nullable<System::Decimal>>(gcnew BinaryExpression<Nullable<System::Decimal>,Nullable<System::Decimal>,Nullable<System::Decimal>>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<Nullable<System::Decimal>> types.
/// </summary>
static Expr<Nullable<System::Decimal>> operator/(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
{
return Expr<Nullable<System::Decimal>>(gcnew BinaryExpression<Nullable<System::Decimal>,Nullable<System::Decimal>,Nullable<System::Decimal>>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<Nullable<System::Decimal>> types.
/// </summary>
static Expr<Nullable<System::Decimal>> operator-(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
{
return Expr<Nullable<System::Decimal>>(gcnew BinaryExpression<Nullable<System::Decimal>,Nullable<System::Decimal>,Nullable<System::Decimal>>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<Nullable<System::Decimal>> types.
/// </summary>
static Expr<bool> operator==(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<System::Decimal>,Nullable<System::Decimal>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<Nullable<System::Decimal>> types.
/// </summary>
static Expr<bool> operator!=(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<System::Decimal>,Nullable<System::Decimal>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<Nullable<System::Decimal>> types.
/// </summary>
static Expr<bool> operator<(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<System::Decimal>,Nullable<System::Decimal>>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<Nullable<System::Decimal>> types.
/// </summary>
static Expr<bool> operator>(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<System::Decimal>,Nullable<System::Decimal>>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<Nullable<System::Decimal>> types.
/// </summary>
static Expr<bool> operator<=(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<System::Decimal>,Nullable<System::Decimal>>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<Nullable<System::Decimal>> types.
/// </summary>
static Expr<bool> operator>=(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<System::Decimal>,Nullable<System::Decimal>>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'Nullable<long long int>' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<Nullable<long long int>> : ExpressionWrapper<Nullable<long long int>>
{
public:
static property Type^ WrappedType { Type^ get() { return Nullable<long long int>::typeid; } }
public:
Expr<Nullable<long long int>>() { }
Expr<Nullable<long long int>>(Nullable<long long int> val) { _value = gcnew Literal<Nullable<long long int>>(val); }
Expr<Nullable<long long int>>(Expression<Nullable<long long int>>^ value) { _value = value; }
Expr<Nullable<long long int>>(Expr<Nullable<long long int>>% b) { _value = b._value; }
operator Expression<Nullable<long long int>>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<Nullable<long long int>>(Expression<Nullable<long long int>>^ value) { return Expr<Nullable<long long int>>(value); }
static operator Expr<Nullable<long long int>>(Nullable<long long int> b) { return Expr<Nullable<long long int>>(b); }
public:
static Expr<Nullable<long long int>> Typed(GenericExpression^ value)
{
return Expr<Nullable<long long int>>(gcnew TypedExpression<Nullable<long long int>>(value));
}
static Expr<Nullable<long long int>> Convert(GenericExpression^ value)
{
return Expr<Nullable<long long int>>(gcnew ConvertExpression<Nullable<long long int>>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<Nullable<long long int>> types.
/// </summary>
static Expr<Nullable<long long int>> operator+(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
{
return Expr<Nullable<long long int>>(gcnew BinaryExpression<Nullable<long long int>,Nullable<long long int>,Nullable<long long int>>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<Nullable<long long int>> types.
/// </summary>
static Expr<Nullable<long long int>> operator*(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
{
return Expr<Nullable<long long int>>(gcnew BinaryExpression<Nullable<long long int>,Nullable<long long int>,Nullable<long long int>>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<Nullable<long long int>> types.
/// </summary>
static Expr<Nullable<long long int>> operator/(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
{
return Expr<Nullable<long long int>>(gcnew BinaryExpression<Nullable<long long int>,Nullable<long long int>,Nullable<long long int>>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<Nullable<long long int>> types.
/// </summary>
static Expr<Nullable<long long int>> operator-(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
{
return Expr<Nullable<long long int>>(gcnew BinaryExpression<Nullable<long long int>,Nullable<long long int>,Nullable<long long int>>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<Nullable<long long int>> types.
/// </summary>
static Expr<bool> operator==(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<long long int>,Nullable<long long int>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<Nullable<long long int>> types.
/// </summary>
static Expr<bool> operator!=(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<long long int>,Nullable<long long int>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<Nullable<long long int>> types.
/// </summary>
static Expr<bool> operator<(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<long long int>,Nullable<long long int>>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<Nullable<long long int>> types.
/// </summary>
static Expr<bool> operator>(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<long long int>,Nullable<long long int>>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<Nullable<long long int>> types.
/// </summary>
static Expr<bool> operator<=(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<long long int>,Nullable<long long int>>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<Nullable<long long int>> types.
/// </summary>
static Expr<bool> operator>=(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<long long int>,Nullable<long long int>>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'Nullable<unsigned long long int>' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<Nullable<unsigned long long int>> : ExpressionWrapper<Nullable<unsigned long long int>>
{
public:
static property Type^ WrappedType { Type^ get() { return Nullable<unsigned long long int>::typeid; } }
public:
Expr<Nullable<unsigned long long int>>() { }
Expr<Nullable<unsigned long long int>>(Nullable<unsigned long long int> val) { _value = gcnew Literal<Nullable<unsigned long long int>>(val); }
Expr<Nullable<unsigned long long int>>(Expression<Nullable<unsigned long long int>>^ value) { _value = value; }
Expr<Nullable<unsigned long long int>>(Expr<Nullable<unsigned long long int>>% b) { _value = b._value; }
operator Expression<Nullable<unsigned long long int>>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<Nullable<unsigned long long int>>(Expression<Nullable<unsigned long long int>>^ value) { return Expr<Nullable<unsigned long long int>>(value); }
static operator Expr<Nullable<unsigned long long int>>(Nullable<unsigned long long int> b) { return Expr<Nullable<unsigned long long int>>(b); }
public:
static Expr<Nullable<unsigned long long int>> Typed(GenericExpression^ value)
{
return Expr<Nullable<unsigned long long int>>(gcnew TypedExpression<Nullable<unsigned long long int>>(value));
}
static Expr<Nullable<unsigned long long int>> Convert(GenericExpression^ value)
{
return Expr<Nullable<unsigned long long int>>(gcnew ConvertExpression<Nullable<unsigned long long int>>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<Nullable<unsigned long long int>> types.
/// </summary>
static Expr<Nullable<unsigned long long int>> operator+(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
{
return Expr<Nullable<unsigned long long int>>(gcnew BinaryExpression<Nullable<unsigned long long int>,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<Nullable<unsigned long long int>> types.
/// </summary>
static Expr<Nullable<unsigned long long int>> operator*(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
{
return Expr<Nullable<unsigned long long int>>(gcnew BinaryExpression<Nullable<unsigned long long int>,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<Nullable<unsigned long long int>> types.
/// </summary>
static Expr<Nullable<unsigned long long int>> operator/(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
{
return Expr<Nullable<unsigned long long int>>(gcnew BinaryExpression<Nullable<unsigned long long int>,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<Nullable<unsigned long long int>> types.
/// </summary>
static Expr<Nullable<unsigned long long int>> operator-(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
{
return Expr<Nullable<unsigned long long int>>(gcnew BinaryExpression<Nullable<unsigned long long int>,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<Nullable<unsigned long long int>> types.
/// </summary>
static Expr<bool> operator==(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<Nullable<unsigned long long int>> types.
/// </summary>
static Expr<bool> operator!=(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<Nullable<unsigned long long int>> types.
/// </summary>
static Expr<bool> operator<(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<Nullable<unsigned long long int>> types.
/// </summary>
static Expr<bool> operator>(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<Nullable<unsigned long long int>> types.
/// </summary>
static Expr<bool> operator<=(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<Nullable<unsigned long long int>> types.
/// </summary>
static Expr<bool> operator>=(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'Nullable<int>' expresion. Supports standard math and comparison operators (including modulo and shifts).
/// </summary>
template<> public ref class Expr<Nullable<int>> : ExpressionWrapper<Nullable<int>>
{
public:
static property Type^ WrappedType { Type^ get() { return Nullable<int>::typeid; } }
public:
Expr<Nullable<int>>() { }
Expr<Nullable<int>>(Nullable<int> val) { _value = gcnew Literal<Nullable<int>>(val); }
Expr<Nullable<int>>(Expression<Nullable<int>>^ value) { _value = value; }
Expr<Nullable<int>>(Expr<Nullable<int>>% b) { _value = b._value; }
operator Expression<Nullable<int>>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<Nullable<int>>(Expression<Nullable<int>>^ value) { return Expr<Nullable<int>>(value); }
static operator Expr<Nullable<int>>(Nullable<int> b) { return Expr<Nullable<int>>(b); }
public:
static Expr<Nullable<int>> Typed(GenericExpression^ value)
{
return Expr<Nullable<int>>(gcnew TypedExpression<Nullable<int>>(value));
}
static Expr<Nullable<int>> Convert(GenericExpression^ value)
{
return Expr<Nullable<int>>(gcnew ConvertExpression<Nullable<int>>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<Nullable<int>> types.
/// </summary>
static Expr<Nullable<int>> operator+(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
{
return Expr<Nullable<int>>(gcnew BinaryExpression<Nullable<int>,Nullable<int>,Nullable<int>>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<Nullable<int>> types.
/// </summary>
static Expr<Nullable<int>> operator*(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
{
return Expr<Nullable<int>>(gcnew BinaryExpression<Nullable<int>,Nullable<int>,Nullable<int>>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<Nullable<int>> types.
/// </summary>
static Expr<Nullable<int>> operator/(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
{
return Expr<Nullable<int>>(gcnew BinaryExpression<Nullable<int>,Nullable<int>,Nullable<int>>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<Nullable<int>> types.
/// </summary>
static Expr<Nullable<int>> operator-(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
{
return Expr<Nullable<int>>(gcnew BinaryExpression<Nullable<int>,Nullable<int>,Nullable<int>>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<Nullable<int>> types.
/// </summary>
static Expr<bool> operator==(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<int>,Nullable<int>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<Nullable<int>> types.
/// </summary>
static Expr<bool> operator!=(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<int>,Nullable<int>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<Nullable<int>> types.
/// </summary>
static Expr<bool> operator<(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<int>,Nullable<int>>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<Nullable<int>> types.
/// </summary>
static Expr<bool> operator>(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<int>,Nullable<int>>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<Nullable<int>> types.
/// </summary>
static Expr<bool> operator<=(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<int>,Nullable<int>>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<Nullable<int>> types.
/// </summary>
static Expr<bool> operator>=(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<int>,Nullable<int>>
(left, right, System::Expressions::ExpressionType::GE));
}
/// <summary>
/// Shift left operator for tuple of Expr<Nullable<int>> types.
/// </summary>
static Expr<Nullable<int>> operator<<(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
{
return Expr<Nullable<int>>(gcnew BinaryExpression<Nullable<int>,Nullable<int>,Nullable<int>>
(left, right, System::Expressions::ExpressionType::LShift));
}
/// <summary>
/// Shift right operator for tuple of Expr<Nullable<int>> types.
/// </summary>
static Expr<Nullable<int>> operator>>(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
{
return Expr<Nullable<int>>(gcnew BinaryExpression<Nullable<int>,Nullable<int>,Nullable<int>>
(left, right, System::Expressions::ExpressionType::RShift));
}
public:
};
/// <summary>
/// Template specialization for the 'Nullable<unsigned int>' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<Nullable<unsigned int>> : ExpressionWrapper<Nullable<unsigned int>>
{
public:
static property Type^ WrappedType { Type^ get() { return Nullable<unsigned int>::typeid; } }
public:
Expr<Nullable<unsigned int>>() { }
Expr<Nullable<unsigned int>>(Nullable<unsigned int> val) { _value = gcnew Literal<Nullable<unsigned int>>(val); }
Expr<Nullable<unsigned int>>(Expression<Nullable<unsigned int>>^ value) { _value = value; }
Expr<Nullable<unsigned int>>(Expr<Nullable<unsigned int>>% b) { _value = b._value; }
operator Expression<Nullable<unsigned int>>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<Nullable<unsigned int>>(Expression<Nullable<unsigned int>>^ value) { return Expr<Nullable<unsigned int>>(value); }
static operator Expr<Nullable<unsigned int>>(Nullable<unsigned int> b) { return Expr<Nullable<unsigned int>>(b); }
public:
static Expr<Nullable<unsigned int>> Typed(GenericExpression^ value)
{
return Expr<Nullable<unsigned int>>(gcnew TypedExpression<Nullable<unsigned int>>(value));
}
static Expr<Nullable<unsigned int>> Convert(GenericExpression^ value)
{
return Expr<Nullable<unsigned int>>(gcnew ConvertExpression<Nullable<unsigned int>>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<Nullable<unsigned int>> types.
/// </summary>
static Expr<Nullable<unsigned int>> operator+(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
{
return Expr<Nullable<unsigned int>>(gcnew BinaryExpression<Nullable<unsigned int>,Nullable<unsigned int>,Nullable<unsigned int>>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<Nullable<unsigned int>> types.
/// </summary>
static Expr<Nullable<unsigned int>> operator*(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
{
return Expr<Nullable<unsigned int>>(gcnew BinaryExpression<Nullable<unsigned int>,Nullable<unsigned int>,Nullable<unsigned int>>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<Nullable<unsigned int>> types.
/// </summary>
static Expr<Nullable<unsigned int>> operator/(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
{
return Expr<Nullable<unsigned int>>(gcnew BinaryExpression<Nullable<unsigned int>,Nullable<unsigned int>,Nullable<unsigned int>>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<Nullable<unsigned int>> types.
/// </summary>
static Expr<Nullable<unsigned int>> operator-(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
{
return Expr<Nullable<unsigned int>>(gcnew BinaryExpression<Nullable<unsigned int>,Nullable<unsigned int>,Nullable<unsigned int>>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<Nullable<unsigned int>> types.
/// </summary>
static Expr<bool> operator==(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned int>,Nullable<unsigned int>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<Nullable<unsigned int>> types.
/// </summary>
static Expr<bool> operator!=(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned int>,Nullable<unsigned int>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<Nullable<unsigned int>> types.
/// </summary>
static Expr<bool> operator<(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned int>,Nullable<unsigned int>>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<Nullable<unsigned int>> types.
/// </summary>
static Expr<bool> operator>(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned int>,Nullable<unsigned int>>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<Nullable<unsigned int>> types.
/// </summary>
static Expr<bool> operator<=(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned int>,Nullable<unsigned int>>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<Nullable<unsigned int>> types.
/// </summary>
static Expr<bool> operator>=(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned int>,Nullable<unsigned int>>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'Nullable<short>' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<Nullable<short>> : ExpressionWrapper<Nullable<short>>
{
public:
static property Type^ WrappedType { Type^ get() { return Nullable<short>::typeid; } }
public:
Expr<Nullable<short>>() { }
Expr<Nullable<short>>(Nullable<short> val) { _value = gcnew Literal<Nullable<short>>(val); }
Expr<Nullable<short>>(Expression<Nullable<short>>^ value) { _value = value; }
Expr<Nullable<short>>(Expr<Nullable<short>>% b) { _value = b._value; }
operator Expression<Nullable<short>>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<Nullable<short>>(Expression<Nullable<short>>^ value) { return Expr<Nullable<short>>(value); }
static operator Expr<Nullable<short>>(Nullable<short> b) { return Expr<Nullable<short>>(b); }
public:
static Expr<Nullable<short>> Typed(GenericExpression^ value)
{
return Expr<Nullable<short>>(gcnew TypedExpression<Nullable<short>>(value));
}
static Expr<Nullable<short>> Convert(GenericExpression^ value)
{
return Expr<Nullable<short>>(gcnew ConvertExpression<Nullable<short>>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<Nullable<short>> types.
/// </summary>
static Expr<Nullable<short>> operator+(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
{
return Expr<Nullable<short>>(gcnew BinaryExpression<Nullable<short>,Nullable<short>,Nullable<short>>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<Nullable<short>> types.
/// </summary>
static Expr<Nullable<short>> operator*(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
{
return Expr<Nullable<short>>(gcnew BinaryExpression<Nullable<short>,Nullable<short>,Nullable<short>>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<Nullable<short>> types.
/// </summary>
static Expr<Nullable<short>> operator/(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
{
return Expr<Nullable<short>>(gcnew BinaryExpression<Nullable<short>,Nullable<short>,Nullable<short>>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<Nullable<short>> types.
/// </summary>
static Expr<Nullable<short>> operator-(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
{
return Expr<Nullable<short>>(gcnew BinaryExpression<Nullable<short>,Nullable<short>,Nullable<short>>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<Nullable<short>> types.
/// </summary>
static Expr<bool> operator==(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<short>,Nullable<short>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<Nullable<short>> types.
/// </summary>
static Expr<bool> operator!=(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<short>,Nullable<short>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<Nullable<short>> types.
/// </summary>
static Expr<bool> operator<(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<short>,Nullable<short>>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<Nullable<short>> types.
/// </summary>
static Expr<bool> operator>(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<short>,Nullable<short>>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<Nullable<short>> types.
/// </summary>
static Expr<bool> operator<=(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<short>,Nullable<short>>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<Nullable<short>> types.
/// </summary>
static Expr<bool> operator>=(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<short>,Nullable<short>>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'Nullable<unsigned short>' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<Nullable<unsigned short>> : ExpressionWrapper<Nullable<unsigned short>>
{
public:
static property Type^ WrappedType { Type^ get() { return Nullable<unsigned short>::typeid; } }
public:
Expr<Nullable<unsigned short>>() { }
Expr<Nullable<unsigned short>>(Nullable<unsigned short> val) { _value = gcnew Literal<Nullable<unsigned short>>(val); }
Expr<Nullable<unsigned short>>(Expression<Nullable<unsigned short>>^ value) { _value = value; }
Expr<Nullable<unsigned short>>(Expr<Nullable<unsigned short>>% b) { _value = b._value; }
operator Expression<Nullable<unsigned short>>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<Nullable<unsigned short>>(Expression<Nullable<unsigned short>>^ value) { return Expr<Nullable<unsigned short>>(value); }
static operator Expr<Nullable<unsigned short>>(Nullable<unsigned short> b) { return Expr<Nullable<unsigned short>>(b); }
public:
static Expr<Nullable<unsigned short>> Typed(GenericExpression^ value)
{
return Expr<Nullable<unsigned short>>(gcnew TypedExpression<Nullable<unsigned short>>(value));
}
static Expr<Nullable<unsigned short>> Convert(GenericExpression^ value)
{
return Expr<Nullable<unsigned short>>(gcnew ConvertExpression<Nullable<unsigned short>>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<Nullable<unsigned short>> types.
/// </summary>
static Expr<Nullable<unsigned short>> operator+(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
{
return Expr<Nullable<unsigned short>>(gcnew BinaryExpression<Nullable<unsigned short>,Nullable<unsigned short>,Nullable<unsigned short>>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<Nullable<unsigned short>> types.
/// </summary>
static Expr<Nullable<unsigned short>> operator*(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
{
return Expr<Nullable<unsigned short>>(gcnew BinaryExpression<Nullable<unsigned short>,Nullable<unsigned short>,Nullable<unsigned short>>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<Nullable<unsigned short>> types.
/// </summary>
static Expr<Nullable<unsigned short>> operator/(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
{
return Expr<Nullable<unsigned short>>(gcnew BinaryExpression<Nullable<unsigned short>,Nullable<unsigned short>,Nullable<unsigned short>>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<Nullable<unsigned short>> types.
/// </summary>
static Expr<Nullable<unsigned short>> operator-(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
{
return Expr<Nullable<unsigned short>>(gcnew BinaryExpression<Nullable<unsigned short>,Nullable<unsigned short>,Nullable<unsigned short>>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<Nullable<unsigned short>> types.
/// </summary>
static Expr<bool> operator==(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned short>,Nullable<unsigned short>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<Nullable<unsigned short>> types.
/// </summary>
static Expr<bool> operator!=(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned short>,Nullable<unsigned short>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<Nullable<unsigned short>> types.
/// </summary>
static Expr<bool> operator<(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned short>,Nullable<unsigned short>>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<Nullable<unsigned short>> types.
/// </summary>
static Expr<bool> operator>(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned short>,Nullable<unsigned short>>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<Nullable<unsigned short>> types.
/// </summary>
static Expr<bool> operator<=(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned short>,Nullable<unsigned short>>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<Nullable<unsigned short>> types.
/// </summary>
static Expr<bool> operator>=(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned short>,Nullable<unsigned short>>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'Nullable<unsigned char>' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<Nullable<unsigned char>> : ExpressionWrapper<Nullable<unsigned char>>
{
public:
static property Type^ WrappedType { Type^ get() { return Nullable<unsigned char>::typeid; } }
public:
Expr<Nullable<unsigned char>>() { }
Expr<Nullable<unsigned char>>(Nullable<unsigned char> val) { _value = gcnew Literal<Nullable<unsigned char>>(val); }
Expr<Nullable<unsigned char>>(Expression<Nullable<unsigned char>>^ value) { _value = value; }
Expr<Nullable<unsigned char>>(Expr<Nullable<unsigned char>>% b) { _value = b._value; }
operator Expression<Nullable<unsigned char>>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<Nullable<unsigned char>>(Expression<Nullable<unsigned char>>^ value) { return Expr<Nullable<unsigned char>>(value); }
static operator Expr<Nullable<unsigned char>>(Nullable<unsigned char> b) { return Expr<Nullable<unsigned char>>(b); }
public:
static Expr<Nullable<unsigned char>> Typed(GenericExpression^ value)
{
return Expr<Nullable<unsigned char>>(gcnew TypedExpression<Nullable<unsigned char>>(value));
}
static Expr<Nullable<unsigned char>> Convert(GenericExpression^ value)
{
return Expr<Nullable<unsigned char>>(gcnew ConvertExpression<Nullable<unsigned char>>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<Nullable<unsigned char>> types.
/// </summary>
static Expr<Nullable<unsigned char>> operator+(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
{
return Expr<Nullable<unsigned char>>(gcnew BinaryExpression<Nullable<unsigned char>,Nullable<unsigned char>,Nullable<unsigned char>>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<Nullable<unsigned char>> types.
/// </summary>
static Expr<Nullable<unsigned char>> operator*(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
{
return Expr<Nullable<unsigned char>>(gcnew BinaryExpression<Nullable<unsigned char>,Nullable<unsigned char>,Nullable<unsigned char>>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<Nullable<unsigned char>> types.
/// </summary>
static Expr<Nullable<unsigned char>> operator/(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
{
return Expr<Nullable<unsigned char>>(gcnew BinaryExpression<Nullable<unsigned char>,Nullable<unsigned char>,Nullable<unsigned char>>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<Nullable<unsigned char>> types.
/// </summary>
static Expr<Nullable<unsigned char>> operator-(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
{
return Expr<Nullable<unsigned char>>(gcnew BinaryExpression<Nullable<unsigned char>,Nullable<unsigned char>,Nullable<unsigned char>>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<Nullable<unsigned char>> types.
/// </summary>
static Expr<bool> operator==(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned char>,Nullable<unsigned char>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<Nullable<unsigned char>> types.
/// </summary>
static Expr<bool> operator!=(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned char>,Nullable<unsigned char>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<Nullable<unsigned char>> types.
/// </summary>
static Expr<bool> operator<(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned char>,Nullable<unsigned char>>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<Nullable<unsigned char>> types.
/// </summary>
static Expr<bool> operator>(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned char>,Nullable<unsigned char>>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<Nullable<unsigned char>> types.
/// </summary>
static Expr<bool> operator<=(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned char>,Nullable<unsigned char>>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<Nullable<unsigned char>> types.
/// </summary>
static Expr<bool> operator>=(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned char>,Nullable<unsigned char>>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'Nullable<signed char>' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<Nullable<signed char>> : ExpressionWrapper<Nullable<signed char>>
{
public:
static property Type^ WrappedType { Type^ get() { return Nullable<signed char>::typeid; } }
public:
Expr<Nullable<signed char>>() { }
Expr<Nullable<signed char>>(Nullable<signed char> val) { _value = gcnew Literal<Nullable<signed char>>(val); }
Expr<Nullable<signed char>>(Expression<Nullable<signed char>>^ value) { _value = value; }
Expr<Nullable<signed char>>(Expr<Nullable<signed char>>% b) { _value = b._value; }
operator Expression<Nullable<signed char>>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<Nullable<signed char>>(Expression<Nullable<signed char>>^ value) { return Expr<Nullable<signed char>>(value); }
static operator Expr<Nullable<signed char>>(Nullable<signed char> b) { return Expr<Nullable<signed char>>(b); }
public:
static Expr<Nullable<signed char>> Typed(GenericExpression^ value)
{
return Expr<Nullable<signed char>>(gcnew TypedExpression<Nullable<signed char>>(value));
}
static Expr<Nullable<signed char>> Convert(GenericExpression^ value)
{
return Expr<Nullable<signed char>>(gcnew ConvertExpression<Nullable<signed char>>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<Nullable<signed char>> types.
/// </summary>
static Expr<Nullable<signed char>> operator+(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
{
return Expr<Nullable<signed char>>(gcnew BinaryExpression<Nullable<signed char>,Nullable<signed char>,Nullable<signed char>>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<Nullable<signed char>> types.
/// </summary>
static Expr<Nullable<signed char>> operator*(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
{
return Expr<Nullable<signed char>>(gcnew BinaryExpression<Nullable<signed char>,Nullable<signed char>,Nullable<signed char>>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<Nullable<signed char>> types.
/// </summary>
static Expr<Nullable<signed char>> operator/(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
{
return Expr<Nullable<signed char>>(gcnew BinaryExpression<Nullable<signed char>,Nullable<signed char>,Nullable<signed char>>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<Nullable<signed char>> types.
/// </summary>
static Expr<Nullable<signed char>> operator-(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
{
return Expr<Nullable<signed char>>(gcnew BinaryExpression<Nullable<signed char>,Nullable<signed char>,Nullable<signed char>>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<Nullable<signed char>> types.
/// </summary>
static Expr<bool> operator==(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<signed char>,Nullable<signed char>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<Nullable<signed char>> types.
/// </summary>
static Expr<bool> operator!=(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<signed char>,Nullable<signed char>>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<Nullable<signed char>> types.
/// </summary>
static Expr<bool> operator<(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<signed char>,Nullable<signed char>>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<Nullable<signed char>> types.
/// </summary>
static Expr<bool> operator>(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<signed char>,Nullable<signed char>>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<Nullable<signed char>> types.
/// </summary>
static Expr<bool> operator<=(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<signed char>,Nullable<signed char>>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<Nullable<signed char>> types.
/// </summary>
static Expr<bool> operator>=(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,Nullable<signed char>,Nullable<signed char>>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'double' expresion. Supports standard math and comparison operators.
/// </summary>
template<> public ref class Expr<double> : ExpressionWrapper<double>
{
public:
static property Type^ WrappedType { Type^ get() { return double::typeid; } }
public:
Expr<double>() { }
Expr<double>(double val) { _value = gcnew Literal<double>(val); }
Expr<double>(Expression<double>^ value) { _value = value; }
Expr<double>(Expr<double>% b) { _value = b._value; }
operator Expression<double>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<double>(Expression<double>^ value) { return Expr<double>(value); }
static operator Expr<double>(double b) { return Expr<double>(b); }
public:
static Expr<double> Typed(GenericExpression^ value)
{
return Expr<double>(gcnew TypedExpression<double>(value));
}
static Expr<double> Convert(GenericExpression^ value)
{
return Expr<double>(gcnew ConvertExpression<double>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<double> types.
/// </summary>
static Expr<double> operator+(Expr<double> left, Expr<double> right)
{
return Expr<double>(gcnew BinaryExpression<double,double,double>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<double> types.
/// </summary>
static Expr<double> operator*(Expr<double> left, Expr<double> right)
{
return Expr<double>(gcnew BinaryExpression<double,double,double>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<double> types.
/// </summary>
static Expr<double> operator/(Expr<double> left, Expr<double> right)
{
return Expr<double>(gcnew BinaryExpression<double,double,double>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<double> types.
/// </summary>
static Expr<double> operator-(Expr<double> left, Expr<double> right)
{
return Expr<double>(gcnew BinaryExpression<double,double,double>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<double> types.
/// </summary>
static Expr<bool> operator==(Expr<double> left, Expr<double> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,double,double>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<double> types.
/// </summary>
static Expr<bool> operator!=(Expr<double> left, Expr<double> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,double,double>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<double> types.
/// </summary>
static Expr<bool> operator<(Expr<double> left, Expr<double> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,double,double>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<double> types.
/// </summary>
static Expr<bool> operator>(Expr<double> left, Expr<double> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,double,double>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<double> types.
/// </summary>
static Expr<bool> operator<=(Expr<double> left, Expr<double> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,double,double>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<double> types.
/// </summary>
static Expr<bool> operator>=(Expr<double> left, Expr<double> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,double,double>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'float' expresion. Supports standard math and comparison operators.
/// </summary>
template<> public ref class Expr<float> : ExpressionWrapper<float>
{
public:
static property Type^ WrappedType { Type^ get() { return float::typeid; } }
public:
Expr<float>() { }
Expr<float>(float val) { _value = gcnew Literal<float>(val); }
Expr<float>(Expression<float>^ value) { _value = value; }
Expr<float>(Expr<float>% b) { _value = b._value; }
operator Expression<float>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<float>(Expression<float>^ value) { return Expr<float>(value); }
static operator Expr<float>(float b) { return Expr<float>(b); }
operator Expr<double>() { return Expr<double>::Convert(_value); }
public:
static Expr<float> Typed(GenericExpression^ value)
{
return Expr<float>(gcnew TypedExpression<float>(value));
}
static Expr<float> Convert(GenericExpression^ value)
{
return Expr<float>(gcnew ConvertExpression<float>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<float> types.
/// </summary>
static Expr<float> operator+(Expr<float> left, Expr<float> right)
{
return Expr<float>(gcnew BinaryExpression<float,float,float>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<float> types.
/// </summary>
static Expr<float> operator*(Expr<float> left, Expr<float> right)
{
return Expr<float>(gcnew BinaryExpression<float,float,float>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<float> types.
/// </summary>
static Expr<float> operator/(Expr<float> left, Expr<float> right)
{
return Expr<float>(gcnew BinaryExpression<float,float,float>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<float> types.
/// </summary>
static Expr<float> operator-(Expr<float> left, Expr<float> right)
{
return Expr<float>(gcnew BinaryExpression<float,float,float>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<float> types.
/// </summary>
static Expr<bool> operator==(Expr<float> left, Expr<float> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,float,float>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<float> types.
/// </summary>
static Expr<bool> operator!=(Expr<float> left, Expr<float> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,float,float>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<float> types.
/// </summary>
static Expr<bool> operator<(Expr<float> left, Expr<float> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,float,float>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<float> types.
/// </summary>
static Expr<bool> operator>(Expr<float> left, Expr<float> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,float,float>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<float> types.
/// </summary>
static Expr<bool> operator<=(Expr<float> left, Expr<float> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,float,float>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<float> types.
/// </summary>
static Expr<bool> operator>=(Expr<float> left, Expr<float> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,float,float>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'System::Decimal' expresion. Supports standard math and comparison operators.
/// </summary>
template<> public ref class Expr<System::Decimal> : ExpressionWrapper<System::Decimal>
{
public:
static property Type^ WrappedType { Type^ get() { return System::Decimal::typeid; } }
public:
Expr<System::Decimal>() { }
Expr<System::Decimal>(System::Decimal val) { _value = gcnew Literal<System::Decimal>(val); }
Expr<System::Decimal>(Expression<System::Decimal>^ value) { _value = value; }
Expr<System::Decimal>(Expr<System::Decimal>% b) { _value = b._value; }
operator Expression<System::Decimal>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<System::Decimal>(Expression<System::Decimal>^ value) { return Expr<System::Decimal>(value); }
static operator Expr<System::Decimal>(System::Decimal b) { return Expr<System::Decimal>(b); }
public:
static Expr<System::Decimal> Typed(GenericExpression^ value)
{
return Expr<System::Decimal>(gcnew TypedExpression<System::Decimal>(value));
}
static Expr<System::Decimal> Convert(GenericExpression^ value)
{
return Expr<System::Decimal>(gcnew ConvertExpression<System::Decimal>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<System::Decimal> types.
/// </summary>
static Expr<System::Decimal> operator+(Expr<System::Decimal> left, Expr<System::Decimal> right)
{
return Expr<System::Decimal>(gcnew BinaryExpression<System::Decimal,System::Decimal,System::Decimal>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<System::Decimal> types.
/// </summary>
static Expr<System::Decimal> operator*(Expr<System::Decimal> left, Expr<System::Decimal> right)
{
return Expr<System::Decimal>(gcnew BinaryExpression<System::Decimal,System::Decimal,System::Decimal>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<System::Decimal> types.
/// </summary>
static Expr<System::Decimal> operator/(Expr<System::Decimal> left, Expr<System::Decimal> right)
{
return Expr<System::Decimal>(gcnew BinaryExpression<System::Decimal,System::Decimal,System::Decimal>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<System::Decimal> types.
/// </summary>
static Expr<System::Decimal> operator-(Expr<System::Decimal> left, Expr<System::Decimal> right)
{
return Expr<System::Decimal>(gcnew BinaryExpression<System::Decimal,System::Decimal,System::Decimal>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<System::Decimal> types.
/// </summary>
static Expr<bool> operator==(Expr<System::Decimal> left, Expr<System::Decimal> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,System::Decimal,System::Decimal>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<System::Decimal> types.
/// </summary>
static Expr<bool> operator!=(Expr<System::Decimal> left, Expr<System::Decimal> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,System::Decimal,System::Decimal>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<System::Decimal> types.
/// </summary>
static Expr<bool> operator<(Expr<System::Decimal> left, Expr<System::Decimal> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,System::Decimal,System::Decimal>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<System::Decimal> types.
/// </summary>
static Expr<bool> operator>(Expr<System::Decimal> left, Expr<System::Decimal> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,System::Decimal,System::Decimal>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<System::Decimal> types.
/// </summary>
static Expr<bool> operator<=(Expr<System::Decimal> left, Expr<System::Decimal> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,System::Decimal,System::Decimal>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<System::Decimal> types.
/// </summary>
static Expr<bool> operator>=(Expr<System::Decimal> left, Expr<System::Decimal> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,System::Decimal,System::Decimal>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'long long int' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<long long int> : ExpressionWrapper<long long int>
{
public:
static property Type^ WrappedType { Type^ get() { return long long int::typeid; } }
public:
Expr<long long int>() { }
Expr<long long int>(long long int val) { _value = gcnew Literal<long long int>(val); }
Expr<long long int>(Expression<long long int>^ value) { _value = value; }
Expr<long long int>(Expr<long long int>% b) { _value = b._value; }
operator Expression<long long int>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<long long int>(Expression<long long int>^ value) { return Expr<long long int>(value); }
static operator Expr<long long int>(long long int b) { return Expr<long long int>(b); }
public:
static Expr<long long int> Typed(GenericExpression^ value)
{
return Expr<long long int>(gcnew TypedExpression<long long int>(value));
}
static Expr<long long int> Convert(GenericExpression^ value)
{
return Expr<long long int>(gcnew ConvertExpression<long long int>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<long long int> types.
/// </summary>
static Expr<long long int> operator+(Expr<long long int> left, Expr<long long int> right)
{
return Expr<long long int>(gcnew BinaryExpression<long long int,long long int,long long int>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<long long int> types.
/// </summary>
static Expr<long long int> operator*(Expr<long long int> left, Expr<long long int> right)
{
return Expr<long long int>(gcnew BinaryExpression<long long int,long long int,long long int>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<long long int> types.
/// </summary>
static Expr<long long int> operator/(Expr<long long int> left, Expr<long long int> right)
{
return Expr<long long int>(gcnew BinaryExpression<long long int,long long int,long long int>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<long long int> types.
/// </summary>
static Expr<long long int> operator-(Expr<long long int> left, Expr<long long int> right)
{
return Expr<long long int>(gcnew BinaryExpression<long long int,long long int,long long int>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<long long int> types.
/// </summary>
static Expr<bool> operator==(Expr<long long int> left, Expr<long long int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,long long int,long long int>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<long long int> types.
/// </summary>
static Expr<bool> operator!=(Expr<long long int> left, Expr<long long int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,long long int,long long int>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<long long int> types.
/// </summary>
static Expr<bool> operator<(Expr<long long int> left, Expr<long long int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,long long int,long long int>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<long long int> types.
/// </summary>
static Expr<bool> operator>(Expr<long long int> left, Expr<long long int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,long long int,long long int>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<long long int> types.
/// </summary>
static Expr<bool> operator<=(Expr<long long int> left, Expr<long long int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,long long int,long long int>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<long long int> types.
/// </summary>
static Expr<bool> operator>=(Expr<long long int> left, Expr<long long int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,long long int,long long int>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'unsigned long long int' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<unsigned long long int> : ExpressionWrapper<unsigned long long int>
{
public:
static property Type^ WrappedType { Type^ get() { return unsigned long long int::typeid; } }
public:
Expr<unsigned long long int>() { }
Expr<unsigned long long int>(unsigned long long int val) { _value = gcnew Literal<unsigned long long int>(val); }
Expr<unsigned long long int>(Expression<unsigned long long int>^ value) { _value = value; }
Expr<unsigned long long int>(Expr<unsigned long long int>% b) { _value = b._value; }
operator Expression<unsigned long long int>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<unsigned long long int>(Expression<unsigned long long int>^ value) { return Expr<unsigned long long int>(value); }
static operator Expr<unsigned long long int>(unsigned long long int b) { return Expr<unsigned long long int>(b); }
public:
static Expr<unsigned long long int> Typed(GenericExpression^ value)
{
return Expr<unsigned long long int>(gcnew TypedExpression<unsigned long long int>(value));
}
static Expr<unsigned long long int> Convert(GenericExpression^ value)
{
return Expr<unsigned long long int>(gcnew ConvertExpression<unsigned long long int>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<unsigned long long int> types.
/// </summary>
static Expr<unsigned long long int> operator+(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
{
return Expr<unsigned long long int>(gcnew BinaryExpression<unsigned long long int,unsigned long long int,unsigned long long int>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<unsigned long long int> types.
/// </summary>
static Expr<unsigned long long int> operator*(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
{
return Expr<unsigned long long int>(gcnew BinaryExpression<unsigned long long int,unsigned long long int,unsigned long long int>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<unsigned long long int> types.
/// </summary>
static Expr<unsigned long long int> operator/(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
{
return Expr<unsigned long long int>(gcnew BinaryExpression<unsigned long long int,unsigned long long int,unsigned long long int>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<unsigned long long int> types.
/// </summary>
static Expr<unsigned long long int> operator-(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
{
return Expr<unsigned long long int>(gcnew BinaryExpression<unsigned long long int,unsigned long long int,unsigned long long int>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<unsigned long long int> types.
/// </summary>
static Expr<bool> operator==(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned long long int,unsigned long long int>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<unsigned long long int> types.
/// </summary>
static Expr<bool> operator!=(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned long long int,unsigned long long int>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<unsigned long long int> types.
/// </summary>
static Expr<bool> operator<(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned long long int,unsigned long long int>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<unsigned long long int> types.
/// </summary>
static Expr<bool> operator>(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned long long int,unsigned long long int>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<unsigned long long int> types.
/// </summary>
static Expr<bool> operator<=(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned long long int,unsigned long long int>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<unsigned long long int> types.
/// </summary>
static Expr<bool> operator>=(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned long long int,unsigned long long int>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'int' expresion. Supports standard math and comparison operators (including modulo and shifts).
/// </summary>
template<> public ref class Expr<int> : ExpressionWrapper<int>
{
public:
static property Type^ WrappedType { Type^ get() { return int::typeid; } }
public:
Expr<int>() { }
Expr<int>(int val) { _value = gcnew Literal<int>(val); }
Expr<int>(Expression<int>^ value) { _value = value; }
Expr<int>(Expr<int>% b) { _value = b._value; }
operator Expression<int>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<int>(Expression<int>^ value) { return Expr<int>(value); }
static operator Expr<int>(int b) { return Expr<int>(b); }
operator Expr<long long int>() { return Expr<long long int>::Convert(_value); }
operator Expr<unsigned long long int>() { return Expr<unsigned long long int>::Convert(_value); }
public:
static Expr<int> Typed(GenericExpression^ value)
{
return Expr<int>(gcnew TypedExpression<int>(value));
}
static Expr<int> Convert(GenericExpression^ value)
{
return Expr<int>(gcnew ConvertExpression<int>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<int> types.
/// </summary>
static Expr<int> operator+(Expr<int> left, Expr<int> right)
{
return Expr<int>(gcnew BinaryExpression<int,int,int>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<int> types.
/// </summary>
static Expr<int> operator*(Expr<int> left, Expr<int> right)
{
return Expr<int>(gcnew BinaryExpression<int,int,int>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<int> types.
/// </summary>
static Expr<int> operator/(Expr<int> left, Expr<int> right)
{
return Expr<int>(gcnew BinaryExpression<int,int,int>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<int> types.
/// </summary>
static Expr<int> operator-(Expr<int> left, Expr<int> right)
{
return Expr<int>(gcnew BinaryExpression<int,int,int>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<int> types.
/// </summary>
static Expr<bool> operator==(Expr<int> left, Expr<int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,int,int>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<int> types.
/// </summary>
static Expr<bool> operator!=(Expr<int> left, Expr<int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,int,int>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<int> types.
/// </summary>
static Expr<bool> operator<(Expr<int> left, Expr<int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,int,int>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<int> types.
/// </summary>
static Expr<bool> operator>(Expr<int> left, Expr<int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,int,int>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<int> types.
/// </summary>
static Expr<bool> operator<=(Expr<int> left, Expr<int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,int,int>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<int> types.
/// </summary>
static Expr<bool> operator>=(Expr<int> left, Expr<int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,int,int>
(left, right, System::Expressions::ExpressionType::GE));
}
/// <summary>
/// Shift left operator for tuple of Expr<int> types.
/// </summary>
static Expr<int> operator<<(Expr<int> left, Expr<int> right)
{
return Expr<int>(gcnew BinaryExpression<int,int,int>
(left, right, System::Expressions::ExpressionType::LShift));
}
/// <summary>
/// Shift right operator for tuple of Expr<int> types.
/// </summary>
static Expr<int> operator>>(Expr<int> left, Expr<int> right)
{
return Expr<int>(gcnew BinaryExpression<int,int,int>
(left, right, System::Expressions::ExpressionType::RShift));
}
public:
};
/// <summary>
/// Template specialization for the 'unsigned int' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<unsigned int> : ExpressionWrapper<unsigned int>
{
public:
static property Type^ WrappedType { Type^ get() { return unsigned int::typeid; } }
public:
Expr<unsigned int>() { }
Expr<unsigned int>(unsigned int val) { _value = gcnew Literal<unsigned int>(val); }
Expr<unsigned int>(Expression<unsigned int>^ value) { _value = value; }
Expr<unsigned int>(Expr<unsigned int>% b) { _value = b._value; }
operator Expression<unsigned int>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<unsigned int>(Expression<unsigned int>^ value) { return Expr<unsigned int>(value); }
static operator Expr<unsigned int>(unsigned int b) { return Expr<unsigned int>(b); }
operator Expr<long long int>() { return Expr<long long int>::Convert(_value); }
operator Expr<unsigned long long int>() { return Expr<unsigned long long int>::Convert(_value); }
public:
static Expr<unsigned int> Typed(GenericExpression^ value)
{
return Expr<unsigned int>(gcnew TypedExpression<unsigned int>(value));
}
static Expr<unsigned int> Convert(GenericExpression^ value)
{
return Expr<unsigned int>(gcnew ConvertExpression<unsigned int>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<unsigned int> types.
/// </summary>
static Expr<unsigned int> operator+(Expr<unsigned int> left, Expr<unsigned int> right)
{
return Expr<unsigned int>(gcnew BinaryExpression<unsigned int,unsigned int,unsigned int>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<unsigned int> types.
/// </summary>
static Expr<unsigned int> operator*(Expr<unsigned int> left, Expr<unsigned int> right)
{
return Expr<unsigned int>(gcnew BinaryExpression<unsigned int,unsigned int,unsigned int>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<unsigned int> types.
/// </summary>
static Expr<unsigned int> operator/(Expr<unsigned int> left, Expr<unsigned int> right)
{
return Expr<unsigned int>(gcnew BinaryExpression<unsigned int,unsigned int,unsigned int>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<unsigned int> types.
/// </summary>
static Expr<unsigned int> operator-(Expr<unsigned int> left, Expr<unsigned int> right)
{
return Expr<unsigned int>(gcnew BinaryExpression<unsigned int,unsigned int,unsigned int>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<unsigned int> types.
/// </summary>
static Expr<bool> operator==(Expr<unsigned int> left, Expr<unsigned int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned int,unsigned int>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<unsigned int> types.
/// </summary>
static Expr<bool> operator!=(Expr<unsigned int> left, Expr<unsigned int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned int,unsigned int>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<unsigned int> types.
/// </summary>
static Expr<bool> operator<(Expr<unsigned int> left, Expr<unsigned int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned int,unsigned int>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<unsigned int> types.
/// </summary>
static Expr<bool> operator>(Expr<unsigned int> left, Expr<unsigned int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned int,unsigned int>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<unsigned int> types.
/// </summary>
static Expr<bool> operator<=(Expr<unsigned int> left, Expr<unsigned int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned int,unsigned int>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<unsigned int> types.
/// </summary>
static Expr<bool> operator>=(Expr<unsigned int> left, Expr<unsigned int> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned int,unsigned int>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'short' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<short> : ExpressionWrapper<short>
{
public:
static property Type^ WrappedType { Type^ get() { return short::typeid; } }
public:
Expr<short>() { }
Expr<short>(short val) { _value = gcnew Literal<short>(val); }
Expr<short>(Expression<short>^ value) { _value = value; }
Expr<short>(Expr<short>% b) { _value = b._value; }
operator Expression<short>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<short>(Expression<short>^ value) { return Expr<short>(value); }
static operator Expr<short>(short b) { return Expr<short>(b); }
operator Expr<long long int>() { return Expr<long long int>::Convert(_value); }
operator Expr<unsigned long long int>() { return Expr<unsigned long long int>::Convert(_value); }
operator Expr<int>() { return Expr<int>::Convert(_value); }
operator Expr<unsigned int>() { return Expr<unsigned int>::Convert(_value); }
public:
static Expr<short> Typed(GenericExpression^ value)
{
return Expr<short>(gcnew TypedExpression<short>(value));
}
static Expr<short> Convert(GenericExpression^ value)
{
return Expr<short>(gcnew ConvertExpression<short>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<short> types.
/// </summary>
static Expr<short> operator+(Expr<short> left, Expr<short> right)
{
return Expr<short>(gcnew BinaryExpression<short,short,short>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<short> types.
/// </summary>
static Expr<short> operator*(Expr<short> left, Expr<short> right)
{
return Expr<short>(gcnew BinaryExpression<short,short,short>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<short> types.
/// </summary>
static Expr<short> operator/(Expr<short> left, Expr<short> right)
{
return Expr<short>(gcnew BinaryExpression<short,short,short>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<short> types.
/// </summary>
static Expr<short> operator-(Expr<short> left, Expr<short> right)
{
return Expr<short>(gcnew BinaryExpression<short,short,short>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<short> types.
/// </summary>
static Expr<bool> operator==(Expr<short> left, Expr<short> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,short,short>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<short> types.
/// </summary>
static Expr<bool> operator!=(Expr<short> left, Expr<short> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,short,short>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<short> types.
/// </summary>
static Expr<bool> operator<(Expr<short> left, Expr<short> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,short,short>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<short> types.
/// </summary>
static Expr<bool> operator>(Expr<short> left, Expr<short> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,short,short>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<short> types.
/// </summary>
static Expr<bool> operator<=(Expr<short> left, Expr<short> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,short,short>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<short> types.
/// </summary>
static Expr<bool> operator>=(Expr<short> left, Expr<short> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,short,short>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'unsigned short' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<unsigned short> : ExpressionWrapper<unsigned short>
{
public:
static property Type^ WrappedType { Type^ get() { return unsigned short::typeid; } }
public:
Expr<unsigned short>() { }
Expr<unsigned short>(unsigned short val) { _value = gcnew Literal<unsigned short>(val); }
Expr<unsigned short>(Expression<unsigned short>^ value) { _value = value; }
Expr<unsigned short>(Expr<unsigned short>% b) { _value = b._value; }
operator Expression<unsigned short>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<unsigned short>(Expression<unsigned short>^ value) { return Expr<unsigned short>(value); }
static operator Expr<unsigned short>(unsigned short b) { return Expr<unsigned short>(b); }
operator Expr<long long int>() { return Expr<long long int>::Convert(_value); }
operator Expr<unsigned long long int>() { return Expr<unsigned long long int>::Convert(_value); }
operator Expr<int>() { return Expr<int>::Convert(_value); }
operator Expr<unsigned int>() { return Expr<unsigned int>::Convert(_value); }
public:
static Expr<unsigned short> Typed(GenericExpression^ value)
{
return Expr<unsigned short>(gcnew TypedExpression<unsigned short>(value));
}
static Expr<unsigned short> Convert(GenericExpression^ value)
{
return Expr<unsigned short>(gcnew ConvertExpression<unsigned short>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<unsigned short> types.
/// </summary>
static Expr<unsigned short> operator+(Expr<unsigned short> left, Expr<unsigned short> right)
{
return Expr<unsigned short>(gcnew BinaryExpression<unsigned short,unsigned short,unsigned short>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<unsigned short> types.
/// </summary>
static Expr<unsigned short> operator*(Expr<unsigned short> left, Expr<unsigned short> right)
{
return Expr<unsigned short>(gcnew BinaryExpression<unsigned short,unsigned short,unsigned short>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<unsigned short> types.
/// </summary>
static Expr<unsigned short> operator/(Expr<unsigned short> left, Expr<unsigned short> right)
{
return Expr<unsigned short>(gcnew BinaryExpression<unsigned short,unsigned short,unsigned short>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<unsigned short> types.
/// </summary>
static Expr<unsigned short> operator-(Expr<unsigned short> left, Expr<unsigned short> right)
{
return Expr<unsigned short>(gcnew BinaryExpression<unsigned short,unsigned short,unsigned short>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<unsigned short> types.
/// </summary>
static Expr<bool> operator==(Expr<unsigned short> left, Expr<unsigned short> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned short,unsigned short>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<unsigned short> types.
/// </summary>
static Expr<bool> operator!=(Expr<unsigned short> left, Expr<unsigned short> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned short,unsigned short>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<unsigned short> types.
/// </summary>
static Expr<bool> operator<(Expr<unsigned short> left, Expr<unsigned short> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned short,unsigned short>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<unsigned short> types.
/// </summary>
static Expr<bool> operator>(Expr<unsigned short> left, Expr<unsigned short> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned short,unsigned short>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<unsigned short> types.
/// </summary>
static Expr<bool> operator<=(Expr<unsigned short> left, Expr<unsigned short> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned short,unsigned short>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<unsigned short> types.
/// </summary>
static Expr<bool> operator>=(Expr<unsigned short> left, Expr<unsigned short> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned short,unsigned short>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'unsigned char' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<unsigned char> : ExpressionWrapper<unsigned char>
{
public:
static property Type^ WrappedType { Type^ get() { return unsigned char::typeid; } }
public:
Expr<unsigned char>() { }
Expr<unsigned char>(unsigned char val) { _value = gcnew Literal<unsigned char>(val); }
Expr<unsigned char>(Expression<unsigned char>^ value) { _value = value; }
Expr<unsigned char>(Expr<unsigned char>% b) { _value = b._value; }
operator Expression<unsigned char>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<unsigned char>(Expression<unsigned char>^ value) { return Expr<unsigned char>(value); }
static operator Expr<unsigned char>(unsigned char b) { return Expr<unsigned char>(b); }
operator Expr<long long int>() { return Expr<long long int>::Convert(_value); }
operator Expr<unsigned long long int>() { return Expr<unsigned long long int>::Convert(_value); }
operator Expr<int>() { return Expr<int>::Convert(_value); }
operator Expr<unsigned int>() { return Expr<unsigned int>::Convert(_value); }
operator Expr<short>() { return Expr<short>::Convert(_value); }
operator Expr<unsigned short>() { return Expr<unsigned short>::Convert(_value); }
public:
static Expr<unsigned char> Typed(GenericExpression^ value)
{
return Expr<unsigned char>(gcnew TypedExpression<unsigned char>(value));
}
static Expr<unsigned char> Convert(GenericExpression^ value)
{
return Expr<unsigned char>(gcnew ConvertExpression<unsigned char>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<unsigned char> types.
/// </summary>
static Expr<unsigned char> operator+(Expr<unsigned char> left, Expr<unsigned char> right)
{
return Expr<unsigned char>(gcnew BinaryExpression<unsigned char,unsigned char,unsigned char>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<unsigned char> types.
/// </summary>
static Expr<unsigned char> operator*(Expr<unsigned char> left, Expr<unsigned char> right)
{
return Expr<unsigned char>(gcnew BinaryExpression<unsigned char,unsigned char,unsigned char>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<unsigned char> types.
/// </summary>
static Expr<unsigned char> operator/(Expr<unsigned char> left, Expr<unsigned char> right)
{
return Expr<unsigned char>(gcnew BinaryExpression<unsigned char,unsigned char,unsigned char>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<unsigned char> types.
/// </summary>
static Expr<unsigned char> operator-(Expr<unsigned char> left, Expr<unsigned char> right)
{
return Expr<unsigned char>(gcnew BinaryExpression<unsigned char,unsigned char,unsigned char>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<unsigned char> types.
/// </summary>
static Expr<bool> operator==(Expr<unsigned char> left, Expr<unsigned char> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned char,unsigned char>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<unsigned char> types.
/// </summary>
static Expr<bool> operator!=(Expr<unsigned char> left, Expr<unsigned char> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned char,unsigned char>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<unsigned char> types.
/// </summary>
static Expr<bool> operator<(Expr<unsigned char> left, Expr<unsigned char> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned char,unsigned char>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<unsigned char> types.
/// </summary>
static Expr<bool> operator>(Expr<unsigned char> left, Expr<unsigned char> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned char,unsigned char>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<unsigned char> types.
/// </summary>
static Expr<bool> operator<=(Expr<unsigned char> left, Expr<unsigned char> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned char,unsigned char>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<unsigned char> types.
/// </summary>
static Expr<bool> operator>=(Expr<unsigned char> left, Expr<unsigned char> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,unsigned char,unsigned char>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'signed char' expresion. Supports standard math and comparison operators (including modulo).
/// </summary>
template<> public ref class Expr<signed char> : ExpressionWrapper<signed char>
{
public:
static property Type^ WrappedType { Type^ get() { return signed char::typeid; } }
public:
Expr<signed char>() { }
Expr<signed char>(signed char val) { _value = gcnew Literal<signed char>(val); }
Expr<signed char>(Expression<signed char>^ value) { _value = value; }
Expr<signed char>(Expr<signed char>% b) { _value = b._value; }
operator Expression<signed char>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<signed char>(Expression<signed char>^ value) { return Expr<signed char>(value); }
static operator Expr<signed char>(signed char b) { return Expr<signed char>(b); }
operator Expr<long long int>() { return Expr<long long int>::Convert(_value); }
operator Expr<unsigned long long int>() { return Expr<unsigned long long int>::Convert(_value); }
operator Expr<int>() { return Expr<int>::Convert(_value); }
operator Expr<unsigned int>() { return Expr<unsigned int>::Convert(_value); }
operator Expr<short>() { return Expr<short>::Convert(_value); }
operator Expr<unsigned short>() { return Expr<unsigned short>::Convert(_value); }
public:
static Expr<signed char> Typed(GenericExpression^ value)
{
return Expr<signed char>(gcnew TypedExpression<signed char>(value));
}
static Expr<signed char> Convert(GenericExpression^ value)
{
return Expr<signed char>(gcnew ConvertExpression<signed char>(value));
}
public:
/// <summary>
/// Addition operator for tuple of Expr<signed char> types.
/// </summary>
static Expr<signed char> operator+(Expr<signed char> left, Expr<signed char> right)
{
return Expr<signed char>(gcnew BinaryExpression<signed char,signed char,signed char>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// Multiplication operator for tuple of Expr<signed char> types.
/// </summary>
static Expr<signed char> operator*(Expr<signed char> left, Expr<signed char> right)
{
return Expr<signed char>(gcnew BinaryExpression<signed char,signed char,signed char>
(left, right, System::Expressions::ExpressionType::Multiply));
}
/// <summary>
/// Division operator for tuple of Expr<signed char> types.
/// </summary>
static Expr<signed char> operator/(Expr<signed char> left, Expr<signed char> right)
{
return Expr<signed char>(gcnew BinaryExpression<signed char,signed char,signed char>
(left, right, System::Expressions::ExpressionType::Divide));
}
/// <summary>
/// Subtraction operator for tuple of Expr<signed char> types.
/// </summary>
static Expr<signed char> operator-(Expr<signed char> left, Expr<signed char> right)
{
return Expr<signed char>(gcnew BinaryExpression<signed char,signed char,signed char>
(left, right, System::Expressions::ExpressionType::Subtract));
}
/// <summary>
/// comparison operator for tuple of Expr<signed char> types.
/// </summary>
static Expr<bool> operator==(Expr<signed char> left, Expr<signed char> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,signed char,signed char>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<signed char> types.
/// </summary>
static Expr<bool> operator!=(Expr<signed char> left, Expr<signed char> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,signed char,signed char>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Less than operator for tuple of Expr<signed char> types.
/// </summary>
static Expr<bool> operator<(Expr<signed char> left, Expr<signed char> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,signed char,signed char>
(left, right, System::Expressions::ExpressionType::LT));
}
/// <summary>
/// Greather than operator for tuple of Expr<signed char> types.
/// </summary>
static Expr<bool> operator>(Expr<signed char> left, Expr<signed char> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,signed char,signed char>
(left, right, System::Expressions::ExpressionType::GT));
}
/// <summary>
/// Less or equals operator for tuple of Expr<signed char> types.
/// </summary>
static Expr<bool> operator<=(Expr<signed char> left, Expr<signed char> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,signed char,signed char>
(left, right, System::Expressions::ExpressionType::LE));
}
/// <summary>
/// Greather or equals than operator for tuple of Expr<signed char> types.
/// </summary>
static Expr<bool> operator>=(Expr<signed char> left, Expr<signed char> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,signed char,signed char>
(left, right, System::Expressions::ExpressionType::GE));
}
public:
};
/// <summary>
/// Template specialization for the 'wchar_t' expresion. Supports comparison operators.
/// </summary>
template<> public ref class Expr<wchar_t> : ExpressionWrapper<wchar_t>
{
public:
static property Type^ WrappedType { Type^ get() { return wchar_t::typeid; } }
public:
Expr<wchar_t>() { }
Expr<wchar_t>(wchar_t val) { _value = gcnew Literal<wchar_t>(val); }
Expr<wchar_t>(Expression<wchar_t>^ value) { _value = value; }
Expr<wchar_t>(Expr<wchar_t>% b) { _value = b._value; }
operator Expression<wchar_t>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<wchar_t>(Expression<wchar_t>^ value) { return Expr<wchar_t>(value); }
static operator Expr<wchar_t>(wchar_t b) { return Expr<wchar_t>(b); }
public:
static Expr<wchar_t> Typed(GenericExpression^ value)
{
return Expr<wchar_t>(gcnew TypedExpression<wchar_t>(value));
}
static Expr<wchar_t> Convert(GenericExpression^ value)
{
return Expr<wchar_t>(gcnew ConvertExpression<wchar_t>(value));
}
public:
/// <summary>
/// Test values for equality.
/// </summary>
static Expr<bool> operator==(Expr<wchar_t> left, Expr<wchar_t> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,wchar_t,wchar_t>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Test values for inequality.
/// </summary>
static Expr<bool> operator!=(Expr<wchar_t> left, Expr<wchar_t> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,wchar_t,wchar_t>
(left, right, System::Expressions::ExpressionType::NE));
}
public:
};
/// <summary>
/// Template specialization for the 'String^' expresion. Support standard string operators and methods.
/// </summary>
template<> public ref class Expr<String^> : ExpressionWrapper<String^>
{
public:
static property Type^ WrappedType { Type^ get() { return String::typeid; } }
public:
Expr<String^>() { }
Expr<String^>(String^ val) { _value = gcnew Literal<String^>(val); }
Expr<String^>(Expression<String^>^ value) { _value = value; }
Expr<String^>(Expr<String^>% b) { _value = b._value; }
operator Expression<String^>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<String^>(Expression<String^>^ value) { return Expr<String^>(value); }
static operator Expr<String^>(String^ b) { return Expr<String^>(b); }
public:
static Expr<String^> Typed(GenericExpression^ value)
{
return Expr<String^>(gcnew TypedExpression<String^>(value));
}
static Expr<String^> Convert(GenericExpression^ value)
{
return Expr<String^>(gcnew ConvertExpression<String^>(value));
}
public:
/// <summary>
/// Operator for string concatenation.
/// </summary>
static Expr<String^> operator+(Expr<String^> left, Expr<String^> right)
{
return Expr<String^>(gcnew BinaryExpression<String^,String^,String^>
(left, right, System::Expressions::ExpressionType::Add));
}
/// <summary>
/// comparison operator for tuple of Expr<String^> types.
/// </summary>
static Expr<bool> operator==(Expr<String^> left, Expr<String^> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,String^,String^>
(left, right, System::Expressions::ExpressionType::EQ));
}
/// <summary>
/// Inequallity operator for tuple of Expr<String^> types.
/// </summary>
static Expr<bool> operator!=(Expr<String^> left, Expr<String^> right)
{
return Expr<bool>(gcnew BinaryExpression<bool,String^,String^>
(left, right, System::Expressions::ExpressionType::NE));
}
public:
private:
static MethodInfo^ __Substring_Expr_int_;
static property MethodInfo^ _Substring_Expr_int_ {
MethodInfo^ get() { if (__Substring_Expr_int_ == nullptr)
__Substring_Expr_int_ = (String::typeid)->GetMethod("Substring", gcnew array<Type^>{ Expr<int>::WrappedType }); return __Substring_Expr_int_;
} }
public:
/// <summary>
/// Retrieves a substring from this instance.
/// </summary>
Expr<String^> Substring(Expr<int> startIndex)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_Substring_Expr_int_, this, gcnew array<GenericExpression^>{startIndex}));
}
private:
static MethodInfo^ __Substring_Expr_int__Expr_int_;
static property MethodInfo^ _Substring_Expr_int__Expr_int_ {
MethodInfo^ get() { if (__Substring_Expr_int__Expr_int_ == nullptr)
__Substring_Expr_int__Expr_int_ = (String::typeid)->GetMethod("Substring", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<int>::WrappedType }); return __Substring_Expr_int__Expr_int_;
} }
public:
/// <summary>
/// Retrieves a substring from this instance.
/// </summary>
Expr<String^> Substring(Expr<int> startIndex, Expr<int> length)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_Substring_Expr_int__Expr_int_, this, gcnew array<GenericExpression^>{startIndex, length}));
}
private:
static MethodInfo^ __Contains_Expr_String__;
static property MethodInfo^ _Contains_Expr_String__ {
MethodInfo^ get() { if (__Contains_Expr_String__ == nullptr)
__Contains_Expr_String__ = (String::typeid)->GetMethod("Contains", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __Contains_Expr_String__;
} }
public:
/// <summary>
/// Returns a value indicating whether the specified String object occurs within this string.
/// </summary>
Expr<bool> Contains(Expr<String^> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_Contains_Expr_String__, this, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __StartsWith_Expr_String__;
static property MethodInfo^ _StartsWith_Expr_String__ {
MethodInfo^ get() { if (__StartsWith_Expr_String__ == nullptr)
__StartsWith_Expr_String__ = (String::typeid)->GetMethod("StartsWith", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __StartsWith_Expr_String__;
} }
public:
/// <summary>
/// Determines whether the beginning of an instance of String matches a specified string.
/// </summary>
Expr<bool> StartsWith(Expr<String^> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_StartsWith_Expr_String__, this, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __EndsWith_Expr_String__;
static property MethodInfo^ _EndsWith_Expr_String__ {
MethodInfo^ get() { if (__EndsWith_Expr_String__ == nullptr)
__EndsWith_Expr_String__ = (String::typeid)->GetMethod("EndsWith", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __EndsWith_Expr_String__;
} }
public:
/// <summary>
/// Determines whether the end of an instance of String matches a specified string.
/// </summary>
Expr<bool> EndsWith(Expr<String^> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_EndsWith_Expr_String__, this, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __IndexOf_Expr_wchar_t_;
static property MethodInfo^ _IndexOf_Expr_wchar_t_ {
MethodInfo^ get() { if (__IndexOf_Expr_wchar_t_ == nullptr)
__IndexOf_Expr_wchar_t_ = (String::typeid)->GetMethod("IndexOf", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __IndexOf_Expr_wchar_t_;
} }
public:
/// <summary>
/// Reports the index of the first occurrence of a String, or one or more characters, within this string.
/// </summary>
Expr<int> IndexOf(Expr<wchar_t> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_IndexOf_Expr_wchar_t_, this, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __IndexOf_Expr_String__;
static property MethodInfo^ _IndexOf_Expr_String__ {
MethodInfo^ get() { if (__IndexOf_Expr_String__ == nullptr)
__IndexOf_Expr_String__ = (String::typeid)->GetMethod("IndexOf", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __IndexOf_Expr_String__;
} }
public:
/// <summary>
/// Reports the index of the first occurrence of a String, or one or more characters, within this string.
/// </summary>
Expr<int> IndexOf(Expr<String^> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_IndexOf_Expr_String__, this, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __IndexOf_Expr_wchar_t__Expr_int_;
static property MethodInfo^ _IndexOf_Expr_wchar_t__Expr_int_ {
MethodInfo^ get() { if (__IndexOf_Expr_wchar_t__Expr_int_ == nullptr)
__IndexOf_Expr_wchar_t__Expr_int_ = (String::typeid)->GetMethod("IndexOf", gcnew array<Type^>{ Expr<wchar_t>::WrappedType, Expr<int>::WrappedType }); return __IndexOf_Expr_wchar_t__Expr_int_;
} }
public:
/// <summary>
/// Reports the index of the first occurrence of a String, or one or more characters, within this string.
/// </summary>
Expr<int> IndexOf(Expr<wchar_t> value, Expr<int> startIndex)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_IndexOf_Expr_wchar_t__Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex}));
}
private:
static MethodInfo^ __IndexOf_Expr_String___Expr_int_;
static property MethodInfo^ _IndexOf_Expr_String___Expr_int_ {
MethodInfo^ get() { if (__IndexOf_Expr_String___Expr_int_ == nullptr)
__IndexOf_Expr_String___Expr_int_ = (String::typeid)->GetMethod("IndexOf", gcnew array<Type^>{ Expr<String^>::WrappedType, Expr<int>::WrappedType }); return __IndexOf_Expr_String___Expr_int_;
} }
public:
/// <summary>
/// Reports the index of the first occurrence of a String, or one or more characters, within this string.
/// </summary>
Expr<int> IndexOf(Expr<String^> value, Expr<int> startIndex)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_IndexOf_Expr_String___Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex}));
}
private:
static MethodInfo^ __IndexOf_Expr_wchar_t__Expr_int__Expr_int_;
static property MethodInfo^ _IndexOf_Expr_wchar_t__Expr_int__Expr_int_ {
MethodInfo^ get() { if (__IndexOf_Expr_wchar_t__Expr_int__Expr_int_ == nullptr)
__IndexOf_Expr_wchar_t__Expr_int__Expr_int_ = (String::typeid)->GetMethod("IndexOf", gcnew array<Type^>{ Expr<wchar_t>::WrappedType, Expr<int>::WrappedType, Expr<int>::WrappedType }); return __IndexOf_Expr_wchar_t__Expr_int__Expr_int_;
} }
public:
/// <summary>
/// Reports the index of the first occurrence of a String, or one or more characters, within this string.
/// </summary>
Expr<int> IndexOf(Expr<wchar_t> value, Expr<int> startIndex, Expr<int> count)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_IndexOf_Expr_wchar_t__Expr_int__Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex, count}));
}
private:
static MethodInfo^ __IndexOf_Expr_String___Expr_int__Expr_int_;
static property MethodInfo^ _IndexOf_Expr_String___Expr_int__Expr_int_ {
MethodInfo^ get() { if (__IndexOf_Expr_String___Expr_int__Expr_int_ == nullptr)
__IndexOf_Expr_String___Expr_int__Expr_int_ = (String::typeid)->GetMethod("IndexOf", gcnew array<Type^>{ Expr<String^>::WrappedType, Expr<int>::WrappedType, Expr<int>::WrappedType }); return __IndexOf_Expr_String___Expr_int__Expr_int_;
} }
public:
/// <summary>
/// Reports the index of the first occurrence of a String, or one or more characters, within this string.
/// </summary>
Expr<int> IndexOf(Expr<String^> value, Expr<int> startIndex, Expr<int> count)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_IndexOf_Expr_String___Expr_int__Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex, count}));
}
private:
static MethodInfo^ __LastIndexOf_Expr_wchar_t_;
static property MethodInfo^ _LastIndexOf_Expr_wchar_t_ {
MethodInfo^ get() { if (__LastIndexOf_Expr_wchar_t_ == nullptr)
__LastIndexOf_Expr_wchar_t_ = (String::typeid)->GetMethod("LastIndexOf", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __LastIndexOf_Expr_wchar_t_;
} }
public:
/// <summary>
/// Reports the index position of the last occurrence of a specified Unicode character or String within this instance.
/// </summary>
Expr<int> LastIndexOf(Expr<wchar_t> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_LastIndexOf_Expr_wchar_t_, this, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __LastIndexOf_Expr_String__;
static property MethodInfo^ _LastIndexOf_Expr_String__ {
MethodInfo^ get() { if (__LastIndexOf_Expr_String__ == nullptr)
__LastIndexOf_Expr_String__ = (String::typeid)->GetMethod("LastIndexOf", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __LastIndexOf_Expr_String__;
} }
public:
/// <summary>
/// Reports the index position of the last occurrence of a specified Unicode character or String within this instance.
/// </summary>
Expr<int> LastIndexOf(Expr<String^> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_LastIndexOf_Expr_String__, this, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __LastIndexOf_Expr_wchar_t__Expr_int_;
static property MethodInfo^ _LastIndexOf_Expr_wchar_t__Expr_int_ {
MethodInfo^ get() { if (__LastIndexOf_Expr_wchar_t__Expr_int_ == nullptr)
__LastIndexOf_Expr_wchar_t__Expr_int_ = (String::typeid)->GetMethod("LastIndexOf", gcnew array<Type^>{ Expr<wchar_t>::WrappedType, Expr<int>::WrappedType }); return __LastIndexOf_Expr_wchar_t__Expr_int_;
} }
public:
/// <summary>
/// Reports the index position of the last occurrence of a specified Unicode character or String within this instance.
/// </summary>
Expr<int> LastIndexOf(Expr<wchar_t> value, Expr<int> startIndex)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_LastIndexOf_Expr_wchar_t__Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex}));
}
private:
static MethodInfo^ __LastIndexOf_Expr_String___Expr_int_;
static property MethodInfo^ _LastIndexOf_Expr_String___Expr_int_ {
MethodInfo^ get() { if (__LastIndexOf_Expr_String___Expr_int_ == nullptr)
__LastIndexOf_Expr_String___Expr_int_ = (String::typeid)->GetMethod("LastIndexOf", gcnew array<Type^>{ Expr<String^>::WrappedType, Expr<int>::WrappedType }); return __LastIndexOf_Expr_String___Expr_int_;
} }
public:
/// <summary>
/// Reports the index position of the last occurrence of a specified Unicode character or String within this instance.
/// </summary>
Expr<int> LastIndexOf(Expr<String^> value, Expr<int> startIndex)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_LastIndexOf_Expr_String___Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex}));
}
private:
static MethodInfo^ __LastIndexOf_Expr_wchar_t__Expr_int__Expr_int_;
static property MethodInfo^ _LastIndexOf_Expr_wchar_t__Expr_int__Expr_int_ {
MethodInfo^ get() { if (__LastIndexOf_Expr_wchar_t__Expr_int__Expr_int_ == nullptr)
__LastIndexOf_Expr_wchar_t__Expr_int__Expr_int_ = (String::typeid)->GetMethod("LastIndexOf", gcnew array<Type^>{ Expr<wchar_t>::WrappedType, Expr<int>::WrappedType, Expr<int>::WrappedType }); return __LastIndexOf_Expr_wchar_t__Expr_int__Expr_int_;
} }
public:
/// <summary>
/// Reports the index position of the last occurrence of a specified Unicode character or String within this instance.
/// </summary>
Expr<int> LastIndexOf(Expr<wchar_t> value, Expr<int> startIndex, Expr<int> count)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_LastIndexOf_Expr_wchar_t__Expr_int__Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex, count}));
}
private:
static MethodInfo^ __LastIndexOf_Expr_String___Expr_int__Expr_int_;
static property MethodInfo^ _LastIndexOf_Expr_String___Expr_int__Expr_int_ {
MethodInfo^ get() { if (__LastIndexOf_Expr_String___Expr_int__Expr_int_ == nullptr)
__LastIndexOf_Expr_String___Expr_int__Expr_int_ = (String::typeid)->GetMethod("LastIndexOf", gcnew array<Type^>{ Expr<String^>::WrappedType, Expr<int>::WrappedType, Expr<int>::WrappedType }); return __LastIndexOf_Expr_String___Expr_int__Expr_int_;
} }
public:
/// <summary>
/// Reports the index position of the last occurrence of a specified Unicode character or String within this instance.
/// </summary>
Expr<int> LastIndexOf(Expr<String^> value, Expr<int> startIndex, Expr<int> count)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_LastIndexOf_Expr_String___Expr_int__Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex, count}));
}
private:
static MethodInfo^ __Insert_Expr_int__Expr_String__;
static property MethodInfo^ _Insert_Expr_int__Expr_String__ {
MethodInfo^ get() { if (__Insert_Expr_int__Expr_String__ == nullptr)
__Insert_Expr_int__Expr_String__ = (String::typeid)->GetMethod("Insert", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<String^>::WrappedType }); return __Insert_Expr_int__Expr_String__;
} }
public:
/// <summary>
/// Inserts a specified instance of String at a specified index position in this instance.
/// </summary>
Expr<String^> Insert(Expr<int> startIndex, Expr<String^> value)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_Insert_Expr_int__Expr_String__, this, gcnew array<GenericExpression^>{startIndex, value}));
}
private:
static MethodInfo^ __Remove_Expr_int_;
static property MethodInfo^ _Remove_Expr_int_ {
MethodInfo^ get() { if (__Remove_Expr_int_ == nullptr)
__Remove_Expr_int_ = (String::typeid)->GetMethod("Remove", gcnew array<Type^>{ Expr<int>::WrappedType }); return __Remove_Expr_int_;
} }
public:
/// <summary>
/// Deletes a specified number of characters from this instance.
/// </summary>
Expr<String^> Remove(Expr<int> startIndex)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_Remove_Expr_int_, this, gcnew array<GenericExpression^>{startIndex}));
}
private:
static MethodInfo^ __Remove_Expr_int__Expr_int_;
static property MethodInfo^ _Remove_Expr_int__Expr_int_ {
MethodInfo^ get() { if (__Remove_Expr_int__Expr_int_ == nullptr)
__Remove_Expr_int__Expr_int_ = (String::typeid)->GetMethod("Remove", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<int>::WrappedType }); return __Remove_Expr_int__Expr_int_;
} }
public:
/// <summary>
/// Deletes a specified number of characters from this instance.
/// </summary>
Expr<String^> Remove(Expr<int> startIndex, Expr<int> count)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_Remove_Expr_int__Expr_int_, this, gcnew array<GenericExpression^>{startIndex, count}));
}
private:
static MethodInfo^ __Replace_Expr_wchar_t__Expr_wchar_t_;
static property MethodInfo^ _Replace_Expr_wchar_t__Expr_wchar_t_ {
MethodInfo^ get() { if (__Replace_Expr_wchar_t__Expr_wchar_t_ == nullptr)
__Replace_Expr_wchar_t__Expr_wchar_t_ = (String::typeid)->GetMethod("Replace", gcnew array<Type^>{ Expr<wchar_t>::WrappedType, Expr<wchar_t>::WrappedType }); return __Replace_Expr_wchar_t__Expr_wchar_t_;
} }
public:
/// <summary>
/// Replaces all occurrences of a specified Unicode character or String in this instance, with another specified Unicode character or String.
/// </summary>
Expr<String^> Replace(Expr<wchar_t> oldChar, Expr<wchar_t> newChar)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_Replace_Expr_wchar_t__Expr_wchar_t_, this, gcnew array<GenericExpression^>{oldChar, newChar}));
}
private:
static MethodInfo^ __Replace_Expr_String___Expr_String__;
static property MethodInfo^ _Replace_Expr_String___Expr_String__ {
MethodInfo^ get() { if (__Replace_Expr_String___Expr_String__ == nullptr)
__Replace_Expr_String___Expr_String__ = (String::typeid)->GetMethod("Replace", gcnew array<Type^>{ Expr<String^>::WrappedType, Expr<String^>::WrappedType }); return __Replace_Expr_String___Expr_String__;
} }
public:
/// <summary>
/// Replaces all occurrences of a specified Unicode character or String in this instance, with another specified Unicode character or String.
/// </summary>
Expr<String^> Replace(Expr<String^> oldValue, Expr<String^> newValue)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_Replace_Expr_String___Expr_String__, this, gcnew array<GenericExpression^>{oldValue, newValue}));
}
private:
static MethodInfo^ __Trim;
static property MethodInfo^ _Trim {
MethodInfo^ get() { if (__Trim == nullptr)
__Trim = (String::typeid)->GetMethod("Trim", gcnew array<Type^>{ }); return __Trim;
} }
public:
/// <summary>
/// Removes all leading and trailing occurrences of a set of specified characters from the current String object.
/// </summary>
Expr<String^> Trim()
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_Trim, this, gcnew array<GenericExpression^>{}));
}
private:
static MethodInfo^ __ToLower;
static property MethodInfo^ _ToLower {
MethodInfo^ get() { if (__ToLower == nullptr)
__ToLower = (String::typeid)->GetMethod("ToLower", gcnew array<Type^>{ }); return __ToLower;
} }
public:
/// <summary>
/// Returns a copy of this String converted to lowercase.
/// </summary>
Expr<String^> ToLower()
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_ToLower, this, gcnew array<GenericExpression^>{}));
}
private:
static MethodInfo^ __ToUpper;
static property MethodInfo^ _ToUpper {
MethodInfo^ get() { if (__ToUpper == nullptr)
__ToUpper = (String::typeid)->GetMethod("ToUpper", gcnew array<Type^>{ }); return __ToUpper;
} }
public:
/// <summary>
/// Returns a copy of this String converted to uppercase.
/// </summary>
Expr<String^> ToUpper()
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_ToUpper, this, gcnew array<GenericExpression^>{}));
}
private:
static MethodInfo^ __PadRight_Expr_int_;
static property MethodInfo^ _PadRight_Expr_int_ {
MethodInfo^ get() { if (__PadRight_Expr_int_ == nullptr)
__PadRight_Expr_int_ = (String::typeid)->GetMethod("PadRight", gcnew array<Type^>{ Expr<int>::WrappedType }); return __PadRight_Expr_int_;
} }
public:
/// <summary>
/// Left-aligns the characters in this string, padding on the right with spaces or a specified Unicode character, for a specified total length.
/// </summary>
Expr<String^> PadRight(Expr<int> totalWidth)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_PadRight_Expr_int_, this, gcnew array<GenericExpression^>{totalWidth}));
}
private:
static MethodInfo^ __PadRight_Expr_int__Expr_wchar_t_;
static property MethodInfo^ _PadRight_Expr_int__Expr_wchar_t_ {
MethodInfo^ get() { if (__PadRight_Expr_int__Expr_wchar_t_ == nullptr)
__PadRight_Expr_int__Expr_wchar_t_ = (String::typeid)->GetMethod("PadRight", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<wchar_t>::WrappedType }); return __PadRight_Expr_int__Expr_wchar_t_;
} }
public:
/// <summary>
/// Left-aligns the characters in this string, padding on the right with spaces or a specified Unicode character, for a specified total length.
/// </summary>
Expr<String^> PadRight(Expr<int> totalWidth, Expr<wchar_t> paddingChar)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_PadRight_Expr_int__Expr_wchar_t_, this, gcnew array<GenericExpression^>{totalWidth, paddingChar}));
}
private:
static MethodInfo^ __PadLeft_Expr_int_;
static property MethodInfo^ _PadLeft_Expr_int_ {
MethodInfo^ get() { if (__PadLeft_Expr_int_ == nullptr)
__PadLeft_Expr_int_ = (String::typeid)->GetMethod("PadLeft", gcnew array<Type^>{ Expr<int>::WrappedType }); return __PadLeft_Expr_int_;
} }
public:
/// <summary>
/// Right-aligns the characters in this instance, padding on the left with spaces or a specified Unicode character for a specified total length.
/// </summary>
Expr<String^> PadLeft(Expr<int> totalWidth)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_PadLeft_Expr_int_, this, gcnew array<GenericExpression^>{totalWidth}));
}
private:
static MethodInfo^ __PadLeft_Expr_int__Expr_wchar_t_;
static property MethodInfo^ _PadLeft_Expr_int__Expr_wchar_t_ {
MethodInfo^ get() { if (__PadLeft_Expr_int__Expr_wchar_t_ == nullptr)
__PadLeft_Expr_int__Expr_wchar_t_ = (String::typeid)->GetMethod("PadLeft", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<wchar_t>::WrappedType }); return __PadLeft_Expr_int__Expr_wchar_t_;
} }
public:
/// <summary>
/// Right-aligns the characters in this instance, padding on the left with spaces or a specified Unicode character for a specified total length.
/// </summary>
Expr<String^> PadLeft(Expr<int> totalWidth, Expr<wchar_t> paddingChar)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_PadLeft_Expr_int__Expr_wchar_t_, this, gcnew array<GenericExpression^>{totalWidth, paddingChar}));
}
private:
static MethodInfo^ __Equals_Expr_String__;
static property MethodInfo^ _Equals_Expr_String__ {
MethodInfo^ get() { if (__Equals_Expr_String__ == nullptr)
__Equals_Expr_String__ = (String::typeid)->GetMethod("Equals", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __Equals_Expr_String__;
} }
public:
/// <summary>
/// Determines whether two String objects have the same value.
/// </summary>
Expr<bool> Equals(Expr<String^> str)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_Equals_Expr_String__, this, gcnew array<GenericExpression^>{str}));
}
private:
static MethodInfo^ __CompareTo_Expr_String__;
static property MethodInfo^ _CompareTo_Expr_String__ {
MethodInfo^ get() { if (__CompareTo_Expr_String__ == nullptr)
__CompareTo_Expr_String__ = (String::typeid)->GetMethod("CompareTo", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __CompareTo_Expr_String__;
} }
public:
/// <summary>
/// Compares this instance with a specified object or String and returns an indication of their relative values.
/// </summary>
Expr<int> CompareTo(Expr<String^> str)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_CompareTo_Expr_String__, this, gcnew array<GenericExpression^>{str}));
}
private:
static MethodInfo^ __Compare_Expr_String___Expr_String__;
static property MethodInfo^ _Compare_Expr_String___Expr_String__ {
MethodInfo^ get() { if (__Compare_Expr_String___Expr_String__ == nullptr)
__Compare_Expr_String___Expr_String__ = (String::typeid)->GetMethod("Compare", gcnew array<Type^>{ Expr<String^>::WrappedType, Expr<String^>::WrappedType }); return __Compare_Expr_String___Expr_String__;
} }
public:
/// <summary>
/// Compares two specified String objects.
/// </summary>
static Expr<int> Compare(Expr<String^> strA, Expr<String^> strB)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_Compare_Expr_String___Expr_String__, nullptr, gcnew array<GenericExpression^>{strA, strB}));
}
private:
static MethodInfo^ __Concat_cli__array_Expression_String_____;
static property MethodInfo^ _Concat_cli__array_Expression_String_____ {
MethodInfo^ get() { if (__Concat_cli__array_Expression_String_____ == nullptr)
__Concat_cli__array_Expression_String_____ = (String::typeid)->GetMethod("Concat", gcnew array<Type^>{ cli::array<String^>::typeid }); return __Concat_cli__array_Expression_String_____;
} }
public:
/// <summary>
/// Concatenates one or more instances of String.
/// </summary>
static Expr<String^> Concat(... cli::array<Expression<String^>^>^ strs)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_Concat_cli__array_Expression_String_____, nullptr, gcnew array<GenericExpression^>{ gcnew ParamsExpression<String^>(strs) }));
}
};
/// <summary>
/// Template specialization for the 'DateTime' expresion.
/// </summary>
template<> public ref class Expr<DateTime> : ExpressionWrapper<DateTime>
{
public:
static property Type^ WrappedType { Type^ get() { return DateTime::typeid; } }
public:
Expr<DateTime>() { }
Expr<DateTime>(DateTime val) { _value = gcnew Literal<DateTime>(val); }
Expr<DateTime>(Expression<DateTime>^ value) { _value = value; }
Expr<DateTime>(Expr<DateTime>% b) { _value = b._value; }
operator Expression<DateTime>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<DateTime>(Expression<DateTime>^ value) { return Expr<DateTime>(value); }
static operator Expr<DateTime>(DateTime b) { return Expr<DateTime>(b); }
public:
static Expr<DateTime> Typed(GenericExpression^ value)
{
return Expr<DateTime>(gcnew TypedExpression<DateTime>(value));
}
static Expr<DateTime> Convert(GenericExpression^ value)
{
return Expr<DateTime>(gcnew ConvertExpression<DateTime>(value));
}
public:
public:
};
/// <summary>
/// Template specialization for the 'Nullable<DateTime>' expresion.
/// </summary>
template<> public ref class Expr<Nullable<DateTime>> : ExpressionWrapper<Nullable<DateTime>>
{
public:
static property Type^ WrappedType { Type^ get() { return Nullable<DateTime>::typeid; } }
public:
Expr<Nullable<DateTime>>() { }
Expr<Nullable<DateTime>>(Nullable<DateTime> val) { _value = gcnew Literal<Nullable<DateTime>>(val); }
Expr<Nullable<DateTime>>(Expression<Nullable<DateTime>>^ value) { _value = value; }
Expr<Nullable<DateTime>>(Expr<Nullable<DateTime>>% b) { _value = b._value; }
operator Expression<Nullable<DateTime>>^() { return _value; }
operator GenericExpression^() { return _value; }
static operator Expr<Nullable<DateTime>>(Expression<Nullable<DateTime>>^ value) { return Expr<Nullable<DateTime>>(value); }
static operator Expr<Nullable<DateTime>>(Nullable<DateTime> b) { return Expr<Nullable<DateTime>>(b); }
public:
static Expr<Nullable<DateTime>> Typed(GenericExpression^ value)
{
return Expr<Nullable<DateTime>>(gcnew TypedExpression<Nullable<DateTime>>(value));
}
static Expr<Nullable<DateTime>> Convert(GenericExpression^ value)
{
return Expr<Nullable<DateTime>>(gcnew ConvertExpression<Nullable<DateTime>>(value));
}
public:
public:
};
/// <summary>
/// Converts a base data type to another base data type.
/// </summary>
template<> public ref class Expr<System::Convert^>
{
private:
Expr<System::Convert^>() { }
public:
public:
private:
static MethodInfo^ __ToBool_Expr_bool_;
static property MethodInfo^ _ToBool_Expr_bool_ {
MethodInfo^ get() { if (__ToBool_Expr_bool_ == nullptr)
__ToBool_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToBool_Expr_bool_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'bool'.
/// </summary>
static Expr<bool> ToBool(Expr<bool> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_ToBool_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToBool_Expr_unsigned_char_;
static property MethodInfo^ _ToBool_Expr_unsigned_char_ {
MethodInfo^ get() { if (__ToBool_Expr_unsigned_char_ == nullptr)
__ToBool_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToBool_Expr_unsigned_char_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'bool'.
/// </summary>
static Expr<bool> ToBool(Expr<unsigned char> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_ToBool_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToBool_Expr_wchar_t_;
static property MethodInfo^ _ToBool_Expr_wchar_t_ {
MethodInfo^ get() { if (__ToBool_Expr_wchar_t_ == nullptr)
__ToBool_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToBool_Expr_wchar_t_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'bool'.
/// </summary>
static Expr<bool> ToBool(Expr<wchar_t> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_ToBool_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToBool_Expr_DateTime_;
static property MethodInfo^ _ToBool_Expr_DateTime_ {
MethodInfo^ get() { if (__ToBool_Expr_DateTime_ == nullptr)
__ToBool_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToBool_Expr_DateTime_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'bool'.
/// </summary>
static Expr<bool> ToBool(Expr<DateTime> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_ToBool_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToBool_Expr_Decimal_;
static property MethodInfo^ _ToBool_Expr_Decimal_ {
MethodInfo^ get() { if (__ToBool_Expr_Decimal_ == nullptr)
__ToBool_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToBool_Expr_Decimal_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'bool'.
/// </summary>
static Expr<bool> ToBool(Expr<Decimal> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_ToBool_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToBool_Expr_Double_;
static property MethodInfo^ _ToBool_Expr_Double_ {
MethodInfo^ get() { if (__ToBool_Expr_Double_ == nullptr)
__ToBool_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToBool_Expr_Double_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'bool'.
/// </summary>
static Expr<bool> ToBool(Expr<Double> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_ToBool_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToBool_Expr_float_;
static property MethodInfo^ _ToBool_Expr_float_ {
MethodInfo^ get() { if (__ToBool_Expr_float_ == nullptr)
__ToBool_Expr_float_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToBool_Expr_float_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'bool'.
/// </summary>
static Expr<bool> ToBool(Expr<float> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_ToBool_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToBool_Expr_short_;
static property MethodInfo^ _ToBool_Expr_short_ {
MethodInfo^ get() { if (__ToBool_Expr_short_ == nullptr)
__ToBool_Expr_short_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToBool_Expr_short_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'bool'.
/// </summary>
static Expr<bool> ToBool(Expr<short> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_ToBool_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToBool_Expr_int_;
static property MethodInfo^ _ToBool_Expr_int_ {
MethodInfo^ get() { if (__ToBool_Expr_int_ == nullptr)
__ToBool_Expr_int_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToBool_Expr_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'bool'.
/// </summary>
static Expr<bool> ToBool(Expr<int> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_ToBool_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToBool_Expr_long_long_int_;
static property MethodInfo^ _ToBool_Expr_long_long_int_ {
MethodInfo^ get() { if (__ToBool_Expr_long_long_int_ == nullptr)
__ToBool_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToBool_Expr_long_long_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'bool'.
/// </summary>
static Expr<bool> ToBool(Expr<long long int> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_ToBool_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToBool_Expr_String__;
static property MethodInfo^ _ToBool_Expr_String__ {
MethodInfo^ get() { if (__ToBool_Expr_String__ == nullptr)
__ToBool_Expr_String__ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToBool_Expr_String__;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'bool'.
/// </summary>
static Expr<bool> ToBool(Expr<String^> value)
{
return Expr<bool>(gcnew MethodInvokeExpression<bool>
(_ToBool_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToByte_Expr_bool_;
static property MethodInfo^ _ToByte_Expr_bool_ {
MethodInfo^ get() { if (__ToByte_Expr_bool_ == nullptr)
__ToByte_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToByte_Expr_bool_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'unsigned char'.
/// </summary>
static Expr<unsigned char> ToByte(Expr<bool> value)
{
return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
(_ToByte_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToByte_Expr_unsigned_char_;
static property MethodInfo^ _ToByte_Expr_unsigned_char_ {
MethodInfo^ get() { if (__ToByte_Expr_unsigned_char_ == nullptr)
__ToByte_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToByte_Expr_unsigned_char_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'unsigned char'.
/// </summary>
static Expr<unsigned char> ToByte(Expr<unsigned char> value)
{
return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
(_ToByte_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToByte_Expr_wchar_t_;
static property MethodInfo^ _ToByte_Expr_wchar_t_ {
MethodInfo^ get() { if (__ToByte_Expr_wchar_t_ == nullptr)
__ToByte_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToByte_Expr_wchar_t_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'unsigned char'.
/// </summary>
static Expr<unsigned char> ToByte(Expr<wchar_t> value)
{
return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
(_ToByte_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToByte_Expr_DateTime_;
static property MethodInfo^ _ToByte_Expr_DateTime_ {
MethodInfo^ get() { if (__ToByte_Expr_DateTime_ == nullptr)
__ToByte_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToByte_Expr_DateTime_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'unsigned char'.
/// </summary>
static Expr<unsigned char> ToByte(Expr<DateTime> value)
{
return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
(_ToByte_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToByte_Expr_Decimal_;
static property MethodInfo^ _ToByte_Expr_Decimal_ {
MethodInfo^ get() { if (__ToByte_Expr_Decimal_ == nullptr)
__ToByte_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToByte_Expr_Decimal_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'unsigned char'.
/// </summary>
static Expr<unsigned char> ToByte(Expr<Decimal> value)
{
return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
(_ToByte_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToByte_Expr_Double_;
static property MethodInfo^ _ToByte_Expr_Double_ {
MethodInfo^ get() { if (__ToByte_Expr_Double_ == nullptr)
__ToByte_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToByte_Expr_Double_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'unsigned char'.
/// </summary>
static Expr<unsigned char> ToByte(Expr<Double> value)
{
return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
(_ToByte_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToByte_Expr_float_;
static property MethodInfo^ _ToByte_Expr_float_ {
MethodInfo^ get() { if (__ToByte_Expr_float_ == nullptr)
__ToByte_Expr_float_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToByte_Expr_float_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'unsigned char'.
/// </summary>
static Expr<unsigned char> ToByte(Expr<float> value)
{
return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
(_ToByte_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToByte_Expr_short_;
static property MethodInfo^ _ToByte_Expr_short_ {
MethodInfo^ get() { if (__ToByte_Expr_short_ == nullptr)
__ToByte_Expr_short_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToByte_Expr_short_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'unsigned char'.
/// </summary>
static Expr<unsigned char> ToByte(Expr<short> value)
{
return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
(_ToByte_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToByte_Expr_int_;
static property MethodInfo^ _ToByte_Expr_int_ {
MethodInfo^ get() { if (__ToByte_Expr_int_ == nullptr)
__ToByte_Expr_int_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToByte_Expr_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'unsigned char'.
/// </summary>
static Expr<unsigned char> ToByte(Expr<int> value)
{
return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
(_ToByte_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToByte_Expr_long_long_int_;
static property MethodInfo^ _ToByte_Expr_long_long_int_ {
MethodInfo^ get() { if (__ToByte_Expr_long_long_int_ == nullptr)
__ToByte_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToByte_Expr_long_long_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'unsigned char'.
/// </summary>
static Expr<unsigned char> ToByte(Expr<long long int> value)
{
return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
(_ToByte_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToByte_Expr_String__;
static property MethodInfo^ _ToByte_Expr_String__ {
MethodInfo^ get() { if (__ToByte_Expr_String__ == nullptr)
__ToByte_Expr_String__ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToByte_Expr_String__;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'unsigned char'.
/// </summary>
static Expr<unsigned char> ToByte(Expr<String^> value)
{
return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
(_ToByte_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToChar_Expr_bool_;
static property MethodInfo^ _ToChar_Expr_bool_ {
MethodInfo^ get() { if (__ToChar_Expr_bool_ == nullptr)
__ToChar_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToChar_Expr_bool_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'wchar_t'.
/// </summary>
static Expr<wchar_t> ToChar(Expr<bool> value)
{
return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
(_ToChar_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToChar_Expr_unsigned_char_;
static property MethodInfo^ _ToChar_Expr_unsigned_char_ {
MethodInfo^ get() { if (__ToChar_Expr_unsigned_char_ == nullptr)
__ToChar_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToChar_Expr_unsigned_char_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'wchar_t'.
/// </summary>
static Expr<wchar_t> ToChar(Expr<unsigned char> value)
{
return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
(_ToChar_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToChar_Expr_wchar_t_;
static property MethodInfo^ _ToChar_Expr_wchar_t_ {
MethodInfo^ get() { if (__ToChar_Expr_wchar_t_ == nullptr)
__ToChar_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToChar_Expr_wchar_t_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'wchar_t'.
/// </summary>
static Expr<wchar_t> ToChar(Expr<wchar_t> value)
{
return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
(_ToChar_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToChar_Expr_DateTime_;
static property MethodInfo^ _ToChar_Expr_DateTime_ {
MethodInfo^ get() { if (__ToChar_Expr_DateTime_ == nullptr)
__ToChar_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToChar_Expr_DateTime_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'wchar_t'.
/// </summary>
static Expr<wchar_t> ToChar(Expr<DateTime> value)
{
return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
(_ToChar_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToChar_Expr_Decimal_;
static property MethodInfo^ _ToChar_Expr_Decimal_ {
MethodInfo^ get() { if (__ToChar_Expr_Decimal_ == nullptr)
__ToChar_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToChar_Expr_Decimal_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'wchar_t'.
/// </summary>
static Expr<wchar_t> ToChar(Expr<Decimal> value)
{
return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
(_ToChar_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToChar_Expr_Double_;
static property MethodInfo^ _ToChar_Expr_Double_ {
MethodInfo^ get() { if (__ToChar_Expr_Double_ == nullptr)
__ToChar_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToChar_Expr_Double_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'wchar_t'.
/// </summary>
static Expr<wchar_t> ToChar(Expr<Double> value)
{
return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
(_ToChar_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToChar_Expr_float_;
static property MethodInfo^ _ToChar_Expr_float_ {
MethodInfo^ get() { if (__ToChar_Expr_float_ == nullptr)
__ToChar_Expr_float_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToChar_Expr_float_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'wchar_t'.
/// </summary>
static Expr<wchar_t> ToChar(Expr<float> value)
{
return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
(_ToChar_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToChar_Expr_short_;
static property MethodInfo^ _ToChar_Expr_short_ {
MethodInfo^ get() { if (__ToChar_Expr_short_ == nullptr)
__ToChar_Expr_short_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToChar_Expr_short_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'wchar_t'.
/// </summary>
static Expr<wchar_t> ToChar(Expr<short> value)
{
return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
(_ToChar_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToChar_Expr_int_;
static property MethodInfo^ _ToChar_Expr_int_ {
MethodInfo^ get() { if (__ToChar_Expr_int_ == nullptr)
__ToChar_Expr_int_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToChar_Expr_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'wchar_t'.
/// </summary>
static Expr<wchar_t> ToChar(Expr<int> value)
{
return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
(_ToChar_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToChar_Expr_long_long_int_;
static property MethodInfo^ _ToChar_Expr_long_long_int_ {
MethodInfo^ get() { if (__ToChar_Expr_long_long_int_ == nullptr)
__ToChar_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToChar_Expr_long_long_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'wchar_t'.
/// </summary>
static Expr<wchar_t> ToChar(Expr<long long int> value)
{
return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
(_ToChar_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToChar_Expr_String__;
static property MethodInfo^ _ToChar_Expr_String__ {
MethodInfo^ get() { if (__ToChar_Expr_String__ == nullptr)
__ToChar_Expr_String__ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToChar_Expr_String__;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'wchar_t'.
/// </summary>
static Expr<wchar_t> ToChar(Expr<String^> value)
{
return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
(_ToChar_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDateTime_Expr_bool_;
static property MethodInfo^ _ToDateTime_Expr_bool_ {
MethodInfo^ get() { if (__ToDateTime_Expr_bool_ == nullptr)
__ToDateTime_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToDateTime_Expr_bool_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'DateTime'.
/// </summary>
static Expr<DateTime> ToDateTime(Expr<bool> value)
{
return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
(_ToDateTime_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDateTime_Expr_unsigned_char_;
static property MethodInfo^ _ToDateTime_Expr_unsigned_char_ {
MethodInfo^ get() { if (__ToDateTime_Expr_unsigned_char_ == nullptr)
__ToDateTime_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToDateTime_Expr_unsigned_char_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'DateTime'.
/// </summary>
static Expr<DateTime> ToDateTime(Expr<unsigned char> value)
{
return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
(_ToDateTime_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDateTime_Expr_wchar_t_;
static property MethodInfo^ _ToDateTime_Expr_wchar_t_ {
MethodInfo^ get() { if (__ToDateTime_Expr_wchar_t_ == nullptr)
__ToDateTime_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToDateTime_Expr_wchar_t_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'DateTime'.
/// </summary>
static Expr<DateTime> ToDateTime(Expr<wchar_t> value)
{
return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
(_ToDateTime_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDateTime_Expr_DateTime_;
static property MethodInfo^ _ToDateTime_Expr_DateTime_ {
MethodInfo^ get() { if (__ToDateTime_Expr_DateTime_ == nullptr)
__ToDateTime_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToDateTime_Expr_DateTime_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'DateTime'.
/// </summary>
static Expr<DateTime> ToDateTime(Expr<DateTime> value)
{
return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
(_ToDateTime_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDateTime_Expr_Decimal_;
static property MethodInfo^ _ToDateTime_Expr_Decimal_ {
MethodInfo^ get() { if (__ToDateTime_Expr_Decimal_ == nullptr)
__ToDateTime_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToDateTime_Expr_Decimal_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'DateTime'.
/// </summary>
static Expr<DateTime> ToDateTime(Expr<Decimal> value)
{
return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
(_ToDateTime_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDateTime_Expr_Double_;
static property MethodInfo^ _ToDateTime_Expr_Double_ {
MethodInfo^ get() { if (__ToDateTime_Expr_Double_ == nullptr)
__ToDateTime_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToDateTime_Expr_Double_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'DateTime'.
/// </summary>
static Expr<DateTime> ToDateTime(Expr<Double> value)
{
return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
(_ToDateTime_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDateTime_Expr_float_;
static property MethodInfo^ _ToDateTime_Expr_float_ {
MethodInfo^ get() { if (__ToDateTime_Expr_float_ == nullptr)
__ToDateTime_Expr_float_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToDateTime_Expr_float_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'DateTime'.
/// </summary>
static Expr<DateTime> ToDateTime(Expr<float> value)
{
return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
(_ToDateTime_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDateTime_Expr_short_;
static property MethodInfo^ _ToDateTime_Expr_short_ {
MethodInfo^ get() { if (__ToDateTime_Expr_short_ == nullptr)
__ToDateTime_Expr_short_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToDateTime_Expr_short_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'DateTime'.
/// </summary>
static Expr<DateTime> ToDateTime(Expr<short> value)
{
return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
(_ToDateTime_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDateTime_Expr_int_;
static property MethodInfo^ _ToDateTime_Expr_int_ {
MethodInfo^ get() { if (__ToDateTime_Expr_int_ == nullptr)
__ToDateTime_Expr_int_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToDateTime_Expr_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'DateTime'.
/// </summary>
static Expr<DateTime> ToDateTime(Expr<int> value)
{
return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
(_ToDateTime_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDateTime_Expr_long_long_int_;
static property MethodInfo^ _ToDateTime_Expr_long_long_int_ {
MethodInfo^ get() { if (__ToDateTime_Expr_long_long_int_ == nullptr)
__ToDateTime_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToDateTime_Expr_long_long_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'DateTime'.
/// </summary>
static Expr<DateTime> ToDateTime(Expr<long long int> value)
{
return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
(_ToDateTime_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDateTime_Expr_String__;
static property MethodInfo^ _ToDateTime_Expr_String__ {
MethodInfo^ get() { if (__ToDateTime_Expr_String__ == nullptr)
__ToDateTime_Expr_String__ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToDateTime_Expr_String__;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'DateTime'.
/// </summary>
static Expr<DateTime> ToDateTime(Expr<String^> value)
{
return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
(_ToDateTime_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDecimal_Expr_bool_;
static property MethodInfo^ _ToDecimal_Expr_bool_ {
MethodInfo^ get() { if (__ToDecimal_Expr_bool_ == nullptr)
__ToDecimal_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToDecimal_Expr_bool_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'Decimal'.
/// </summary>
static Expr<Decimal> ToDecimal(Expr<bool> value)
{
return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
(_ToDecimal_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDecimal_Expr_unsigned_char_;
static property MethodInfo^ _ToDecimal_Expr_unsigned_char_ {
MethodInfo^ get() { if (__ToDecimal_Expr_unsigned_char_ == nullptr)
__ToDecimal_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToDecimal_Expr_unsigned_char_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'Decimal'.
/// </summary>
static Expr<Decimal> ToDecimal(Expr<unsigned char> value)
{
return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
(_ToDecimal_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDecimal_Expr_wchar_t_;
static property MethodInfo^ _ToDecimal_Expr_wchar_t_ {
MethodInfo^ get() { if (__ToDecimal_Expr_wchar_t_ == nullptr)
__ToDecimal_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToDecimal_Expr_wchar_t_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'Decimal'.
/// </summary>
static Expr<Decimal> ToDecimal(Expr<wchar_t> value)
{
return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
(_ToDecimal_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDecimal_Expr_DateTime_;
static property MethodInfo^ _ToDecimal_Expr_DateTime_ {
MethodInfo^ get() { if (__ToDecimal_Expr_DateTime_ == nullptr)
__ToDecimal_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToDecimal_Expr_DateTime_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'Decimal'.
/// </summary>
static Expr<Decimal> ToDecimal(Expr<DateTime> value)
{
return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
(_ToDecimal_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDecimal_Expr_Decimal_;
static property MethodInfo^ _ToDecimal_Expr_Decimal_ {
MethodInfo^ get() { if (__ToDecimal_Expr_Decimal_ == nullptr)
__ToDecimal_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToDecimal_Expr_Decimal_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'Decimal'.
/// </summary>
static Expr<Decimal> ToDecimal(Expr<Decimal> value)
{
return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
(_ToDecimal_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDecimal_Expr_Double_;
static property MethodInfo^ _ToDecimal_Expr_Double_ {
MethodInfo^ get() { if (__ToDecimal_Expr_Double_ == nullptr)
__ToDecimal_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToDecimal_Expr_Double_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'Decimal'.
/// </summary>
static Expr<Decimal> ToDecimal(Expr<Double> value)
{
return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
(_ToDecimal_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDecimal_Expr_float_;
static property MethodInfo^ _ToDecimal_Expr_float_ {
MethodInfo^ get() { if (__ToDecimal_Expr_float_ == nullptr)
__ToDecimal_Expr_float_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToDecimal_Expr_float_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'Decimal'.
/// </summary>
static Expr<Decimal> ToDecimal(Expr<float> value)
{
return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
(_ToDecimal_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDecimal_Expr_short_;
static property MethodInfo^ _ToDecimal_Expr_short_ {
MethodInfo^ get() { if (__ToDecimal_Expr_short_ == nullptr)
__ToDecimal_Expr_short_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToDecimal_Expr_short_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'Decimal'.
/// </summary>
static Expr<Decimal> ToDecimal(Expr<short> value)
{
return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
(_ToDecimal_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDecimal_Expr_int_;
static property MethodInfo^ _ToDecimal_Expr_int_ {
MethodInfo^ get() { if (__ToDecimal_Expr_int_ == nullptr)
__ToDecimal_Expr_int_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToDecimal_Expr_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'Decimal'.
/// </summary>
static Expr<Decimal> ToDecimal(Expr<int> value)
{
return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
(_ToDecimal_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDecimal_Expr_long_long_int_;
static property MethodInfo^ _ToDecimal_Expr_long_long_int_ {
MethodInfo^ get() { if (__ToDecimal_Expr_long_long_int_ == nullptr)
__ToDecimal_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToDecimal_Expr_long_long_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'Decimal'.
/// </summary>
static Expr<Decimal> ToDecimal(Expr<long long int> value)
{
return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
(_ToDecimal_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDecimal_Expr_String__;
static property MethodInfo^ _ToDecimal_Expr_String__ {
MethodInfo^ get() { if (__ToDecimal_Expr_String__ == nullptr)
__ToDecimal_Expr_String__ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToDecimal_Expr_String__;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'Decimal'.
/// </summary>
static Expr<Decimal> ToDecimal(Expr<String^> value)
{
return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
(_ToDecimal_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDouble_Expr_bool_;
static property MethodInfo^ _ToDouble_Expr_bool_ {
MethodInfo^ get() { if (__ToDouble_Expr_bool_ == nullptr)
__ToDouble_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToDouble_Expr_bool_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'double'.
/// </summary>
static Expr<double> ToDouble(Expr<bool> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_ToDouble_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDouble_Expr_unsigned_char_;
static property MethodInfo^ _ToDouble_Expr_unsigned_char_ {
MethodInfo^ get() { if (__ToDouble_Expr_unsigned_char_ == nullptr)
__ToDouble_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToDouble_Expr_unsigned_char_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'double'.
/// </summary>
static Expr<double> ToDouble(Expr<unsigned char> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_ToDouble_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDouble_Expr_wchar_t_;
static property MethodInfo^ _ToDouble_Expr_wchar_t_ {
MethodInfo^ get() { if (__ToDouble_Expr_wchar_t_ == nullptr)
__ToDouble_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToDouble_Expr_wchar_t_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'double'.
/// </summary>
static Expr<double> ToDouble(Expr<wchar_t> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_ToDouble_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDouble_Expr_DateTime_;
static property MethodInfo^ _ToDouble_Expr_DateTime_ {
MethodInfo^ get() { if (__ToDouble_Expr_DateTime_ == nullptr)
__ToDouble_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToDouble_Expr_DateTime_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'double'.
/// </summary>
static Expr<double> ToDouble(Expr<DateTime> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_ToDouble_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDouble_Expr_Decimal_;
static property MethodInfo^ _ToDouble_Expr_Decimal_ {
MethodInfo^ get() { if (__ToDouble_Expr_Decimal_ == nullptr)
__ToDouble_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToDouble_Expr_Decimal_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'double'.
/// </summary>
static Expr<double> ToDouble(Expr<Decimal> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_ToDouble_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDouble_Expr_Double_;
static property MethodInfo^ _ToDouble_Expr_Double_ {
MethodInfo^ get() { if (__ToDouble_Expr_Double_ == nullptr)
__ToDouble_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToDouble_Expr_Double_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'double'.
/// </summary>
static Expr<double> ToDouble(Expr<Double> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_ToDouble_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDouble_Expr_float_;
static property MethodInfo^ _ToDouble_Expr_float_ {
MethodInfo^ get() { if (__ToDouble_Expr_float_ == nullptr)
__ToDouble_Expr_float_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToDouble_Expr_float_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'double'.
/// </summary>
static Expr<double> ToDouble(Expr<float> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_ToDouble_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDouble_Expr_short_;
static property MethodInfo^ _ToDouble_Expr_short_ {
MethodInfo^ get() { if (__ToDouble_Expr_short_ == nullptr)
__ToDouble_Expr_short_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToDouble_Expr_short_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'double'.
/// </summary>
static Expr<double> ToDouble(Expr<short> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_ToDouble_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDouble_Expr_int_;
static property MethodInfo^ _ToDouble_Expr_int_ {
MethodInfo^ get() { if (__ToDouble_Expr_int_ == nullptr)
__ToDouble_Expr_int_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToDouble_Expr_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'double'.
/// </summary>
static Expr<double> ToDouble(Expr<int> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_ToDouble_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDouble_Expr_long_long_int_;
static property MethodInfo^ _ToDouble_Expr_long_long_int_ {
MethodInfo^ get() { if (__ToDouble_Expr_long_long_int_ == nullptr)
__ToDouble_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToDouble_Expr_long_long_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'double'.
/// </summary>
static Expr<double> ToDouble(Expr<long long int> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_ToDouble_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToDouble_Expr_String__;
static property MethodInfo^ _ToDouble_Expr_String__ {
MethodInfo^ get() { if (__ToDouble_Expr_String__ == nullptr)
__ToDouble_Expr_String__ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToDouble_Expr_String__;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'double'.
/// </summary>
static Expr<double> ToDouble(Expr<String^> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_ToDouble_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToSingle_Expr_bool_;
static property MethodInfo^ _ToSingle_Expr_bool_ {
MethodInfo^ get() { if (__ToSingle_Expr_bool_ == nullptr)
__ToSingle_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToSingle_Expr_bool_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'float'.
/// </summary>
static Expr<float> ToSingle(Expr<bool> value)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_ToSingle_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToSingle_Expr_unsigned_char_;
static property MethodInfo^ _ToSingle_Expr_unsigned_char_ {
MethodInfo^ get() { if (__ToSingle_Expr_unsigned_char_ == nullptr)
__ToSingle_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToSingle_Expr_unsigned_char_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'float'.
/// </summary>
static Expr<float> ToSingle(Expr<unsigned char> value)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_ToSingle_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToSingle_Expr_wchar_t_;
static property MethodInfo^ _ToSingle_Expr_wchar_t_ {
MethodInfo^ get() { if (__ToSingle_Expr_wchar_t_ == nullptr)
__ToSingle_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToSingle_Expr_wchar_t_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'float'.
/// </summary>
static Expr<float> ToSingle(Expr<wchar_t> value)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_ToSingle_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToSingle_Expr_DateTime_;
static property MethodInfo^ _ToSingle_Expr_DateTime_ {
MethodInfo^ get() { if (__ToSingle_Expr_DateTime_ == nullptr)
__ToSingle_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToSingle_Expr_DateTime_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'float'.
/// </summary>
static Expr<float> ToSingle(Expr<DateTime> value)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_ToSingle_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToSingle_Expr_Decimal_;
static property MethodInfo^ _ToSingle_Expr_Decimal_ {
MethodInfo^ get() { if (__ToSingle_Expr_Decimal_ == nullptr)
__ToSingle_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToSingle_Expr_Decimal_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'float'.
/// </summary>
static Expr<float> ToSingle(Expr<Decimal> value)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_ToSingle_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToSingle_Expr_Double_;
static property MethodInfo^ _ToSingle_Expr_Double_ {
MethodInfo^ get() { if (__ToSingle_Expr_Double_ == nullptr)
__ToSingle_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToSingle_Expr_Double_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'float'.
/// </summary>
static Expr<float> ToSingle(Expr<Double> value)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_ToSingle_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToSingle_Expr_float_;
static property MethodInfo^ _ToSingle_Expr_float_ {
MethodInfo^ get() { if (__ToSingle_Expr_float_ == nullptr)
__ToSingle_Expr_float_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToSingle_Expr_float_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'float'.
/// </summary>
static Expr<float> ToSingle(Expr<float> value)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_ToSingle_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToSingle_Expr_short_;
static property MethodInfo^ _ToSingle_Expr_short_ {
MethodInfo^ get() { if (__ToSingle_Expr_short_ == nullptr)
__ToSingle_Expr_short_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToSingle_Expr_short_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'float'.
/// </summary>
static Expr<float> ToSingle(Expr<short> value)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_ToSingle_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToSingle_Expr_int_;
static property MethodInfo^ _ToSingle_Expr_int_ {
MethodInfo^ get() { if (__ToSingle_Expr_int_ == nullptr)
__ToSingle_Expr_int_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToSingle_Expr_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'float'.
/// </summary>
static Expr<float> ToSingle(Expr<int> value)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_ToSingle_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToSingle_Expr_long_long_int_;
static property MethodInfo^ _ToSingle_Expr_long_long_int_ {
MethodInfo^ get() { if (__ToSingle_Expr_long_long_int_ == nullptr)
__ToSingle_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToSingle_Expr_long_long_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'float'.
/// </summary>
static Expr<float> ToSingle(Expr<long long int> value)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_ToSingle_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToSingle_Expr_String__;
static property MethodInfo^ _ToSingle_Expr_String__ {
MethodInfo^ get() { if (__ToSingle_Expr_String__ == nullptr)
__ToSingle_Expr_String__ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToSingle_Expr_String__;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'float'.
/// </summary>
static Expr<float> ToSingle(Expr<String^> value)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_ToSingle_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt16_Expr_bool_;
static property MethodInfo^ _ToInt16_Expr_bool_ {
MethodInfo^ get() { if (__ToInt16_Expr_bool_ == nullptr)
__ToInt16_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToInt16_Expr_bool_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'short'.
/// </summary>
static Expr<short> ToInt16(Expr<bool> value)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_ToInt16_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt16_Expr_unsigned_char_;
static property MethodInfo^ _ToInt16_Expr_unsigned_char_ {
MethodInfo^ get() { if (__ToInt16_Expr_unsigned_char_ == nullptr)
__ToInt16_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToInt16_Expr_unsigned_char_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'short'.
/// </summary>
static Expr<short> ToInt16(Expr<unsigned char> value)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_ToInt16_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt16_Expr_wchar_t_;
static property MethodInfo^ _ToInt16_Expr_wchar_t_ {
MethodInfo^ get() { if (__ToInt16_Expr_wchar_t_ == nullptr)
__ToInt16_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToInt16_Expr_wchar_t_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'short'.
/// </summary>
static Expr<short> ToInt16(Expr<wchar_t> value)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_ToInt16_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt16_Expr_DateTime_;
static property MethodInfo^ _ToInt16_Expr_DateTime_ {
MethodInfo^ get() { if (__ToInt16_Expr_DateTime_ == nullptr)
__ToInt16_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToInt16_Expr_DateTime_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'short'.
/// </summary>
static Expr<short> ToInt16(Expr<DateTime> value)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_ToInt16_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt16_Expr_Decimal_;
static property MethodInfo^ _ToInt16_Expr_Decimal_ {
MethodInfo^ get() { if (__ToInt16_Expr_Decimal_ == nullptr)
__ToInt16_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToInt16_Expr_Decimal_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'short'.
/// </summary>
static Expr<short> ToInt16(Expr<Decimal> value)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_ToInt16_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt16_Expr_Double_;
static property MethodInfo^ _ToInt16_Expr_Double_ {
MethodInfo^ get() { if (__ToInt16_Expr_Double_ == nullptr)
__ToInt16_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToInt16_Expr_Double_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'short'.
/// </summary>
static Expr<short> ToInt16(Expr<Double> value)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_ToInt16_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt16_Expr_float_;
static property MethodInfo^ _ToInt16_Expr_float_ {
MethodInfo^ get() { if (__ToInt16_Expr_float_ == nullptr)
__ToInt16_Expr_float_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToInt16_Expr_float_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'short'.
/// </summary>
static Expr<short> ToInt16(Expr<float> value)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_ToInt16_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt16_Expr_short_;
static property MethodInfo^ _ToInt16_Expr_short_ {
MethodInfo^ get() { if (__ToInt16_Expr_short_ == nullptr)
__ToInt16_Expr_short_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToInt16_Expr_short_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'short'.
/// </summary>
static Expr<short> ToInt16(Expr<short> value)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_ToInt16_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt16_Expr_int_;
static property MethodInfo^ _ToInt16_Expr_int_ {
MethodInfo^ get() { if (__ToInt16_Expr_int_ == nullptr)
__ToInt16_Expr_int_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToInt16_Expr_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'short'.
/// </summary>
static Expr<short> ToInt16(Expr<int> value)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_ToInt16_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt16_Expr_long_long_int_;
static property MethodInfo^ _ToInt16_Expr_long_long_int_ {
MethodInfo^ get() { if (__ToInt16_Expr_long_long_int_ == nullptr)
__ToInt16_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToInt16_Expr_long_long_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'short'.
/// </summary>
static Expr<short> ToInt16(Expr<long long int> value)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_ToInt16_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt16_Expr_String__;
static property MethodInfo^ _ToInt16_Expr_String__ {
MethodInfo^ get() { if (__ToInt16_Expr_String__ == nullptr)
__ToInt16_Expr_String__ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToInt16_Expr_String__;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'short'.
/// </summary>
static Expr<short> ToInt16(Expr<String^> value)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_ToInt16_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt32_Expr_bool_;
static property MethodInfo^ _ToInt32_Expr_bool_ {
MethodInfo^ get() { if (__ToInt32_Expr_bool_ == nullptr)
__ToInt32_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToInt32_Expr_bool_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'int'.
/// </summary>
static Expr<int> ToInt32(Expr<bool> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_ToInt32_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt32_Expr_unsigned_char_;
static property MethodInfo^ _ToInt32_Expr_unsigned_char_ {
MethodInfo^ get() { if (__ToInt32_Expr_unsigned_char_ == nullptr)
__ToInt32_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToInt32_Expr_unsigned_char_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'int'.
/// </summary>
static Expr<int> ToInt32(Expr<unsigned char> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_ToInt32_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt32_Expr_wchar_t_;
static property MethodInfo^ _ToInt32_Expr_wchar_t_ {
MethodInfo^ get() { if (__ToInt32_Expr_wchar_t_ == nullptr)
__ToInt32_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToInt32_Expr_wchar_t_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'int'.
/// </summary>
static Expr<int> ToInt32(Expr<wchar_t> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_ToInt32_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt32_Expr_DateTime_;
static property MethodInfo^ _ToInt32_Expr_DateTime_ {
MethodInfo^ get() { if (__ToInt32_Expr_DateTime_ == nullptr)
__ToInt32_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToInt32_Expr_DateTime_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'int'.
/// </summary>
static Expr<int> ToInt32(Expr<DateTime> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_ToInt32_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt32_Expr_Decimal_;
static property MethodInfo^ _ToInt32_Expr_Decimal_ {
MethodInfo^ get() { if (__ToInt32_Expr_Decimal_ == nullptr)
__ToInt32_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToInt32_Expr_Decimal_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'int'.
/// </summary>
static Expr<int> ToInt32(Expr<Decimal> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_ToInt32_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt32_Expr_Double_;
static property MethodInfo^ _ToInt32_Expr_Double_ {
MethodInfo^ get() { if (__ToInt32_Expr_Double_ == nullptr)
__ToInt32_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToInt32_Expr_Double_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'int'.
/// </summary>
static Expr<int> ToInt32(Expr<Double> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_ToInt32_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt32_Expr_float_;
static property MethodInfo^ _ToInt32_Expr_float_ {
MethodInfo^ get() { if (__ToInt32_Expr_float_ == nullptr)
__ToInt32_Expr_float_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToInt32_Expr_float_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'int'.
/// </summary>
static Expr<int> ToInt32(Expr<float> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_ToInt32_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt32_Expr_short_;
static property MethodInfo^ _ToInt32_Expr_short_ {
MethodInfo^ get() { if (__ToInt32_Expr_short_ == nullptr)
__ToInt32_Expr_short_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToInt32_Expr_short_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'int'.
/// </summary>
static Expr<int> ToInt32(Expr<short> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_ToInt32_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt32_Expr_int_;
static property MethodInfo^ _ToInt32_Expr_int_ {
MethodInfo^ get() { if (__ToInt32_Expr_int_ == nullptr)
__ToInt32_Expr_int_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToInt32_Expr_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'int'.
/// </summary>
static Expr<int> ToInt32(Expr<int> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_ToInt32_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt32_Expr_long_long_int_;
static property MethodInfo^ _ToInt32_Expr_long_long_int_ {
MethodInfo^ get() { if (__ToInt32_Expr_long_long_int_ == nullptr)
__ToInt32_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToInt32_Expr_long_long_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'int'.
/// </summary>
static Expr<int> ToInt32(Expr<long long int> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_ToInt32_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt32_Expr_String__;
static property MethodInfo^ _ToInt32_Expr_String__ {
MethodInfo^ get() { if (__ToInt32_Expr_String__ == nullptr)
__ToInt32_Expr_String__ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToInt32_Expr_String__;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'int'.
/// </summary>
static Expr<int> ToInt32(Expr<String^> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_ToInt32_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt64_Expr_bool_;
static property MethodInfo^ _ToInt64_Expr_bool_ {
MethodInfo^ get() { if (__ToInt64_Expr_bool_ == nullptr)
__ToInt64_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToInt64_Expr_bool_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'long long int'.
/// </summary>
static Expr<long long int> ToInt64(Expr<bool> value)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_ToInt64_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt64_Expr_unsigned_char_;
static property MethodInfo^ _ToInt64_Expr_unsigned_char_ {
MethodInfo^ get() { if (__ToInt64_Expr_unsigned_char_ == nullptr)
__ToInt64_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToInt64_Expr_unsigned_char_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'long long int'.
/// </summary>
static Expr<long long int> ToInt64(Expr<unsigned char> value)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_ToInt64_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt64_Expr_wchar_t_;
static property MethodInfo^ _ToInt64_Expr_wchar_t_ {
MethodInfo^ get() { if (__ToInt64_Expr_wchar_t_ == nullptr)
__ToInt64_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToInt64_Expr_wchar_t_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'long long int'.
/// </summary>
static Expr<long long int> ToInt64(Expr<wchar_t> value)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_ToInt64_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt64_Expr_DateTime_;
static property MethodInfo^ _ToInt64_Expr_DateTime_ {
MethodInfo^ get() { if (__ToInt64_Expr_DateTime_ == nullptr)
__ToInt64_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToInt64_Expr_DateTime_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'long long int'.
/// </summary>
static Expr<long long int> ToInt64(Expr<DateTime> value)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_ToInt64_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt64_Expr_Decimal_;
static property MethodInfo^ _ToInt64_Expr_Decimal_ {
MethodInfo^ get() { if (__ToInt64_Expr_Decimal_ == nullptr)
__ToInt64_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToInt64_Expr_Decimal_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'long long int'.
/// </summary>
static Expr<long long int> ToInt64(Expr<Decimal> value)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_ToInt64_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt64_Expr_Double_;
static property MethodInfo^ _ToInt64_Expr_Double_ {
MethodInfo^ get() { if (__ToInt64_Expr_Double_ == nullptr)
__ToInt64_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToInt64_Expr_Double_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'long long int'.
/// </summary>
static Expr<long long int> ToInt64(Expr<Double> value)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_ToInt64_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt64_Expr_float_;
static property MethodInfo^ _ToInt64_Expr_float_ {
MethodInfo^ get() { if (__ToInt64_Expr_float_ == nullptr)
__ToInt64_Expr_float_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToInt64_Expr_float_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'long long int'.
/// </summary>
static Expr<long long int> ToInt64(Expr<float> value)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_ToInt64_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt64_Expr_short_;
static property MethodInfo^ _ToInt64_Expr_short_ {
MethodInfo^ get() { if (__ToInt64_Expr_short_ == nullptr)
__ToInt64_Expr_short_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToInt64_Expr_short_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'long long int'.
/// </summary>
static Expr<long long int> ToInt64(Expr<short> value)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_ToInt64_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt64_Expr_int_;
static property MethodInfo^ _ToInt64_Expr_int_ {
MethodInfo^ get() { if (__ToInt64_Expr_int_ == nullptr)
__ToInt64_Expr_int_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToInt64_Expr_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'long long int'.
/// </summary>
static Expr<long long int> ToInt64(Expr<int> value)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_ToInt64_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt64_Expr_long_long_int_;
static property MethodInfo^ _ToInt64_Expr_long_long_int_ {
MethodInfo^ get() { if (__ToInt64_Expr_long_long_int_ == nullptr)
__ToInt64_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToInt64_Expr_long_long_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'long long int'.
/// </summary>
static Expr<long long int> ToInt64(Expr<long long int> value)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_ToInt64_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToInt64_Expr_String__;
static property MethodInfo^ _ToInt64_Expr_String__ {
MethodInfo^ get() { if (__ToInt64_Expr_String__ == nullptr)
__ToInt64_Expr_String__ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToInt64_Expr_String__;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'long long int'.
/// </summary>
static Expr<long long int> ToInt64(Expr<String^> value)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_ToInt64_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToString_Expr_bool_;
static property MethodInfo^ _ToString_Expr_bool_ {
MethodInfo^ get() { if (__ToString_Expr_bool_ == nullptr)
__ToString_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToString_Expr_bool_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'String^'.
/// </summary>
static Expr<String^> ToString(Expr<bool> value)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_ToString_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToString_Expr_unsigned_char_;
static property MethodInfo^ _ToString_Expr_unsigned_char_ {
MethodInfo^ get() { if (__ToString_Expr_unsigned_char_ == nullptr)
__ToString_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToString_Expr_unsigned_char_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'String^'.
/// </summary>
static Expr<String^> ToString(Expr<unsigned char> value)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_ToString_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToString_Expr_wchar_t_;
static property MethodInfo^ _ToString_Expr_wchar_t_ {
MethodInfo^ get() { if (__ToString_Expr_wchar_t_ == nullptr)
__ToString_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToString_Expr_wchar_t_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'String^'.
/// </summary>
static Expr<String^> ToString(Expr<wchar_t> value)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_ToString_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToString_Expr_DateTime_;
static property MethodInfo^ _ToString_Expr_DateTime_ {
MethodInfo^ get() { if (__ToString_Expr_DateTime_ == nullptr)
__ToString_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToString_Expr_DateTime_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'String^'.
/// </summary>
static Expr<String^> ToString(Expr<DateTime> value)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_ToString_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToString_Expr_Decimal_;
static property MethodInfo^ _ToString_Expr_Decimal_ {
MethodInfo^ get() { if (__ToString_Expr_Decimal_ == nullptr)
__ToString_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToString_Expr_Decimal_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'String^'.
/// </summary>
static Expr<String^> ToString(Expr<Decimal> value)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_ToString_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToString_Expr_Double_;
static property MethodInfo^ _ToString_Expr_Double_ {
MethodInfo^ get() { if (__ToString_Expr_Double_ == nullptr)
__ToString_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToString_Expr_Double_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'String^'.
/// </summary>
static Expr<String^> ToString(Expr<Double> value)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_ToString_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToString_Expr_float_;
static property MethodInfo^ _ToString_Expr_float_ {
MethodInfo^ get() { if (__ToString_Expr_float_ == nullptr)
__ToString_Expr_float_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToString_Expr_float_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'String^'.
/// </summary>
static Expr<String^> ToString(Expr<float> value)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_ToString_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToString_Expr_short_;
static property MethodInfo^ _ToString_Expr_short_ {
MethodInfo^ get() { if (__ToString_Expr_short_ == nullptr)
__ToString_Expr_short_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToString_Expr_short_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'String^'.
/// </summary>
static Expr<String^> ToString(Expr<short> value)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_ToString_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToString_Expr_int_;
static property MethodInfo^ _ToString_Expr_int_ {
MethodInfo^ get() { if (__ToString_Expr_int_ == nullptr)
__ToString_Expr_int_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToString_Expr_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'String^'.
/// </summary>
static Expr<String^> ToString(Expr<int> value)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_ToString_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToString_Expr_long_long_int_;
static property MethodInfo^ _ToString_Expr_long_long_int_ {
MethodInfo^ get() { if (__ToString_Expr_long_long_int_ == nullptr)
__ToString_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToString_Expr_long_long_int_;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'String^'.
/// </summary>
static Expr<String^> ToString(Expr<long long int> value)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_ToString_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __ToString_Expr_String__;
static property MethodInfo^ _ToString_Expr_String__ {
MethodInfo^ get() { if (__ToString_Expr_String__ == nullptr)
__ToString_Expr_String__ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToString_Expr_String__;
} }
public:
/// <summary>
/// Overloaded. Converts a specified value to 'String^'.
/// </summary>
static Expr<String^> ToString(Expr<String^> value)
{
return Expr<String^>(gcnew MethodInvokeExpression<String^>
(_ToString_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
}
};
/// <summary>
/// Provides constants and static methods for trigonometric, logarithmic, and other common mathematical functions.
/// </summary>
template<> public ref class Expr<System::Math^>
{
private:
Expr<System::Math^>() { }
public:
public:
private:
static MethodInfo^ __Abs_Expr_System__Decimal_;
static property MethodInfo^ _Abs_Expr_System__Decimal_ {
MethodInfo^ get() { if (__Abs_Expr_System__Decimal_ == nullptr)
__Abs_Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType }); return __Abs_Expr_System__Decimal_;
} }
public:
/// <summary>
/// Returns the absolute value of a specified number.
/// </summary>
static Expr<System::Decimal> Abs(Expr<System::Decimal> value)
{
return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
(_Abs_Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Abs_Expr_double_;
static property MethodInfo^ _Abs_Expr_double_ {
MethodInfo^ get() { if (__Abs_Expr_double_ == nullptr)
__Abs_Expr_double_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Abs_Expr_double_;
} }
public:
/// <summary>
/// Returns the absolute value of a specified number.
/// </summary>
static Expr<double> Abs(Expr<double> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Abs_Expr_double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Abs_Expr_float_;
static property MethodInfo^ _Abs_Expr_float_ {
MethodInfo^ get() { if (__Abs_Expr_float_ == nullptr)
__Abs_Expr_float_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<float>::WrappedType }); return __Abs_Expr_float_;
} }
public:
/// <summary>
/// Returns the absolute value of a specified number.
/// </summary>
static Expr<float> Abs(Expr<float> value)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_Abs_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Abs_Expr_int_;
static property MethodInfo^ _Abs_Expr_int_ {
MethodInfo^ get() { if (__Abs_Expr_int_ == nullptr)
__Abs_Expr_int_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<int>::WrappedType }); return __Abs_Expr_int_;
} }
public:
/// <summary>
/// Returns the absolute value of a specified number.
/// </summary>
static Expr<int> Abs(Expr<int> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_Abs_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Abs_Expr_long_long_int_;
static property MethodInfo^ _Abs_Expr_long_long_int_ {
MethodInfo^ get() { if (__Abs_Expr_long_long_int_ == nullptr)
__Abs_Expr_long_long_int_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __Abs_Expr_long_long_int_;
} }
public:
/// <summary>
/// Returns the absolute value of a specified number.
/// </summary>
static Expr<long long int> Abs(Expr<long long int> value)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_Abs_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Abs_Expr_signed_char_;
static property MethodInfo^ _Abs_Expr_signed_char_ {
MethodInfo^ get() { if (__Abs_Expr_signed_char_ == nullptr)
__Abs_Expr_signed_char_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<signed char>::WrappedType }); return __Abs_Expr_signed_char_;
} }
public:
/// <summary>
/// Returns the absolute value of a specified number.
/// </summary>
static Expr<signed char> Abs(Expr<signed char> value)
{
return Expr<signed char>(gcnew MethodInvokeExpression<signed char>
(_Abs_Expr_signed_char_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Abs_Expr_short_;
static property MethodInfo^ _Abs_Expr_short_ {
MethodInfo^ get() { if (__Abs_Expr_short_ == nullptr)
__Abs_Expr_short_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<short>::WrappedType }); return __Abs_Expr_short_;
} }
public:
/// <summary>
/// Returns the absolute value of a specified number.
/// </summary>
static Expr<short> Abs(Expr<short> value)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_Abs_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Acos_Expr_double_;
static property MethodInfo^ _Acos_Expr_double_ {
MethodInfo^ get() { if (__Acos_Expr_double_ == nullptr)
__Acos_Expr_double_ = (System::Math::typeid)->GetMethod("Acos", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Acos_Expr_double_;
} }
public:
/// <summary>
/// Returns the angle whose cosine is the specified number.
/// </summary>
static Expr<double> Acos(Expr<double> d)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Acos_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
}
private:
static MethodInfo^ __Asin_Expr_double_;
static property MethodInfo^ _Asin_Expr_double_ {
MethodInfo^ get() { if (__Asin_Expr_double_ == nullptr)
__Asin_Expr_double_ = (System::Math::typeid)->GetMethod("Asin", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Asin_Expr_double_;
} }
public:
/// <summary>
/// Returns the angle whose sine is the specified number.
/// </summary>
static Expr<double> Asin(Expr<double> d)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Asin_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
}
private:
static MethodInfo^ __Atan_Expr_double_;
static property MethodInfo^ _Atan_Expr_double_ {
MethodInfo^ get() { if (__Atan_Expr_double_ == nullptr)
__Atan_Expr_double_ = (System::Math::typeid)->GetMethod("Atan", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Atan_Expr_double_;
} }
public:
/// <summary>
/// Returns the angle whose tangent is the specified number.
/// </summary>
static Expr<double> Atan(Expr<double> d)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Atan_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
}
private:
static MethodInfo^ __Atan2_Expr_double__Expr_double_;
static property MethodInfo^ _Atan2_Expr_double__Expr_double_ {
MethodInfo^ get() { if (__Atan2_Expr_double__Expr_double_ == nullptr)
__Atan2_Expr_double__Expr_double_ = (System::Math::typeid)->GetMethod("Atan2", gcnew array<Type^>{ Expr<double>::WrappedType, Expr<double>::WrappedType }); return __Atan2_Expr_double__Expr_double_;
} }
public:
/// <summary>
/// Returns the angle whose tangent is the quotient of two specified numbers.
/// </summary>
static Expr<double> Atan2(Expr<double> y, Expr<double> x)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Atan2_Expr_double__Expr_double_, nullptr, gcnew array<GenericExpression^>{y, x}));
}
private:
static MethodInfo^ __BigMul_Expr_int__Expr_int_;
static property MethodInfo^ _BigMul_Expr_int__Expr_int_ {
MethodInfo^ get() { if (__BigMul_Expr_int__Expr_int_ == nullptr)
__BigMul_Expr_int__Expr_int_ = (System::Math::typeid)->GetMethod("BigMul", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<int>::WrappedType }); return __BigMul_Expr_int__Expr_int_;
} }
public:
/// <summary>
/// Produces the full product of two 32-bit numbers.
/// </summary>
static Expr<long long int> BigMul(Expr<int> a, Expr<int> b)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_BigMul_Expr_int__Expr_int_, nullptr, gcnew array<GenericExpression^>{a, b}));
}
private:
static MethodInfo^ __Ceiling_Expr_System__Decimal_;
static property MethodInfo^ _Ceiling_Expr_System__Decimal_ {
MethodInfo^ get() { if (__Ceiling_Expr_System__Decimal_ == nullptr)
__Ceiling_Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Ceiling", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType }); return __Ceiling_Expr_System__Decimal_;
} }
public:
/// <summary>
/// Returns the smallest number greater than or equal to the specified number.
/// </summary>
static Expr<System::Decimal> Ceiling(Expr<System::Decimal> d)
{
return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
(_Ceiling_Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{d}));
}
private:
static MethodInfo^ __Ceiling_Expr_double_;
static property MethodInfo^ _Ceiling_Expr_double_ {
MethodInfo^ get() { if (__Ceiling_Expr_double_ == nullptr)
__Ceiling_Expr_double_ = (System::Math::typeid)->GetMethod("Ceiling", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Ceiling_Expr_double_;
} }
public:
/// <summary>
/// Returns the smallest number greater than or equal to the specified number.
/// </summary>
static Expr<double> Ceiling(Expr<double> a)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Ceiling_Expr_double_, nullptr, gcnew array<GenericExpression^>{a}));
}
private:
static MethodInfo^ __Cos_Expr_double_;
static property MethodInfo^ _Cos_Expr_double_ {
MethodInfo^ get() { if (__Cos_Expr_double_ == nullptr)
__Cos_Expr_double_ = (System::Math::typeid)->GetMethod("Cos", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Cos_Expr_double_;
} }
public:
/// <summary>
/// Returns the cosine of the specified angle.
/// </summary>
static Expr<double> Cos(Expr<double> d)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Cos_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
}
private:
static MethodInfo^ __Cosh_Expr_double_;
static property MethodInfo^ _Cosh_Expr_double_ {
MethodInfo^ get() { if (__Cosh_Expr_double_ == nullptr)
__Cosh_Expr_double_ = (System::Math::typeid)->GetMethod("Cosh", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Cosh_Expr_double_;
} }
public:
/// <summary>
/// Returns the hyperbolic cosine of the specified angle.
/// </summary>
static Expr<double> Cosh(Expr<double> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Cosh_Expr_double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Exp_Expr_double_;
static property MethodInfo^ _Exp_Expr_double_ {
MethodInfo^ get() { if (__Exp_Expr_double_ == nullptr)
__Exp_Expr_double_ = (System::Math::typeid)->GetMethod("Exp", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Exp_Expr_double_;
} }
public:
/// <summary>
/// Returns e raised to the specified power.
/// </summary>
static Expr<double> Exp(Expr<double> d)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Exp_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
}
private:
static MethodInfo^ __Floor_Expr_System__Decimal_;
static property MethodInfo^ _Floor_Expr_System__Decimal_ {
MethodInfo^ get() { if (__Floor_Expr_System__Decimal_ == nullptr)
__Floor_Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Floor", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType }); return __Floor_Expr_System__Decimal_;
} }
public:
/// <summary>
/// Returns the largest number less than or equal to the specified number.
/// </summary>
static Expr<System::Decimal> Floor(Expr<System::Decimal> d)
{
return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
(_Floor_Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{d}));
}
private:
static MethodInfo^ __Floor_Expr_double_;
static property MethodInfo^ _Floor_Expr_double_ {
MethodInfo^ get() { if (__Floor_Expr_double_ == nullptr)
__Floor_Expr_double_ = (System::Math::typeid)->GetMethod("Floor", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Floor_Expr_double_;
} }
public:
/// <summary>
/// Returns the largest number less than or equal to the specified number.
/// </summary>
static Expr<double> Floor(Expr<double> d)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Floor_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
}
private:
static MethodInfo^ __Log_Expr_double_;
static property MethodInfo^ _Log_Expr_double_ {
MethodInfo^ get() { if (__Log_Expr_double_ == nullptr)
__Log_Expr_double_ = (System::Math::typeid)->GetMethod("Log", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Log_Expr_double_;
} }
public:
/// <summary>
/// Returns the logarithm of a specified number.
/// </summary>
static Expr<double> Log(Expr<double> d)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Log_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
}
private:
static MethodInfo^ __Log_Expr_double__Expr_double_;
static property MethodInfo^ _Log_Expr_double__Expr_double_ {
MethodInfo^ get() { if (__Log_Expr_double__Expr_double_ == nullptr)
__Log_Expr_double__Expr_double_ = (System::Math::typeid)->GetMethod("Log", gcnew array<Type^>{ Expr<double>::WrappedType, Expr<double>::WrappedType }); return __Log_Expr_double__Expr_double_;
} }
public:
/// <summary>
/// Returns the logarithm of a specified number.
/// </summary>
static Expr<double> Log(Expr<double> a, Expr<double> newBase)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Log_Expr_double__Expr_double_, nullptr, gcnew array<GenericExpression^>{a, newBase}));
}
private:
static MethodInfo^ __Log10_Expr_double_;
static property MethodInfo^ _Log10_Expr_double_ {
MethodInfo^ get() { if (__Log10_Expr_double_ == nullptr)
__Log10_Expr_double_ = (System::Math::typeid)->GetMethod("Log10", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Log10_Expr_double_;
} }
public:
/// <summary>
/// Log10 Returns the base 10 logarithm of a specified number.
/// </summary>
static Expr<double> Log10(Expr<double> d)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Log10_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
}
private:
static MethodInfo^ __Max_Expr_unsigned_char__Expr_unsigned_char_;
static property MethodInfo^ _Max_Expr_unsigned_char__Expr_unsigned_char_ {
MethodInfo^ get() { if (__Max_Expr_unsigned_char__Expr_unsigned_char_ == nullptr)
__Max_Expr_unsigned_char__Expr_unsigned_char_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<unsigned char>::WrappedType, Expr<unsigned char>::WrappedType }); return __Max_Expr_unsigned_char__Expr_unsigned_char_;
} }
public:
/// <summary>
/// Returns the larger of two specified numbers.
/// </summary>
static Expr<unsigned char> Max(Expr<unsigned char> val1, Expr<unsigned char> val2)
{
return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
(_Max_Expr_unsigned_char__Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Max_Expr_System__Decimal__Expr_System__Decimal_;
static property MethodInfo^ _Max_Expr_System__Decimal__Expr_System__Decimal_ {
MethodInfo^ get() { if (__Max_Expr_System__Decimal__Expr_System__Decimal_ == nullptr)
__Max_Expr_System__Decimal__Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType, Expr<System::Decimal>::WrappedType }); return __Max_Expr_System__Decimal__Expr_System__Decimal_;
} }
public:
/// <summary>
/// Returns the larger of two specified numbers.
/// </summary>
static Expr<System::Decimal> Max(Expr<System::Decimal> val1, Expr<System::Decimal> val2)
{
return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
(_Max_Expr_System__Decimal__Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Max_Expr_double__Expr_double_;
static property MethodInfo^ _Max_Expr_double__Expr_double_ {
MethodInfo^ get() { if (__Max_Expr_double__Expr_double_ == nullptr)
__Max_Expr_double__Expr_double_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<double>::WrappedType, Expr<double>::WrappedType }); return __Max_Expr_double__Expr_double_;
} }
public:
/// <summary>
/// Returns the larger of two specified numbers.
/// </summary>
static Expr<double> Max(Expr<double> val1, Expr<double> val2)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Max_Expr_double__Expr_double_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Max_Expr_float__Expr_float_;
static property MethodInfo^ _Max_Expr_float__Expr_float_ {
MethodInfo^ get() { if (__Max_Expr_float__Expr_float_ == nullptr)
__Max_Expr_float__Expr_float_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<float>::WrappedType, Expr<float>::WrappedType }); return __Max_Expr_float__Expr_float_;
} }
public:
/// <summary>
/// Returns the larger of two specified numbers.
/// </summary>
static Expr<float> Max(Expr<float> val1, Expr<float> val2)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_Max_Expr_float__Expr_float_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Max_Expr_int__Expr_int_;
static property MethodInfo^ _Max_Expr_int__Expr_int_ {
MethodInfo^ get() { if (__Max_Expr_int__Expr_int_ == nullptr)
__Max_Expr_int__Expr_int_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<int>::WrappedType }); return __Max_Expr_int__Expr_int_;
} }
public:
/// <summary>
/// Returns the larger of two specified numbers.
/// </summary>
static Expr<int> Max(Expr<int> val1, Expr<int> val2)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_Max_Expr_int__Expr_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Max_Expr_long_long_int__Expr_long_long_int_;
static property MethodInfo^ _Max_Expr_long_long_int__Expr_long_long_int_ {
MethodInfo^ get() { if (__Max_Expr_long_long_int__Expr_long_long_int_ == nullptr)
__Max_Expr_long_long_int__Expr_long_long_int_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<long long int>::WrappedType, Expr<long long int>::WrappedType }); return __Max_Expr_long_long_int__Expr_long_long_int_;
} }
public:
/// <summary>
/// Returns the larger of two specified numbers.
/// </summary>
static Expr<long long int> Max(Expr<long long int> val1, Expr<long long int> val2)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_Max_Expr_long_long_int__Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Max_Expr_signed_char__Expr_signed_char_;
static property MethodInfo^ _Max_Expr_signed_char__Expr_signed_char_ {
MethodInfo^ get() { if (__Max_Expr_signed_char__Expr_signed_char_ == nullptr)
__Max_Expr_signed_char__Expr_signed_char_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<signed char>::WrappedType, Expr<signed char>::WrappedType }); return __Max_Expr_signed_char__Expr_signed_char_;
} }
public:
/// <summary>
/// Returns the larger of two specified numbers.
/// </summary>
static Expr<signed char> Max(Expr<signed char> val1, Expr<signed char> val2)
{
return Expr<signed char>(gcnew MethodInvokeExpression<signed char>
(_Max_Expr_signed_char__Expr_signed_char_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Max_Expr_short__Expr_short_;
static property MethodInfo^ _Max_Expr_short__Expr_short_ {
MethodInfo^ get() { if (__Max_Expr_short__Expr_short_ == nullptr)
__Max_Expr_short__Expr_short_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<short>::WrappedType, Expr<short>::WrappedType }); return __Max_Expr_short__Expr_short_;
} }
public:
/// <summary>
/// Returns the larger of two specified numbers.
/// </summary>
static Expr<short> Max(Expr<short> val1, Expr<short> val2)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_Max_Expr_short__Expr_short_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Max_Expr_unsigned_int__Expr_unsigned_int_;
static property MethodInfo^ _Max_Expr_unsigned_int__Expr_unsigned_int_ {
MethodInfo^ get() { if (__Max_Expr_unsigned_int__Expr_unsigned_int_ == nullptr)
__Max_Expr_unsigned_int__Expr_unsigned_int_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<unsigned int>::WrappedType, Expr<unsigned int>::WrappedType }); return __Max_Expr_unsigned_int__Expr_unsigned_int_;
} }
public:
/// <summary>
/// Returns the larger of two specified numbers.
/// </summary>
static Expr<unsigned int> Max(Expr<unsigned int> val1, Expr<unsigned int> val2)
{
return Expr<unsigned int>(gcnew MethodInvokeExpression<unsigned int>
(_Max_Expr_unsigned_int__Expr_unsigned_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Max_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_;
static property MethodInfo^ _Max_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_ {
MethodInfo^ get() { if (__Max_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_ == nullptr)
__Max_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<unsigned long long int>::WrappedType, Expr<unsigned long long int>::WrappedType }); return __Max_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_;
} }
public:
/// <summary>
/// Returns the larger of two specified numbers.
/// </summary>
static Expr<unsigned long long int> Max(Expr<unsigned long long int> val1, Expr<unsigned long long int> val2)
{
return Expr<unsigned long long int>(gcnew MethodInvokeExpression<unsigned long long int>
(_Max_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Max_Expr_unsigned_short__Expr_unsigned_short_;
static property MethodInfo^ _Max_Expr_unsigned_short__Expr_unsigned_short_ {
MethodInfo^ get() { if (__Max_Expr_unsigned_short__Expr_unsigned_short_ == nullptr)
__Max_Expr_unsigned_short__Expr_unsigned_short_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<unsigned short>::WrappedType, Expr<unsigned short>::WrappedType }); return __Max_Expr_unsigned_short__Expr_unsigned_short_;
} }
public:
/// <summary>
/// Returns the larger of two specified numbers.
/// </summary>
static Expr<unsigned short> Max(Expr<unsigned short> val1, Expr<unsigned short> val2)
{
return Expr<unsigned short>(gcnew MethodInvokeExpression<unsigned short>
(_Max_Expr_unsigned_short__Expr_unsigned_short_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Min_Expr_unsigned_char__Expr_unsigned_char_;
static property MethodInfo^ _Min_Expr_unsigned_char__Expr_unsigned_char_ {
MethodInfo^ get() { if (__Min_Expr_unsigned_char__Expr_unsigned_char_ == nullptr)
__Min_Expr_unsigned_char__Expr_unsigned_char_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<unsigned char>::WrappedType, Expr<unsigned char>::WrappedType }); return __Min_Expr_unsigned_char__Expr_unsigned_char_;
} }
public:
/// <summary>
/// Returns the smaller of two numbers.
/// </summary>
static Expr<unsigned char> Min(Expr<unsigned char> val1, Expr<unsigned char> val2)
{
return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
(_Min_Expr_unsigned_char__Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Min_Expr_System__Decimal__Expr_System__Decimal_;
static property MethodInfo^ _Min_Expr_System__Decimal__Expr_System__Decimal_ {
MethodInfo^ get() { if (__Min_Expr_System__Decimal__Expr_System__Decimal_ == nullptr)
__Min_Expr_System__Decimal__Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType, Expr<System::Decimal>::WrappedType }); return __Min_Expr_System__Decimal__Expr_System__Decimal_;
} }
public:
/// <summary>
/// Returns the smaller of two numbers.
/// </summary>
static Expr<System::Decimal> Min(Expr<System::Decimal> val1, Expr<System::Decimal> val2)
{
return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
(_Min_Expr_System__Decimal__Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Min_Expr_double__Expr_double_;
static property MethodInfo^ _Min_Expr_double__Expr_double_ {
MethodInfo^ get() { if (__Min_Expr_double__Expr_double_ == nullptr)
__Min_Expr_double__Expr_double_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<double>::WrappedType, Expr<double>::WrappedType }); return __Min_Expr_double__Expr_double_;
} }
public:
/// <summary>
/// Returns the smaller of two numbers.
/// </summary>
static Expr<double> Min(Expr<double> val1, Expr<double> val2)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Min_Expr_double__Expr_double_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Min_Expr_float__Expr_float_;
static property MethodInfo^ _Min_Expr_float__Expr_float_ {
MethodInfo^ get() { if (__Min_Expr_float__Expr_float_ == nullptr)
__Min_Expr_float__Expr_float_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<float>::WrappedType, Expr<float>::WrappedType }); return __Min_Expr_float__Expr_float_;
} }
public:
/// <summary>
/// Returns the smaller of two numbers.
/// </summary>
static Expr<float> Min(Expr<float> val1, Expr<float> val2)
{
return Expr<float>(gcnew MethodInvokeExpression<float>
(_Min_Expr_float__Expr_float_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Min_Expr_int__Expr_int_;
static property MethodInfo^ _Min_Expr_int__Expr_int_ {
MethodInfo^ get() { if (__Min_Expr_int__Expr_int_ == nullptr)
__Min_Expr_int__Expr_int_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<int>::WrappedType }); return __Min_Expr_int__Expr_int_;
} }
public:
/// <summary>
/// Returns the smaller of two numbers.
/// </summary>
static Expr<int> Min(Expr<int> val1, Expr<int> val2)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_Min_Expr_int__Expr_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Min_Expr_long_long_int__Expr_long_long_int_;
static property MethodInfo^ _Min_Expr_long_long_int__Expr_long_long_int_ {
MethodInfo^ get() { if (__Min_Expr_long_long_int__Expr_long_long_int_ == nullptr)
__Min_Expr_long_long_int__Expr_long_long_int_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<long long int>::WrappedType, Expr<long long int>::WrappedType }); return __Min_Expr_long_long_int__Expr_long_long_int_;
} }
public:
/// <summary>
/// Returns the smaller of two numbers.
/// </summary>
static Expr<long long int> Min(Expr<long long int> val1, Expr<long long int> val2)
{
return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
(_Min_Expr_long_long_int__Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Min_Expr_signed_char__Expr_signed_char_;
static property MethodInfo^ _Min_Expr_signed_char__Expr_signed_char_ {
MethodInfo^ get() { if (__Min_Expr_signed_char__Expr_signed_char_ == nullptr)
__Min_Expr_signed_char__Expr_signed_char_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<signed char>::WrappedType, Expr<signed char>::WrappedType }); return __Min_Expr_signed_char__Expr_signed_char_;
} }
public:
/// <summary>
/// Returns the smaller of two numbers.
/// </summary>
static Expr<signed char> Min(Expr<signed char> val1, Expr<signed char> val2)
{
return Expr<signed char>(gcnew MethodInvokeExpression<signed char>
(_Min_Expr_signed_char__Expr_signed_char_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Min_Expr_short__Expr_short_;
static property MethodInfo^ _Min_Expr_short__Expr_short_ {
MethodInfo^ get() { if (__Min_Expr_short__Expr_short_ == nullptr)
__Min_Expr_short__Expr_short_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<short>::WrappedType, Expr<short>::WrappedType }); return __Min_Expr_short__Expr_short_;
} }
public:
/// <summary>
/// Returns the smaller of two numbers.
/// </summary>
static Expr<short> Min(Expr<short> val1, Expr<short> val2)
{
return Expr<short>(gcnew MethodInvokeExpression<short>
(_Min_Expr_short__Expr_short_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Min_Expr_unsigned_int__Expr_unsigned_int_;
static property MethodInfo^ _Min_Expr_unsigned_int__Expr_unsigned_int_ {
MethodInfo^ get() { if (__Min_Expr_unsigned_int__Expr_unsigned_int_ == nullptr)
__Min_Expr_unsigned_int__Expr_unsigned_int_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<unsigned int>::WrappedType, Expr<unsigned int>::WrappedType }); return __Min_Expr_unsigned_int__Expr_unsigned_int_;
} }
public:
/// <summary>
/// Returns the smaller of two numbers.
/// </summary>
static Expr<unsigned int> Min(Expr<unsigned int> val1, Expr<unsigned int> val2)
{
return Expr<unsigned int>(gcnew MethodInvokeExpression<unsigned int>
(_Min_Expr_unsigned_int__Expr_unsigned_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Min_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_;
static property MethodInfo^ _Min_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_ {
MethodInfo^ get() { if (__Min_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_ == nullptr)
__Min_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<unsigned long long int>::WrappedType, Expr<unsigned long long int>::WrappedType }); return __Min_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_;
} }
public:
/// <summary>
/// Returns the smaller of two numbers.
/// </summary>
static Expr<unsigned long long int> Min(Expr<unsigned long long int> val1, Expr<unsigned long long int> val2)
{
return Expr<unsigned long long int>(gcnew MethodInvokeExpression<unsigned long long int>
(_Min_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Min_Expr_unsigned_short__Expr_unsigned_short_;
static property MethodInfo^ _Min_Expr_unsigned_short__Expr_unsigned_short_ {
MethodInfo^ get() { if (__Min_Expr_unsigned_short__Expr_unsigned_short_ == nullptr)
__Min_Expr_unsigned_short__Expr_unsigned_short_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<unsigned short>::WrappedType, Expr<unsigned short>::WrappedType }); return __Min_Expr_unsigned_short__Expr_unsigned_short_;
} }
public:
/// <summary>
/// Returns the smaller of two numbers.
/// </summary>
static Expr<unsigned short> Min(Expr<unsigned short> val1, Expr<unsigned short> val2)
{
return Expr<unsigned short>(gcnew MethodInvokeExpression<unsigned short>
(_Min_Expr_unsigned_short__Expr_unsigned_short_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
}
private:
static MethodInfo^ __Pow_Expr_double__Expr_double_;
static property MethodInfo^ _Pow_Expr_double__Expr_double_ {
MethodInfo^ get() { if (__Pow_Expr_double__Expr_double_ == nullptr)
__Pow_Expr_double__Expr_double_ = (System::Math::typeid)->GetMethod("Pow", gcnew array<Type^>{ Expr<double>::WrappedType, Expr<double>::WrappedType }); return __Pow_Expr_double__Expr_double_;
} }
public:
/// <summary>
/// Returns a specified number raised to the specified power.
/// </summary>
static Expr<double> Pow(Expr<double> x, Expr<double> y)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Pow_Expr_double__Expr_double_, nullptr, gcnew array<GenericExpression^>{x, y}));
}
private:
static MethodInfo^ __Round_Expr_System__Decimal_;
static property MethodInfo^ _Round_Expr_System__Decimal_ {
MethodInfo^ get() { if (__Round_Expr_System__Decimal_ == nullptr)
__Round_Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Round", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType }); return __Round_Expr_System__Decimal_;
} }
public:
/// <summary>
/// Rounds a value to the nearest number or specified number of Expr<System::Decimal> places.
/// </summary>
static Expr<System::Decimal> Round(Expr<System::Decimal> d)
{
return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
(_Round_Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{d}));
}
private:
static MethodInfo^ __Round_Expr_double_;
static property MethodInfo^ _Round_Expr_double_ {
MethodInfo^ get() { if (__Round_Expr_double_ == nullptr)
__Round_Expr_double_ = (System::Math::typeid)->GetMethod("Round", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Round_Expr_double_;
} }
public:
/// <summary>
/// Rounds a value to the nearest number or specified number of Expr<System::Decimal> places.
/// </summary>
static Expr<double> Round(Expr<double> a)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Round_Expr_double_, nullptr, gcnew array<GenericExpression^>{a}));
}
private:
static MethodInfo^ __Round_Expr_System__Decimal__Expr_int_;
static property MethodInfo^ _Round_Expr_System__Decimal__Expr_int_ {
MethodInfo^ get() { if (__Round_Expr_System__Decimal__Expr_int_ == nullptr)
__Round_Expr_System__Decimal__Expr_int_ = (System::Math::typeid)->GetMethod("Round", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType, Expr<int>::WrappedType }); return __Round_Expr_System__Decimal__Expr_int_;
} }
public:
/// <summary>
/// Rounds a value to the nearest number or specified number of Expr<System::Decimal> places.
/// </summary>
static Expr<System::Decimal> Round(Expr<System::Decimal> d, Expr<int> decimals)
{
return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
(_Round_Expr_System__Decimal__Expr_int_, nullptr, gcnew array<GenericExpression^>{d, decimals}));
}
private:
static MethodInfo^ __Round_Expr_double__Expr_int_;
static property MethodInfo^ _Round_Expr_double__Expr_int_ {
MethodInfo^ get() { if (__Round_Expr_double__Expr_int_ == nullptr)
__Round_Expr_double__Expr_int_ = (System::Math::typeid)->GetMethod("Round", gcnew array<Type^>{ Expr<double>::WrappedType, Expr<int>::WrappedType }); return __Round_Expr_double__Expr_int_;
} }
public:
/// <summary>
/// Rounds a value to the nearest number or specified number of Expr<System::Decimal> places.
/// </summary>
static Expr<double> Round(Expr<double> value, Expr<int> digits)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Round_Expr_double__Expr_int_, nullptr, gcnew array<GenericExpression^>{value, digits}));
}
private:
static MethodInfo^ __Sign_Expr_System__Decimal_;
static property MethodInfo^ _Sign_Expr_System__Decimal_ {
MethodInfo^ get() { if (__Sign_Expr_System__Decimal_ == nullptr)
__Sign_Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType }); return __Sign_Expr_System__Decimal_;
} }
public:
/// <summary>
/// Returns a value indicating the sign of a number.
/// </summary>
static Expr<int> Sign(Expr<System::Decimal> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_Sign_Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Sign_Expr_double_;
static property MethodInfo^ _Sign_Expr_double_ {
MethodInfo^ get() { if (__Sign_Expr_double_ == nullptr)
__Sign_Expr_double_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Sign_Expr_double_;
} }
public:
/// <summary>
/// Returns a value indicating the sign of a number.
/// </summary>
static Expr<int> Sign(Expr<double> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_Sign_Expr_double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Sign_Expr_float_;
static property MethodInfo^ _Sign_Expr_float_ {
MethodInfo^ get() { if (__Sign_Expr_float_ == nullptr)
__Sign_Expr_float_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<float>::WrappedType }); return __Sign_Expr_float_;
} }
public:
/// <summary>
/// Returns a value indicating the sign of a number.
/// </summary>
static Expr<int> Sign(Expr<float> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_Sign_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Sign_Expr_int_;
static property MethodInfo^ _Sign_Expr_int_ {
MethodInfo^ get() { if (__Sign_Expr_int_ == nullptr)
__Sign_Expr_int_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<int>::WrappedType }); return __Sign_Expr_int_;
} }
public:
/// <summary>
/// Returns a value indicating the sign of a number.
/// </summary>
static Expr<int> Sign(Expr<int> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_Sign_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Sign_Expr_long_long_int_;
static property MethodInfo^ _Sign_Expr_long_long_int_ {
MethodInfo^ get() { if (__Sign_Expr_long_long_int_ == nullptr)
__Sign_Expr_long_long_int_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __Sign_Expr_long_long_int_;
} }
public:
/// <summary>
/// Returns a value indicating the sign of a number.
/// </summary>
static Expr<int> Sign(Expr<long long int> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_Sign_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Sign_Expr_signed_char_;
static property MethodInfo^ _Sign_Expr_signed_char_ {
MethodInfo^ get() { if (__Sign_Expr_signed_char_ == nullptr)
__Sign_Expr_signed_char_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<signed char>::WrappedType }); return __Sign_Expr_signed_char_;
} }
public:
/// <summary>
/// Returns a value indicating the sign of a number.
/// </summary>
static Expr<int> Sign(Expr<signed char> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_Sign_Expr_signed_char_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Sign_Expr_short_;
static property MethodInfo^ _Sign_Expr_short_ {
MethodInfo^ get() { if (__Sign_Expr_short_ == nullptr)
__Sign_Expr_short_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<short>::WrappedType }); return __Sign_Expr_short_;
} }
public:
/// <summary>
/// Returns a value indicating the sign of a number.
/// </summary>
static Expr<int> Sign(Expr<short> value)
{
return Expr<int>(gcnew MethodInvokeExpression<int>
(_Sign_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Sin_Expr_double_;
static property MethodInfo^ _Sin_Expr_double_ {
MethodInfo^ get() { if (__Sin_Expr_double_ == nullptr)
__Sin_Expr_double_ = (System::Math::typeid)->GetMethod("Sin", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Sin_Expr_double_;
} }
public:
/// <summary>
/// Returns the sine of the specified angle.
/// </summary>
static Expr<double> Sin(Expr<double> a)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Sin_Expr_double_, nullptr, gcnew array<GenericExpression^>{a}));
}
private:
static MethodInfo^ __Sinh_Expr_double_;
static property MethodInfo^ _Sinh_Expr_double_ {
MethodInfo^ get() { if (__Sinh_Expr_double_ == nullptr)
__Sinh_Expr_double_ = (System::Math::typeid)->GetMethod("Sinh", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Sinh_Expr_double_;
} }
public:
/// <summary>
/// Returns the hyperbolic sine of the specified angle.
/// </summary>
static Expr<double> Sinh(Expr<double> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Sinh_Expr_double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Sqrt_Expr_double_;
static property MethodInfo^ _Sqrt_Expr_double_ {
MethodInfo^ get() { if (__Sqrt_Expr_double_ == nullptr)
__Sqrt_Expr_double_ = (System::Math::typeid)->GetMethod("Sqrt", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Sqrt_Expr_double_;
} }
public:
/// <summary>
/// Returns the square root of a specified number.
/// </summary>
static Expr<double> Sqrt(Expr<double> d)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Sqrt_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
}
private:
static MethodInfo^ __Tan_Expr_double_;
static property MethodInfo^ _Tan_Expr_double_ {
MethodInfo^ get() { if (__Tan_Expr_double_ == nullptr)
__Tan_Expr_double_ = (System::Math::typeid)->GetMethod("Tan", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Tan_Expr_double_;
} }
public:
/// <summary>
/// Returns the tangent of the specified angle.
/// </summary>
static Expr<double> Tan(Expr<double> a)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Tan_Expr_double_, nullptr, gcnew array<GenericExpression^>{a}));
}
private:
static MethodInfo^ __Tanh_Expr_double_;
static property MethodInfo^ _Tanh_Expr_double_ {
MethodInfo^ get() { if (__Tanh_Expr_double_ == nullptr)
__Tanh_Expr_double_ = (System::Math::typeid)->GetMethod("Tanh", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Tanh_Expr_double_;
} }
public:
/// <summary>
/// Returns the hyperbolic tangent of the specified angle.
/// </summary>
static Expr<double> Tanh(Expr<double> value)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Tanh_Expr_double_, nullptr, gcnew array<GenericExpression^>{value}));
}
private:
static MethodInfo^ __Truncate_Expr_System__Decimal_;
static property MethodInfo^ _Truncate_Expr_System__Decimal_ {
MethodInfo^ get() { if (__Truncate_Expr_System__Decimal_ == nullptr)
__Truncate_Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Truncate", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType }); return __Truncate_Expr_System__Decimal_;
} }
public:
/// <summary>
/// Calculates the integral part of a number.
/// </summary>
static Expr<System::Decimal> Truncate(Expr<System::Decimal> d)
{
return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
(_Truncate_Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{d}));
}
private:
static MethodInfo^ __Truncate_Expr_double_;
static property MethodInfo^ _Truncate_Expr_double_ {
MethodInfo^ get() { if (__Truncate_Expr_double_ == nullptr)
__Truncate_Expr_double_ = (System::Math::typeid)->GetMethod("Truncate", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Truncate_Expr_double_;
} }
public:
/// <summary>
/// Calculates the integral part of a number.
/// </summary>
static Expr<double> Truncate(Expr<double> d)
{
return Expr<double>(gcnew MethodInvokeExpression<double>
(_Truncate_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
}
};
/// <summary>
/// Class that represents variable of type unsigned char.
/// </summary>
template<> public ref class Var<unsigned char> : ExpressionWrapper<unsigned char>
{
public:
Var<unsigned char>(String^ name)
{
_value = gcnew Variable<unsigned char>(name);
}
operator Expression<unsigned char>^()
{
return _value;
}
};
/// <summary>
/// Class that represents variable of type signed char.
/// </summary>
template<> public ref class Var<signed char> : ExpressionWrapper<signed char>
{
public:
Var<signed char>(String^ name)
{
_value = gcnew Variable<signed char>(name);
}
operator Expression<signed char>^()
{
return _value;
}
};
/// <summary>
/// Class that represents variable of type float.
/// </summary>
template<> public ref class Var<float> : ExpressionWrapper<float>
{
public:
Var<float>(String^ name)
{
_value = gcnew Variable<float>(name);
}
operator Expression<float>^()
{
return _value;
}
};
/// <summary>
/// Class that represents variable of type double.
/// </summary>
template<> public ref class Var<double> : ExpressionWrapper<double>
{
public:
Var<double>(String^ name)
{
_value = gcnew Variable<double>(name);
}
operator Expression<double>^()
{
return _value;
}
};
/// <summary>
/// Class that represents variable of type System::Decimal.
/// </summary>
template<> public ref class Var<System::Decimal> : ExpressionWrapper<System::Decimal>
{
public:
Var<System::Decimal>(String^ name)
{
_value = gcnew Variable<System::Decimal>(name);
}
operator Expression<System::Decimal>^()
{
return _value;
}
};
/// <summary>
/// Class that represents variable of type long long int (Int64).
/// </summary>
template<> public ref class Var<long long int> : ExpressionWrapper<long long int>
{
public:
Var<long long int>(String^ name)
{
_value = gcnew Variable<long long int>(name);
}
operator Expression<long long int>^()
{
return _value;
}
};
/// <summary>
/// Class that represents variable of type short (Int16).
/// </summary>
template<> public ref class Var<short> : ExpressionWrapper<short>
{
public:
Var<short>(String^ name)
{
_value = gcnew Variable<short>(name);
}
operator Expression<short>^()
{
return _value;
}
};
/// <summary>
/// Class that represents variable of type int (Int32).
/// </summary>
template<> public ref class Var<int> : ExpressionWrapper<int>
{
public:
Var<int>(String^ name)
{
_value = gcnew Variable<int>(name);
}
operator Expression<int>^()
{
return _value;
}
};
/// <summary>
/// Class that represents variable of type unsigned long long int (UInt64).
/// </summary>
template<> public ref class Var<unsigned long long int> : ExpressionWrapper<unsigned long long int>
{
public:
Var<unsigned long long int>(String^ name)
{
_value = gcnew Variable<unsigned long long int>(name);
}
operator Expression<unsigned long long int>^()
{
return _value;
}
};
/// <summary>
/// Class that represents variable of type unsigned short (UInt16).
/// </summary>
template<> public ref class Var<unsigned short> : ExpressionWrapper<unsigned short>
{
public:
Var<unsigned short>(String^ name)
{
_value = gcnew Variable<unsigned short>(name);
}
operator Expression<unsigned short>^()
{
return _value;
}
};
/// <summary>
/// Class that represents variable of type unsigned int (UInt32).
/// </summary>
template<> public ref class Var<unsigned int> : ExpressionWrapper<unsigned int>
{
public:
Var<unsigned int>(String^ name)
{
_value = gcnew Variable<unsigned int>(name);
}
operator Expression<unsigned int>^()
{
return _value;
}
};
/// <summary>
/// Class that represents variable of type bool.
/// </summary>
template<> public ref class Var<bool> : ExpressionWrapper<bool>
{
public:
Var<bool>(String^ name)
{
_value = gcnew Variable<bool>(name);
}
operator Expression<bool>^()
{
return _value;
}
};
/// <summary>
/// Class that represents variable of type unicode wchar_t (Char).
/// </summary>
template<> public ref class Var<wchar_t> : ExpressionWrapper<wchar_t>
{
public:
Var<wchar_t>(String^ name)
{
_value = gcnew Variable<wchar_t>(name);
}
operator Expression<wchar_t>^()
{
return _value;
}
};
/// <summary>
/// Class that represents variable of type System::String.
/// </summary>
template<> public ref class Var<String^> : ExpressionWrapper<String^>
{
public:
Var<String^>(String^ name)
{
_value = gcnew Variable<String^>(name);
}
operator Expression<String^>^()
{
return _value;
}
};
}
}