/// <summary>
/// Adds the given values incrementally
/// </summary>
/// <param name="left">The left operand</param>
/// <param name="right">The right operand</param>
/// <returns>The incremental sum</returns>
public static INotifyExpression <double> Add(INotifyExpression <double> left, INotifyExpression <double> right)
{
return(new ObservableDoublePlus(left, right));
}
public ObservableLogicNot(INotifyExpression <bool> inner)
: base(inner)
{
}
public ObservableULongDivide(INotifyExpression <ulong> left, INotifyExpression <ulong> right)
: base(left, right)
{
}
public ObservableLongModulo(INotifyExpression <long> left, INotifyExpression <long> right)
: base(left, right)
{
}
public ModelFuncExtractionParameter(INotifyExpression <TBase1> base1, Func <TBase1, T> memberGetter)
{
Base1 = base1;
MemberGetter = memberGetter;
}
protected ObservableReversableBinaryExpressionBase(INotifyExpression <TLeft> left, INotifyExpression <TRight> right)
: base(left, right)
{
}
public ObservableFloatModulo(INotifyExpression <float> left, INotifyExpression <float> right)
: base(left, right)
{
}
public static INotifyExpression <ulong> Modulo(INotifyExpression <ulong> left, INotifyExpression <ulong> right)
{
return(new ObservableULongModulo(left, right));
}
/// <summary>
/// Computes an incremental modulo of the operands
/// </summary>
/// <param name="left">The left operand</param>
/// <param name="right">The right operand</param>
/// <returns>The incremental modulo</returns>
public static INotifyExpression <float> Modulo(INotifyExpression <float> left, INotifyExpression <float> right)
{
return(new ObservableFloatModulo(left, right));
}
/// <summary>
/// Multiplies the given values incrementally
/// </summary>
/// <param name="left">The left factor</param>
/// <param name="right">The right factor</param>
/// <returns>The incremental product</returns>
public static INotifyExpression <double> Multiply(INotifyExpression <double> left, INotifyExpression <double> right)
{
return(new ObservableDoubleMultiply(left, right));
}
public static INotifyExpression <uint> Modulo(INotifyExpression <uint> left, INotifyExpression <uint> right)
{
return(new ObservableUIntModulo(left, right));
}
/// <summary>
/// Multiplies the given values incrementally
/// </summary>
/// <param name="left">The left factor</param>
/// <param name="right">The right factor</param>
/// <returns>The incremental product</returns>
public static INotifyExpression <long> Multiply(INotifyExpression <long> left, INotifyExpression <long> right)
{
return(new ObservableLongMultiply(left, right));
}
/// <summary>
/// Multiplies the given values incrementally
/// </summary>
/// <param name="left">The left factor</param>
/// <param name="right">The right factor</param>
/// <returns>The incremental product</returns>
public static INotifyExpression <int> Multiply(INotifyExpression <int> left, INotifyExpression <int> right)
{
return(new ObservableIntMultiply(left, right));
}
/// <summary>
/// Adds the given values incrementally
/// </summary>
/// <param name="left">The left operand</param>
/// <param name="right">The right operand</param>
/// <returns>The incremental sum</returns>
public static INotifyExpression <string> Add(INotifyExpression <string> left, INotifyExpression <string> right)
{
return(new ObservableStringPlus(left, right));
}
public ObservableBinaryExpression(INotifyExpression <TLeft> left, INotifyExpression <TRight> right, Func <TLeft, TRight, TResult> implementation)
: base(left, right)
{
Implementation = implementation;
}
/// <summary>
/// Computes an incremental modulo of the operands
/// </summary>
/// <param name="left">The left operand</param>
/// <param name="right">The right operand</param>
/// <returns>The incremental modulo</returns>
public static INotifyExpression <double> Modulo(INotifyExpression <double> left, INotifyExpression <double> right)
{
return(new ObservableDoubleModulo(left, right));
}
public ObservableCoalesceExpression(INotifyExpression <T> left, INotifyExpression <T> right)
: base(left, right)
{
}
/// <summary>
/// Coalesces the given value with the given alternative
/// </summary>
/// <typeparam name="T">The element type</typeparam>
/// <param name="value">The incremental value that should be coalesced</param>
/// <param name="ifNull">The incremental coalesce value</param>
/// <returns>An incremental coalesced value</returns>
public static INotifyExpression <T> Coalesce <T>(INotifyExpression <T> value, INotifyExpression <T> ifNull) where T : class
{
return(new ObservableCoalesceExpression <T>(value, ifNull));
}
public ObservableNewArray3Expression(INotifyExpression <int> bounds1, INotifyExpression <int> bounds2, INotifyExpression <int> bounds3)
{
if (bounds1 == null)
{
throw new ArgumentNullException("bounds1");
}
if (bounds2 == null)
{
throw new ArgumentNullException("bounds2");
}
if (bounds3 == null)
{
throw new ArgumentNullException("bounds3");
}
Bounds1 = bounds1;
Bounds2 = bounds2;
Bounds3 = bounds3;
bounds1.ValueChanged += ArgumentChanged;
bounds2.ValueChanged += ArgumentChanged;
bounds3.ValueChanged += ArgumentChanged;
}
/// <summary>
/// Performs an incremental right shift
/// </summary>
/// <param name="left">The value to be shifted</param>
/// <param name="right">The shift</param>
/// <returns>An incremental shift</returns>
public static INotifyExpression <long> RightShift(INotifyExpression <long> left, INotifyExpression <int> right)
{
return(new ObservableLongRightShift(left, right));
}
public ObservableDoubleModulo(INotifyExpression <double> left, INotifyExpression <double> right)
: base(left, right)
{
}
/// <summary>
/// Performs an incremental left shift
/// </summary>
/// <param name="left">The value to be shifted</param>
/// <param name="right">The shift</param>
/// <returns>An incremental shift</returns>
public static INotifyExpression <int> LeftShift(INotifyExpression <int> left, INotifyExpression <int> right)
{
return(new ObservableIntLeftShift(left, right));
}
public ObservableUIntModulo(INotifyExpression <uint> left, INotifyExpression <uint> right)
: base(left, right)
{
}
public static INotifyExpression <ulong> LeftShift(INotifyExpression <ulong> left, INotifyExpression <int> right)
{
return(new ObservableULongLeftShift(left, right));
}
public ObservableMethodLensProxyCall(MethodInfo proxyMethod, INotifyExpression <T> target, LensPut <T, TResult> lensPut) : base(target, proxyMethod)
{
LensPut = lensPut;
}
/// <summary>
/// Incrementally determines whether the left value is greather than or equals to the right value
/// </summary>
/// <typeparam name="T">The type of the elements</typeparam>
/// <param name="left">The left operand</param>
/// <param name="right">The right operand</param>
/// <returns>An incremental value determing whether the left operand is greather than or equals to the right operand</returns>
public static INotifyExpression <bool> GreatherThanOrEquals <T>(INotifyExpression <T> left, INotifyExpression <T> right)
where T : IComparable <T>
{
return(new ObservableGreatherThanOrEquals <T>(left, right));
}
public ObservableLogicXor(INotifyExpression <bool> left, INotifyExpression <bool> right)
: base(left, right)
{
}
/// <summary>
/// Incrementally determines whether the left value is less than the right value
/// </summary>
/// <typeparam name="T">The type of the elements</typeparam>
/// <param name="left">The left operand</param>
/// <param name="right">The right operand</param>
/// <returns>An incremental value determing whether the left operand is less than the right operand</returns>
public static INotifyExpression <bool> LessThan <T>(INotifyExpression <T> left, INotifyExpression <T> right)
where T : IComparable <T>
{
return(new ObservableLessThan <T>(left, right));
}
public ObservableIntDivide(INotifyExpression <int> left, INotifyExpression <int> right)
: base(left, right)
{
}
/// <summary>
/// Adds the given values incrementally
/// </summary>
/// <param name="left">The left operand</param>
/// <param name="right">The right operand</param>
/// <returns>The incremental sum</returns>
public static INotifyExpression <float> Add(INotifyExpression <float> left, INotifyExpression <float> right)
{
return(new ObservableFloatPlus(left, right));
}
