public void ILBytesForDifferentDelegatesAreTheSameTest()
{
var x = new Func<object, int>(y => 0);
var z = new Func<object, int>(y => 0);
Assert.False(x == z);
var xBytes = x.GetMethodInfo().GetILBytes();
Assert.False(xBytes.IsNullOrEmpty());
var zBytes = x.GetMethodInfo().GetILBytes();
Assert.False(zBytes.IsNullOrEmpty());
Assert.True(xBytes.EqualTo(zBytes));
}
/// <summary>Invokes the method from this assembly in another process using the specified arguments.</summary>
/// <param name="method">The method to invoke.</param>
/// <param name="start">true if this function should Start the Process; false if that responsibility is left up to the caller.</param>
internal static RemoteInvokeHandle RemoteInvoke(
Func<int> method,
bool start = true,
ProcessStartInfo psi = null)
{
return RemoteInvoke(method.GetMethodInfo(), Array.Empty<string>(), start, psi);
}
public void Static <T1, T2, T3, TResult>(Func <T1, T2, T3, TResult> target, Func <T1, T2, T3, TResult> deputy)
{
SwapMethod(
IsStatic(NotNull(target?.GetMethodInfo(), nameof(target))),
IsStatic(NotNull(deputy?.GetMethodInfo(), nameof(deputy)))
);
}
/// <summary>Invokes the method from this assembly in another process using the specified arguments.</summary>
/// <param name="method">The method to invoke.</param>
/// <param name="arg1">The first argument to pass to the method.</param>
/// <param name="arg2">The second argument to pass to the method.</param>
/// <param name="arg3">The third argument to pass to the method.</param>
/// <param name="options">Options to use for the invocation.</param>
internal static RemoteInvokeHandle RemoteInvoke(
Func<string, string, string, int> method,
string arg1, string arg2, string arg3,
RemoteInvokeOptions options = null)
{
return RemoteInvoke(method.GetMethodInfo(), new[] { arg1, arg2, arg3 }, options);
}
/// <summary>Invokes the method from this assembly in another process using the specified arguments.</summary>
/// <param name="method">The method to invoke.</param>
/// <param name="arg1">The first argument to pass to the method.</param>
/// <param name="arg2">The second argument to pass to the method.</param>
/// <param name="arg3">The third argument to pass to the method.</param>
/// <param name="start">true if this function should Start the Process; false if that responsibility is left up to the caller.</param>
internal static RemoteInvokeHandle RemoteInvoke(
Func<string, string, string, int> method,
string arg1, string arg2, string arg3,
bool start = true,
ProcessStartInfo psi = null)
{
return RemoteInvoke(method.GetMethodInfo(), new[] { arg1, arg2, arg3 }, start, psi);
}
/// <summary>
/// Accept the specified trigger, execute exit actions and re-execute entry actions.
/// Reentry behaves as though the configured state transitions to an identical sibling state.
/// </summary>
/// <param name="trigger">The accepted trigger.</param>
/// <param name="guard">Function that must return true in order for the
/// trigger to be accepted.</param>
/// <param name="guardDescription">Guard description</param>
/// <returns>The reciever.</returns>
/// <remarks>
/// Applies to the current state only. Will not re-execute superstate actions, or
/// cause actions to execute transitioning between super- and sub-states.
/// </remarks>
public StateConfiguration PermitReentryIf(TTrigger trigger, Func <bool> guard, string guardDescription = null)
{
return(InternalPermitIf(
trigger,
_representation.UnderlyingState,
guard,
guardDescription ?? guard?.GetMethodInfo().Name));
}
public void ILBytesForDelegateAreAvailableTest()
{
var x = new Func<object, int>(y => 0);
var bytes = x.GetMethodInfo().GetILBytes();
Assert.False(bytes.IsNullOrEmpty());
}
public void Instance <TClass, T1, T2, T3, TResult>(Func <T1, T2, T3, TResult> target, Func <TClass, T1, T2, T3, TResult> deputy)
where TClass : class
{
SwapMethod(
NotStatic(NotNull(target?.GetMethodInfo(), nameof(target))),
IsStatic(NotNull(deputy?.GetMethodInfo(), nameof(deputy)))
);
}
/// <summary>
/// Accept the specified trigger and transition to the destination state.
/// </summary>
/// <param name="trigger">The accepted trigger.</param>
/// <param name="destinationState">The state that the trigger will cause a
/// transition to.</param>
/// <param name="guard">Function that must return true in order for the
/// trigger to be accepted.</param>
/// <param name="guardDescription">Guard description</param>
/// <returns>The reciever.</returns>
public StateConfiguration PermitIf(TTrigger trigger, TState destinationState, Func <bool> guard, string guardDescription = null)
{
EnforceNotIdentityTransition(destinationState);
return(InternalPermitIf(
trigger,
destinationState,
guard,
guardDescription ?? guard?.GetMethodInfo().Name));
}
/// <summary>
/// Accept the specified trigger and transition to the destination state, calculated
/// dynamically by the supplied function.
/// </summary>
/// <param name="trigger">The accepted trigger.</param>
/// <param name="destinationStateSelector">Function to calculate the state
/// that the trigger will cause a transition to.</param>
/// <param name="guard">Function that must return true in order for the
/// trigger to be accepted.</param>
/// <param name="guardDescription">Guard description</param>
/// <returns>The reciever.</returns>
public StateConfiguration PermitDynamicIf(TTrigger trigger, Func <TState> destinationStateSelector, Func <bool> guard, string guardDescription = null)
{
Enforce.ArgumentNotNull(destinationStateSelector, nameof(destinationStateSelector));
return(InternalPermitDynamicIf(
trigger,
args => destinationStateSelector(),
guard,
guardDescription ?? guard?.GetMethodInfo().Name));
}
public WeakRelayCommand(Action <object> executeCallback, Func <object, bool> canExecuteCallback = null)
{
ExecuteTargetReference = new WeakReference <object>(executeCallback.Target);
if (canExecuteCallback != null)
{
CanExecuteTargetReference = new WeakReference <object>(canExecuteCallback.Target);
}
ExecuteCallbackInfo = executeCallback.GetMethodInfo();
CanExecuteCallbackInfo = canExecuteCallback?.GetMethodInfo();
}
/// <summary>
/// Ignore the specified trigger when in the configured state, if the guard
/// returns true..
/// </summary>
/// <param name="trigger">The trigger to ignore.</param>
/// <param name="guardDescription">Guard description</param>
/// <param name="guard">Function that must return true in order for the
/// trigger to be ignored.</param>
/// <returns>The receiver.</returns>
public StateConfiguration IgnoreIf(TTrigger trigger, Func <bool> guard, string guardDescription = null)
{
Enforce.ArgumentNotNull(guard, nameof(guard));
_representation.AddTriggerBehaviour(
new IgnoredTriggerBehaviour(
trigger,
guard,
guardDescription ?? guard?.GetMethodInfo().Name));
return(this);
}
/// <summary>
/// Accept the specified trigger and transition to the destination state, calculated
/// dynamically by the supplied function.
/// </summary>
/// <param name="trigger">The accepted trigger.</param>
/// <param name="destinationStateSelector">Function to calculate the state
/// that the trigger will cause a transition to.</param>
/// <param name="guard">Function that must return true in order for the
/// trigger to be accepted.</param>
/// <param name="guardDescription">Guard description</param>
/// <returns>The reciever.</returns>
/// <typeparam name="TArg0">Type of the first trigger argument.</typeparam>
public StateConfiguration PermitDynamicIf <TArg0>(TriggerWithParameters <TArg0> trigger, Func <TArg0, TState> destinationStateSelector, Func <bool> guard, string guardDescription = null)
{
Enforce.ArgumentNotNull(trigger, nameof(trigger));
Enforce.ArgumentNotNull(destinationStateSelector, nameof(destinationStateSelector));
return(InternalPermitDynamicIf(
trigger.Trigger,
args => destinationStateSelector(
ParameterConversion.Unpack <TArg0>(args, 0)),
guard,
guardDescription ?? guard?.GetMethodInfo().Name));
}
public static void Run(this ApplicationInstance applicationInstance,
Func<Task> staticMethodToExecute,
TestInjectorSettings testInjectorSettings = null)
{
var methodInfo =
#if NET40
staticMethodToExecute.Method;
#else
staticMethodToExecute.GetMethodInfo();
#endif
if (!methodInfo.IsStatic)
throw new InvalidOperationException("Method must be static - don't reference any outside parameters");
RunMethodImpl(applicationInstance, methodInfo, testInjectorSettings);
}
private async Task Accept(Func <byte[], Task <byte[]> > callback)
{
//run this through Task.Run so we can respond to the waitToken if its called for.
using (var client = await Task.Run(() => tcpListener.AcceptTcpClientAsync(), _waitToken))
{
if (_waitToken.IsCancellationRequested)
{
return;
}
client.Client.NoDelay = true;
//client.Client.LingerState = new LingerOption(true, 0);
var readBuffer = new byte[32768];
using (var stream = client.GetStream())
{
using (var memoryStream = new MemoryStream())
{
while (true)
{
using (var readTokenSource = new CancellationTokenSource(readTimeout))
{
readTokenSource.Token.Register(() =>
{
if (memoryStream != null)
{
memoryStream.Close();
memoryStream.Dispose();
}
if (stream != null)
{
stream.Close();
stream.Dispose();
}
if (client != null)
{
//if (client.Client != null) client.Client.Disconnect(false);
client.Close();
client.Dispose();
}
readBuffer = null;
});
var read = await stream.ReadAsync(readBuffer, 0, readBuffer.Length,
readTokenSource.Token);
if (read > 0)
{
if (readBuffer[0] == 63)
{
var payload = _serializer.Serialize(new
{
_configuration?.DebugMode,
_configuration?.Environment,
_configuration?.Version,
Owner = _onReceived?.GetMethodInfo()?.DeclaringType?.FullName,
Counter,
Environment.WorkingSet,
Environment.MachineName,
OnlineSince = _captureAndAggregate.StartDateTimeOffset,
OnlineDurationInSeconds =
(DateTimeOffset.UtcNow - _captureAndAggregate.StartDateTimeOffset)
.TotalSeconds,
TotalAverage = _captureAndAggregate.TotalAverage(),
Last5SecondsAverage = _captureAndAggregate.Last5SecondsAverage()
});
await stream.WriteAsync(payload, 0, payload.Length, _waitToken);
await stream.FlushAsync(_waitToken);
break;
}
if (read > 0)
{
await memoryStream.WriteAsync(readBuffer, 0, read, _waitToken);
}
if (read <= 0 || readBuffer[read - 1] == PacketFormatter?.PacketTerminator)
{
var data = memoryStream.ToArray();
if (PacketFormatter != null)
{
data = PacketFormatter.RemoveFooter(data);
}
//Client is done sending, process the packet
var result = await callback(data);
if (result != null && result.Any())
{
if (PacketFormatter != null)
{
result = PacketFormatter.AddFooter(result);
}
await stream.WriteAsync(result, 0, result.Length, _waitToken);
await stream.FlushAsync(_waitToken);
}
result = null;
data = null;
break;
}
}
else
{
break;
}
}
}
memoryStream.Close();
memoryStream.Dispose();
}
stream.Close();
stream.Dispose();
}
readBuffer = null;
client.Client.Disconnect(false);
client.Close();
client.Dispose();
}
}
private WrapperDelegate makeFastWrapper(ConstructorInfo constructorInfo)
{
Expression tree = null;
var target = Expression.Parameter(typeof(object), "target");
var context = Expression.Parameter(typeof(Context), "context");
var arguments = Expression.Parameter(typeof(Expressions.Expression[]), "arguments");
var argumentsObjectPrm = Expression.Parameter(typeof(Arguments), "argumentsObject");
var argumentsObject = Expression.Condition(
Expression.NotEqual(argumentsObjectPrm, Expression.Constant(null)),
argumentsObjectPrm,
Expression.Assign(argumentsObjectPrm, Expression.Call(((Func <Expressions.Expression[], Context, Arguments>)Tools.CreateArguments).GetMethodInfo(), arguments, context)));
if (_parameters.Length == 0)
{
tree = Expression.New(constructorInfo);
}
else
{
if (_parameters.Length == 1 && _parameters[0].ParameterType == typeof(Arguments))
{
tree = Expression.New(constructorInfo, argumentsObject);
}
else
{
Func <Expressions.Expression[], Context, int, object> processArg = processArgument;
Func <Expressions.Expression[], Context, int, object> processArgTail = processArgumentsTail;
Func <int, JSValue, object> convertArg = convertArgument;
var prms = new Expression[_parameters.Length];
for (var i = 0; i < prms.Length; i++)
{
prms[i] = Expression.Convert(
Expression.Call(
Expression.Constant(this),
i + 1 < prms.Length ? processArg.GetMethodInfo() : processArgTail.GetMethodInfo(),
arguments,
context,
Expression.Constant(i)),
_parameters[i].ParameterType);
}
tree = Expression.New(constructorInfo, prms);
for (var i = 0; i < prms.Length; i++)
{
prms[i] = Expression.Convert(
Expression.Call(
Expression.Constant(this),
convertArg.GetMethodInfo(),
Expression.Constant(i),
Expression.Call(argumentsObject, ArgumentsGetItemMethod, Expression.Constant(i))),
_parameters[i].ParameterType);
}
Expression treeWithObjectAsSource;
treeWithObjectAsSource = Expression.New(constructorInfo, prms);
tree = Expression.Condition(Expression.Equal(argumentsObjectPrm, Expression.Constant(null)),
tree,
treeWithObjectAsSource);
}
}
try
{
return(Expression
.Lambda <WrapperDelegate>(
Expression.Convert(tree, typeof(object)),
constructorInfo.DeclaringType.Name,
new[]
{
target,
context,
arguments,
argumentsObjectPrm
})
.Compile());
}
catch
{
throw;
}
}
public WeakFunc(object target, Func <TResult> func, bool keepTargetAlive = false)
{
#if NETFX_CORE
if (func.GetMethodInfo().IsStatic)
#else
if (func.Method.IsStatic)
#endif
{
_staticFunc = func;
if (target != null)
{
// Keep a reference to the target to control the
// WeakAction's lifetime.
Reference = new WeakReference(target);
}
return;
}
#if SILVERLIGHT
if (!func.Method.IsPublic ||
(target != null &&
!target.GetType().IsPublic &&
!target.GetType().IsNestedPublic))
{
_func = func;
}
else
{
var name = func.Method.Name;
if (name.Contains("<") &&
name.Contains(">"))
{
// Anonymous method
_func = func;
}
else
{
Method = func.Method;
FuncReference = new WeakReference(func.Target);
LiveReference = keepTargetAlive ? func.Target : null;
}
}
#else
#if NETFX_CORE
Method = func.GetMethodInfo();
#else
Method = func.Method;
#endif
FuncReference = new WeakReference(func.Target);
#endif
LiveReference = keepTargetAlive ? func.Target : null;
Reference = new WeakReference(target);
#if DEBUG
if (FuncReference != null &&
FuncReference.Target != null &&
!keepTargetAlive)
{
var type = FuncReference.Target.GetType();
if (type.Name.StartsWith("<>") &&
type.Name.Contains("DisplayClass"))
{
System.Diagnostics.Debug.WriteLine(
"You are attempting to register a lambda with a closure without using keepTargetAlive. Are you sure? Check http://galasoft.ch/s/mvvmweakaction for more info.");
}
}
#endif
}
public override Expression Visit(BinaryOperatorNode nodeIn)
{
Expression left = TranslateNode(nodeIn.Left);
Expression right = TranslateNode(nodeIn.Right);
if (left.Type != right.Type)
{
Type leftType = left.Type;
Type rightType = right.Type;
if (OeExpressionHelper.IsNullable(left) && !OeExpressionHelper.IsNull(left))
{
if (OeExpressionHelper.IsNull(right))
{
right = OeConstantToVariableVisitor.NullConstantExpression;
}
else
{
leftType = Nullable.GetUnderlyingType(left.Type);
}
}
else if (OeExpressionHelper.IsNullable(right) && !OeExpressionHelper.IsNull(right))
{
if (OeExpressionHelper.IsNull(left))
{
left = OeConstantToVariableVisitor.NullConstantExpression;
}
else
{
rightType = Nullable.GetUnderlyingType(right.Type);
}
}
if (right.Type != left.Type)
{
if (left is ConstantExpression)
{
ConstantExpression oldConstant = left as ConstantExpression;
ConstantExpression newConstant = OeExpressionHelper.ConstantChangeType(oldConstant, rightType);
if (oldConstant != newConstant)
{
ReplaceConstant(oldConstant, newConstant);
}
left = Expression.Convert(newConstant, right.Type);
}
else if (right is ConstantExpression)
{
ConstantExpression oldConstant = right as ConstantExpression;
ConstantExpression newConstant = OeExpressionHelper.ConstantChangeType(oldConstant, leftType);
if (oldConstant != newConstant)
{
ReplaceConstant(oldConstant, newConstant);
}
right = Expression.Convert(newConstant, left.Type);
}
else
{
Type precedenceType = OeExpressionHelper.GetTypeConversion(left.Type, right.Type);
if (left.Type != precedenceType)
{
left = Expression.Convert(left, precedenceType);
}
if (right.Type != precedenceType)
{
right = Expression.Convert(right, precedenceType);
}
}
}
}
ExpressionType binaryType = OeExpressionHelper.ToExpressionType(nodeIn.OperatorKind);
if (!(binaryType == ExpressionType.Equal || binaryType == ExpressionType.NotEqual))
{
if (left.Type == typeof(String))
{
Func <String, String, int> compareToFunc = String.Compare;
MethodCallExpression compareToCall = Expression.Call(null, compareToFunc.GetMethodInfo(), left, right);
return(Expression.MakeBinary(binaryType, compareToCall, OeConstantToVariableVisitor.ZeroStringCompareConstantExpression));
}
Type underlyingType;
if (left.Type.IsEnum)
{
Type enumUnderlyingType = Enum.GetUnderlyingType(left.Type);
left = ConvertEnumExpression(left, enumUnderlyingType);
right = ConvertEnumExpression(right, enumUnderlyingType);
}
else if ((underlyingType = Nullable.GetUnderlyingType(left.Type)) != null && underlyingType.IsEnum)
{
Type enumUnderlyingType = Enum.GetUnderlyingType(underlyingType);
Type nullableUnderlyingType = typeof(Nullable <>).MakeGenericType(enumUnderlyingType);
left = ConvertEnumExpression(left, nullableUnderlyingType);
right = ConvertEnumExpression(right, nullableUnderlyingType);
}
}
return(Expression.MakeBinary(binaryType, left, right));
UnaryExpression ConvertEnumExpression(Expression e, Type nullableType)
{
if (e is UnaryExpression unaryExpression)
{
var value = (ConstantExpression)unaryExpression.Operand;
return(Expression.Convert(value, nullableType));
}
return(Expression.Convert(e, nullableType));
}
}
public void AddFunction <TIn, TIn2, TOut>(string rawName, Func <TIn, TIn2, TOut> func)
{
AddMethodInfo(rawName, func.Target, func.GetMethodInfo());
}
public TypeTransform AddStaticMethod <T1, T2, TResult>(Func <T1, T2, TResult> method, string tsDecl = null)
{
return(AddStaticMethod(method.GetMethodInfo(), tsDecl));
}
public TypeTransform AddExtensionMethod <TResult>(Func <TResult> method, string tsDecl = null)
{
return(AddExtensionMethod(method.GetMethodInfo(), tsDecl));
}
/// <summary>Invokes the method from this assembly in another process using the specified arguments.</summary>
/// <param name="method">The method to invoke.</param>
/// <param name="options">Options to use for the invocation.</param>
internal static RemoteInvokeHandle RemoteInvoke(
Func <Task <int> > method,
RemoteInvokeOptions options = null)
{
return(RemoteInvoke(method.GetMethodInfo(), Array.Empty <string>(), options));
}
private Expression ProduceComparatorExpressionForSingleFieldCondition(Expression fieldExpression, Type fieldType, bool isFieldTypeNullable = false)
{
// this must determine an appropriate runtime comparison given the field type, the predicate, and the comparand
TypeCode fieldTypeCode = Type.GetTypeCode(fieldType);
switch (fieldTypeCode)
{
case TypeCode.Boolean:
{
this.ThrowOnInvalidFilter(fieldType, !this.comparandBoolean.HasValue);
switch (this.predicate)
{
case Predicate.Equal:
// fieldValue == this.comparandBoolean.Value;
return(Expression.Equal(fieldExpression, Expression.Constant(this.comparandBoolean.Value, isFieldTypeNullable ? typeof(bool?) : typeof(bool))));
case Predicate.NotEqual:
// fieldValue != this.comparandBoolean.Value;
return(Expression.NotEqual(fieldExpression, Expression.Constant(this.comparandBoolean.Value, isFieldTypeNullable ? typeof(bool?) : typeof(bool))));
default:
this.ThrowOnInvalidFilter(fieldType);
break;
}
}
break;
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.Byte:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
case TypeCode.Single:
case TypeCode.Double:
{
if (fieldType.GetTypeInfo().IsEnum)
{
// this is actually an Enum
object enumValue = null;
try
{
enumValue = Enum.Parse(fieldType, this.comparand, true);
}
catch (Exception)
{
// we must throw unless this.predicate is either Contains or DoesNotContain, in which case it's ok
this.ThrowOnInvalidFilter(fieldType, this.predicate != Predicate.Contains && this.predicate != Predicate.DoesNotContain);
}
Type enumUnderlyingType = fieldType.GetTypeInfo().GetEnumUnderlyingType();
switch (this.predicate)
{
case Predicate.Equal:
// fieldValue == enumValue
return(Expression.Equal(fieldExpression, Expression.Constant(enumValue, isFieldTypeNullable ? typeof(Nullable <>).MakeGenericType(fieldType) : fieldType)));
case Predicate.NotEqual:
// fieldValue != enumValue
return(Expression.NotEqual(fieldExpression, Expression.Constant(enumValue, isFieldTypeNullable ? typeof(Nullable <>).MakeGenericType(fieldType) : fieldType)));
case Predicate.LessThan:
// (int)fieldValue < (int)enumValue
// (int?)fieldValue < (int?)enumValue
Type underlyingType = isFieldTypeNullable ? typeof(Nullable <>).MakeGenericType(enumUnderlyingType) : enumUnderlyingType;
return(Expression.LessThan(
Expression.Convert(fieldExpression, underlyingType),
Expression.Convert(Expression.Constant(enumValue, fieldType), underlyingType)));
case Predicate.GreaterThan:
// (int)fieldValue > (int)enumValue
// (int?)fieldValue > (int?)enumValue
underlyingType = isFieldTypeNullable ? typeof(Nullable <>).MakeGenericType(enumUnderlyingType) : enumUnderlyingType;
return(Expression.GreaterThan(
Expression.Convert(fieldExpression, underlyingType),
Expression.Convert(Expression.Constant(enumValue, fieldType), underlyingType)));
case Predicate.LessThanOrEqual:
// (int)fieldValue <= (int)enumValue
// (int?)fieldValue <= (int?)enumValue
underlyingType = isFieldTypeNullable ? typeof(Nullable <>).MakeGenericType(enumUnderlyingType) : enumUnderlyingType;
return(Expression.LessThanOrEqual(
Expression.Convert(fieldExpression, underlyingType),
Expression.Convert(Expression.Constant(enumValue, fieldType), underlyingType)));
case Predicate.GreaterThanOrEqual:
// (int)fieldValue >= (int)enumValue
// (int?)fieldValue >= (int?)enumValue
underlyingType = isFieldTypeNullable ? typeof(Nullable <>).MakeGenericType(enumUnderlyingType) : enumUnderlyingType;
return(Expression.GreaterThanOrEqual(
Expression.Convert(fieldExpression, underlyingType),
Expression.Convert(Expression.Constant(enumValue, fieldType), underlyingType)));
case Predicate.Contains:
// fieldValue.ToString(CultureInfo.InvariantCulture).IndexOf(this.comparand, StringComparison.OrdinalIgnoreCase) != -1
Expression toStringCall = Expression.Call(fieldExpression, isFieldTypeNullable ? ValueTypeToStringMethodInfo : ObjectToStringMethodInfo);
Expression indexOfCall = Expression.Call(toStringCall, StringIndexOfMethodInfo, Expression.Constant(this.comparand), Expression.Constant(StringComparison.OrdinalIgnoreCase));
return(Expression.NotEqual(indexOfCall, Expression.Constant(-1)));
case Predicate.DoesNotContain:
// fieldValue.ToString(CultureInfo.InvariantCulture).IndexOf(this.comparand, StringComparison.OrdinalIgnoreCase) == -1
toStringCall = Expression.Call(fieldExpression, isFieldTypeNullable ? ValueTypeToStringMethodInfo : ObjectToStringMethodInfo);
indexOfCall = Expression.Call(toStringCall, StringIndexOfMethodInfo, Expression.Constant(this.comparand), Expression.Constant(StringComparison.OrdinalIgnoreCase));
return(Expression.Equal(indexOfCall, Expression.Constant(-1)));
default:
this.ThrowOnInvalidFilter(fieldType);
break;
}
}
else
{
// this is a regular numerical type
// in order for the expression to compile, we must cast to double unless it's already double
// we're using double as the lowest common denominator for all numerical types
Expression fieldConvertedExpression = fieldTypeCode == TypeCode.Double
? fieldExpression
: Expression.ConvertChecked(fieldExpression, isFieldTypeNullable ? typeof(double?) : typeof(double));
switch (this.predicate)
{
case Predicate.Equal:
this.ThrowOnInvalidFilter(fieldType, !this.comparandDouble.HasValue);
return(Expression.Equal(
fieldConvertedExpression,
Expression.Constant(this.comparandDouble.Value, isFieldTypeNullable ? typeof(Nullable <>).MakeGenericType(typeof(double)) : typeof(double))));
case Predicate.NotEqual:
this.ThrowOnInvalidFilter(fieldType, !this.comparandDouble.HasValue);
return(Expression.NotEqual(
fieldConvertedExpression,
Expression.Constant(this.comparandDouble.Value, isFieldTypeNullable ? typeof(Nullable <>).MakeGenericType(typeof(double)) : typeof(double))));
case Predicate.LessThan:
this.ThrowOnInvalidFilter(fieldType, !this.comparandDouble.HasValue);
return(Expression.LessThan(
fieldConvertedExpression,
Expression.Constant(this.comparandDouble.Value, isFieldTypeNullable ? typeof(Nullable <>).MakeGenericType(typeof(double)) : typeof(double))));
case Predicate.GreaterThan:
this.ThrowOnInvalidFilter(fieldType, !this.comparandDouble.HasValue);
return(Expression.GreaterThan(
fieldConvertedExpression,
Expression.Constant(this.comparandDouble.Value, isFieldTypeNullable ? typeof(Nullable <>).MakeGenericType(typeof(double)) : typeof(double))));
case Predicate.LessThanOrEqual:
this.ThrowOnInvalidFilter(fieldType, !this.comparandDouble.HasValue);
return(Expression.LessThanOrEqual(
fieldConvertedExpression,
Expression.Constant(this.comparandDouble.Value, isFieldTypeNullable ? typeof(Nullable <>).MakeGenericType(typeof(double)) : typeof(double))));
case Predicate.GreaterThanOrEqual:
this.ThrowOnInvalidFilter(fieldType, !this.comparandDouble.HasValue);
return(Expression.GreaterThanOrEqual(
fieldConvertedExpression,
Expression.Constant(this.comparandDouble.Value, isFieldTypeNullable ? typeof(Nullable <>).MakeGenericType(typeof(double)) : typeof(double))));
case Predicate.Contains:
// fieldValue.ToString(CultureInfo.InvariantCulture).IndexOf(this.comparand, StringComparison.OrdinalIgnoreCase) != -1
Expression toStringCall = isFieldTypeNullable
? Expression.Call(fieldConvertedExpression, NullableDoubleToStringMethodInfo)
: Expression.Call(fieldConvertedExpression, DoubleToStringMethodInfo, Expression.Constant(CultureInfo.InvariantCulture));
Expression indexOfCall = Expression.Call(toStringCall, StringIndexOfMethodInfo, Expression.Constant(this.comparand), Expression.Constant(StringComparison.OrdinalIgnoreCase));
return(Expression.NotEqual(indexOfCall, Expression.Constant(-1)));
case Predicate.DoesNotContain:
// fieldValue.ToString(CultureInfo.InvariantCulture).IndexOf(this.comparand, StringComparison.OrdinalIgnoreCase) == -1
toStringCall = isFieldTypeNullable
? Expression.Call(fieldConvertedExpression, NullableDoubleToStringMethodInfo)
: Expression.Call(fieldConvertedExpression, DoubleToStringMethodInfo, Expression.Constant(CultureInfo.InvariantCulture));
indexOfCall = Expression.Call(toStringCall, StringIndexOfMethodInfo, Expression.Constant(this.comparand), Expression.Constant(StringComparison.OrdinalIgnoreCase));
return(Expression.Equal(indexOfCall, Expression.Constant(-1)));
default:
this.ThrowOnInvalidFilter(fieldType);
break;
}
}
}
break;
case TypeCode.String:
{
Expression fieldValueOrEmptyString = Expression.Condition(Expression.Equal(fieldExpression, Expression.Constant(null)), Expression.Constant(string.Empty), fieldExpression);
Expression indexOfCall = Expression.Call(fieldValueOrEmptyString, StringIndexOfMethodInfo, Expression.Constant(this.comparand), Expression.Constant(StringComparison.OrdinalIgnoreCase));
switch (this.predicate)
{
case Predicate.Equal:
// (fieldValue ?? string.Empty).Equals(this.comparand, StringComparison.OrdinalIgnoreCase)
return(Expression.Call(fieldValueOrEmptyString, StringEqualsMethodInfo, Expression.Constant(this.comparand), Expression.Constant(StringComparison.OrdinalIgnoreCase)));
case Predicate.NotEqual:
// !(fieldValue ?? string.Empty).Equals(this.comparand, StringComparison.OrdinalIgnoreCase)
return(Expression.Not(Expression.Call(fieldValueOrEmptyString, StringEqualsMethodInfo, Expression.Constant(this.comparand), Expression.Constant(StringComparison.OrdinalIgnoreCase))));
case Predicate.LessThan:
case Predicate.GreaterThan:
case Predicate.LessThanOrEqual:
case Predicate.GreaterThanOrEqual:
// double.TryParse(fieldValue, out temp) && temp {<, <=, >, >=} comparandDouble
this.ThrowOnInvalidFilter(fieldType, !this.comparandDouble.HasValue);
return(this.CreateStringToDoubleComparisonBlock(fieldExpression, this.predicate));
case Predicate.Contains:
// fieldValue => (fieldValue ?? string.Empty).IndexOf(this.comparand, StringComparison.OrdinalIgnoreCase) != -1;
return(Expression.NotEqual(indexOfCall, Expression.Constant(-1)));
case Predicate.DoesNotContain:
// fieldValue => (fieldValue ?? string.Empty).IndexOf(this.comparand, StringComparison.OrdinalIgnoreCase) == -1;
return(Expression.Equal(indexOfCall, Expression.Constant(-1)));
default:
this.ThrowOnInvalidFilter(fieldType);
break;
}
}
break;
default:
Type nullableUnderlyingType;
if (fieldType == typeof(TimeSpan))
{
this.ThrowOnInvalidFilter(fieldType, !this.comparandTimeSpan.HasValue);
switch (this.predicate)
{
case Predicate.Equal:
Func <TimeSpan, bool> comparator = fieldValue => fieldValue == this.comparandTimeSpan.Value;
return(Expression.Call(Expression.Constant(comparator.Target), comparator.GetMethodInfo(), fieldExpression));
case Predicate.NotEqual:
comparator = fieldValue => fieldValue != this.comparandTimeSpan.Value;
return(Expression.Call(Expression.Constant(comparator.Target), comparator.GetMethodInfo(), fieldExpression));
case Predicate.LessThan:
comparator = fieldValue => fieldValue < this.comparandTimeSpan.Value;
return(Expression.Call(Expression.Constant(comparator.Target), comparator.GetMethodInfo(), fieldExpression));
case Predicate.GreaterThan:
comparator = fieldValue => fieldValue > this.comparandTimeSpan.Value;
return(Expression.Call(Expression.Constant(comparator.Target), comparator.GetMethodInfo(), fieldExpression));
case Predicate.LessThanOrEqual:
comparator = fieldValue => fieldValue <= this.comparandTimeSpan.Value;
return(Expression.Call(Expression.Constant(comparator.Target), comparator.GetMethodInfo(), fieldExpression));
case Predicate.GreaterThanOrEqual:
comparator = fieldValue => fieldValue >= this.comparandTimeSpan.Value;
return(Expression.Call(Expression.Constant(comparator.Target), comparator.GetMethodInfo(), fieldExpression));
default:
this.ThrowOnInvalidFilter(fieldType);
break;
}
}
else if (fieldType == typeof(Uri))
{
Expression toStringCall = Expression.Call(fieldExpression, UriToStringMethodInfo);
Expression fieldValueOrEmptyString = Expression.Condition(Expression.Equal(fieldExpression, Expression.Constant(null)), Expression.Constant(string.Empty), toStringCall);
Expression indexOfCall = Expression.Call(fieldValueOrEmptyString, StringIndexOfMethodInfo, Expression.Constant(this.comparand), Expression.Constant(StringComparison.OrdinalIgnoreCase));
switch (this.predicate)
{
case Predicate.Equal:
// (fieldValue?.ToString() ?? string.Empty).Equals(this.comparand, StringComparison.OrdinalIgnoreCase)
return(Expression.Call(fieldValueOrEmptyString, StringEqualsMethodInfo, Expression.Constant(this.comparand), Expression.Constant(StringComparison.OrdinalIgnoreCase)));
case Predicate.NotEqual:
// !(fieldValue?.ToString() ?? string.Empty).Equals(this.comparand, StringComparison.OrdinalIgnoreCase)
return(Expression.Not(Expression.Call(fieldValueOrEmptyString, StringEqualsMethodInfo, Expression.Constant(this.comparand), Expression.Constant(StringComparison.OrdinalIgnoreCase))));
case Predicate.Contains:
// fieldValue => (fieldValue?.ToString() ?? string.Empty).IndexOf(this.comparand, StringComparison.OrdinalIgnoreCase) != -1;
return(Expression.NotEqual(indexOfCall, Expression.Constant(-1)));
case Predicate.DoesNotContain:
// fieldValue => (fieldValue?.ToString() ?? string.Empty).IndexOf(this.comparand, StringComparison.OrdinalIgnoreCase) == -1;
return(Expression.Equal(indexOfCall, Expression.Constant(-1)));
default:
this.ThrowOnInvalidFilter(fieldType);
break;
}
}
else if ((nullableUnderlyingType = Nullable.GetUnderlyingType(fieldType)) != null)
{
// make a recursive call for the underlying type
return(ProduceComparatorExpressionForSingleFieldCondition(fieldExpression, nullableUnderlyingType, true));
}
else
{
this.ThrowOnInvalidFilter(fieldType);
}
break;
}
return(null);
}
/// <summary>Invokes the method from this assembly in another process using the specified arguments.</summary>
/// <param name="method">The method to invoke.</param>
/// <param name="start">true if this function should Start the Process; false if that responsibility is left up to the caller.</param>
internal static RemoteInvokeHandle RemoteInvoke(
Func <int> method,
bool start = true)
{
return(RemoteInvoke(method.GetMethodInfo(), Array.Empty <string>(), start));
}
// REVIEW: It would be nice to support propagation of select metadata.
public static IDataView Create <TSrc, TDst>(IHostEnvironment env, string name, IDataView input,
string src, string dst, DataViewType typeSrc, DataViewType typeDst, ValueMapper <TSrc, TDst> mapper,
ValueGetter <VBuffer <ReadOnlyMemory <char> > > keyValueGetter = null, ValueGetter <VBuffer <ReadOnlyMemory <char> > > slotNamesGetter = null)
{
Contracts.CheckValue(env, nameof(env));
env.CheckNonEmpty(name, nameof(name));
env.CheckValue(input, nameof(input));
env.CheckNonEmpty(src, nameof(src));
env.CheckNonEmpty(dst, nameof(dst));
env.CheckValue(typeSrc, nameof(typeSrc));
env.CheckValue(typeDst, nameof(typeDst));
env.CheckValue(mapper, nameof(mapper));
env.Check(keyValueGetter == null || typeDst.GetItemType() is KeyType);
env.Check(slotNamesGetter == null || typeDst.IsKnownSizeVector());
if (typeSrc.RawType != typeof(TSrc))
{
throw env.ExceptParam(nameof(mapper),
"The source column type '{0}' doesn't match the input type of the mapper", typeSrc);
}
if (typeDst.RawType != typeof(TDst))
{
throw env.ExceptParam(nameof(mapper),
"The destination column type '{0}' doesn't match the output type of the mapper", typeDst);
}
bool tmp = input.Schema.TryGetColumnIndex(src, out int colSrc);
if (!tmp)
{
throw env.ExceptParam(nameof(src), "The input data doesn't have a column named '{0}'", src);
}
var typeOrig = input.Schema[colSrc].Type;
// REVIEW: Ideally this should support vector-type conversion. It currently doesn't.
bool ident;
Delegate conv;
if (typeOrig.SameSizeAndItemType(typeSrc))
{
ident = true;
conv = null;
}
else if (!Conversions.Instance.TryGetStandardConversion(typeOrig, typeSrc, out conv, out ident))
{
throw env.ExceptParam(nameof(mapper),
"The type of column '{0}', '{1}', cannot be converted to the input type of the mapper '{2}'",
src, typeOrig, typeSrc);
}
var col = new Column(src, dst);
IDataView impl;
if (ident)
{
impl = new Impl <TSrc, TDst, TDst>(env, name, input, col, typeDst, mapper, keyValueGetter: keyValueGetter, slotNamesGetter: slotNamesGetter);
}
else
{
Func <IHostEnvironment, string, IDataView, Column, DataViewType, ValueMapper <int, int>,
ValueMapper <int, int>, ValueGetter <VBuffer <ReadOnlyMemory <char> > >, ValueGetter <VBuffer <ReadOnlyMemory <char> > >,
Impl <int, int, int> > del = CreateImpl <int, int, int>;
var meth = del.GetMethodInfo().GetGenericMethodDefinition()
.MakeGenericMethod(typeOrig.RawType, typeof(TSrc), typeof(TDst));
impl = (IDataView)meth.Invoke(null, new object[] { env, name, input, col, typeDst, conv, mapper, keyValueGetter, slotNamesGetter });
}
return(new OpaqueDataView(impl));
}
public ITypeDependencyBuilder <T> Creating <TImplementation>(Func <TImplementation> func)
where TImplementation : T
{
return(Creating(func.GetMethodInfo()));
}
/// <summary>
/// DO NOT USE THIS MANUALLY.
/// </summary>
/// <param name="client">DO NOT USE THIS MANUALLY.</param>
/// <exception cref="InvalidOperationException"/>
protected internal override void Setup(DiscordClient client)
{
if (this.Client != null)
{
throw new InvalidOperationException("What did I tell you?");
}
this.Client = client;
this._executed = new AsyncEvent <CommandExecutionEventArgs>(this.Client.EventErrorHandler, "COMMAND_EXECUTED");
this._error = new AsyncEvent <CommandErrorEventArgs>(this.Client.EventErrorHandler, "COMMAND_ERRORED");
this.Client.MessageCreated += this.HandleCommandsAsync;
if (this.Config.EnableDefaultHelp)
{
var dlg = new Func <CommandContext, string[], Task>(this.DefaultHelpAsync);
var mi = dlg.GetMethodInfo();
this.MakeCallable(mi, dlg.Target, out var cbl, out var args);
var attrs = mi.GetCustomAttributes();
if (!attrs.Any(xa => xa.GetType() == typeof(CommandAttribute)))
{
return;
}
var cmd = new Command();
var cbas = new List <CheckBaseAttribute>();
foreach (var xa in attrs)
{
switch (xa)
{
case CommandAttribute c:
cmd.Name = c.Name;
break;
case AliasesAttribute a:
cmd.Aliases = a.Aliases;
break;
case CheckBaseAttribute p:
cbas.Add(p);
break;
case DescriptionAttribute d:
cmd.Description = d.Description;
break;
case HiddenAttribute h:
cmd.IsHidden = true;
break;
}
}
if (this.Config.DefaultHelpChecks != null && this.Config.DefaultHelpChecks.Any())
{
cbas.AddRange(this.Config.DefaultHelpChecks);
}
cmd.ExecutionChecks = new ReadOnlyCollection <CheckBaseAttribute>(cbas);
cmd.Arguments = args;
cmd.Callable = cbl;
this.AddToCommandDictionary(cmd);
}
}
/// <summary>Invokes the method from this assembly in another process using the specified arguments.</summary>
/// <param name="method">The method to invoke.</param>
/// <param name="options">Options to use for the invocation.</param>
internal static RemoteInvokeHandle RemoteInvoke(
Func<int> method,
RemoteInvokeOptions options = null)
{
return RemoteInvoke(method.GetMethodInfo(), Array.Empty<string>(), options);
}
private NAReplaceTransform(IHost host, ModelLoadContext ctx, IDataView input)
: base(host, ctx, input, TestType)
{
Host.AssertValue(ctx);
Host.AssertNonEmpty(Infos);
GetInfoAndMetadata(out _types, out _isNAs);
// *** Binary format ***
// <base>
// for each column:
// type and value
_repValues = new object[Infos.Length];
_repIsDefault = new BitArray[Infos.Length];
var saver = new BinarySaver(Host, new BinarySaver.Arguments());
for (int iinfo = 0; iinfo < Infos.Length; iinfo++)
{
object repValue;
ColumnType repType;
if (!saver.TryLoadTypeAndValue(ctx.Reader.BaseStream, out repType, out repValue))
{
throw Host.ExceptDecode();
}
if (!_types[iinfo].ItemType.Equals(repType.ItemType))
{
throw Host.ExceptParam(nameof(input), "Decoded serialization of type '{0}' does not match expected ColumnType of '{1}'", repType.ItemType, _types[iinfo].ItemType);
}
// If type is a vector and the value is not either a scalar or a vector of the same size, throw an error.
if (repType.IsVector)
{
if (!_types[iinfo].IsVector)
{
throw Host.ExceptParam(nameof(input), "Decoded serialization of type '{0}' cannot be a vector when Columntype is a scalar of type '{1}'", repType, _types[iinfo]);
}
if (!_types[iinfo].IsKnownSizeVector)
{
throw Host.ExceptParam(nameof(input), "Decoded serialization for unknown size vector '{0}' must be a scalar instead of type '{1}'", _types[iinfo], repType);
}
if (_types[iinfo].VectorSize != repType.VectorSize)
{
throw Host.ExceptParam(nameof(input), "Decoded serialization of type '{0}' must be a scalar or a vector of the same size as Columntype '{1}'",
repType, _types[iinfo]);
}
// REVIEW: The current implementation takes the serialized VBuffer, densifies it, and stores the values array.
// It might be of value to consider storing the VBUffer in order to possibly benefit from sparsity. However, this would
// necessitate a reimplementation of the FillValues code to accomodate sparse VBuffers.
object[] args = new object[] { repValue, _types[iinfo], iinfo };
Func <VBuffer <int>, ColumnType, int, int[]> func = GetValuesArray <int>;
var meth = func.GetMethodInfo().GetGenericMethodDefinition().MakeGenericMethod(repType.ItemType.RawType);
_repValues[iinfo] = meth.Invoke(this, args);
}
else
{
_repValues[iinfo] = repValue;
}
Host.Assert(repValue.GetType() == _types[iinfo].RawType || repValue.GetType() == _types[iinfo].ItemType.RawType);
}
}
private MethodInfo CreateSerializeMethod(Func <object, string> serializeMethod) => serializeMethod.GetMethodInfo();
public InjectionFactory(Func<IUnityContainer, object> factoryFunc)
{
var parameters = new Expression[] { Expression.Constant(DummyContainer) };
this.Factory = factoryFunc.Target == null ? Expression.Call(factoryFunc.GetMethodInfo(), parameters) : Expression.Call(Expression.Constant(factoryFunc.Target), factoryFunc.GetMethodInfo(), parameters);
}
public void Register(string endpoint, string version, Func <HttpContext, Task> method)
{
MethodRegister(endpoint, version, method.GetMethodInfo());
}
private static MethodInfo GetMethodInfoOf <T1, T2>(Func <T1, T2> func)
{
Debug.Assert(func != null);
return(func.GetMethodInfo());
}
private Expression GenerateMethodBody(Operation operation, ParameterExpression contextParameter,
IFunctionRegistry functionRegistry)
{
if (operation == null)
{
throw new ArgumentNullException("operation");
}
if (operation.GetType() == typeof(IntegerConstant))
{
IntegerConstant constant = (IntegerConstant)operation;
double value = constant.Value;
return(Expression.Constant(value, typeof(double)));
}
else if (operation.GetType() == typeof(FloatingPointConstant))
{
FloatingPointConstant constant = (FloatingPointConstant)operation;
return(Expression.Constant(constant.Value, typeof(double)));
}
else if (operation.GetType() == typeof(Variable))
{
Variable variable = (Variable)operation;
Func <string, FormulaContext, double> getVariableValueOrThrow = PrecompiledMethods.GetVariableValueOrThrow;
return(Expression.Call(null,
getVariableValueOrThrow.GetMethodInfo(),
Expression.Constant(variable.Name),
contextParameter));
}
else if (operation.GetType() == typeof(Multiplication))
{
Multiplication multiplication = (Multiplication)operation;
Expression argument1 = GenerateMethodBody(multiplication.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(multiplication.Argument2, contextParameter, functionRegistry);
return(Expression.Multiply(argument1, argument2));
}
else if (operation.GetType() == typeof(Addition))
{
Addition addition = (Addition)operation;
Expression argument1 = GenerateMethodBody(addition.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(addition.Argument2, contextParameter, functionRegistry);
return(Expression.Add(argument1, argument2));
}
else if (operation.GetType() == typeof(Subtraction))
{
Subtraction addition = (Subtraction)operation;
Expression argument1 = GenerateMethodBody(addition.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(addition.Argument2, contextParameter, functionRegistry);
return(Expression.Subtract(argument1, argument2));
}
else if (operation.GetType() == typeof(Division))
{
Division division = (Division)operation;
Expression dividend = GenerateMethodBody(division.Dividend, contextParameter, functionRegistry);
Expression divisor = GenerateMethodBody(division.Divisor, contextParameter, functionRegistry);
return(Expression.Divide(dividend, divisor));
}
else if (operation.GetType() == typeof(Modulo))
{
Modulo modulo = (Modulo)operation;
Expression dividend = GenerateMethodBody(modulo.Dividend, contextParameter, functionRegistry);
Expression divisor = GenerateMethodBody(modulo.Divisor, contextParameter, functionRegistry);
return(Expression.Modulo(dividend, divisor));
}
else if (operation.GetType() == typeof(Exponentiation))
{
Exponentiation exponentation = (Exponentiation)operation;
Expression @base = GenerateMethodBody(exponentation.Base, contextParameter, functionRegistry);
Expression exponent = GenerateMethodBody(exponentation.Exponent, contextParameter, functionRegistry);
return(Expression.Call(null, typeof(Math).GetRuntimeMethod("Pow", new Type[] { typeof(double), typeof(double) }), @base, exponent));
}
else if (operation.GetType() == typeof(UnaryMinus))
{
UnaryMinus unaryMinus = (UnaryMinus)operation;
Expression argument = GenerateMethodBody(unaryMinus.Argument, contextParameter, functionRegistry);
return(Expression.Negate(argument));
}
else if (operation.GetType() == typeof(And))
{
And and = (And)operation;
Expression argument1 = Expression.NotEqual(GenerateMethodBody(and.Argument1, contextParameter, functionRegistry), Expression.Constant(0.0));
Expression argument2 = Expression.NotEqual(GenerateMethodBody(and.Argument2, contextParameter, functionRegistry), Expression.Constant(0.0));
return(Expression.Condition(Expression.And(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(Or))
{
Or and = (Or)operation;
Expression argument1 = Expression.NotEqual(GenerateMethodBody(and.Argument1, contextParameter, functionRegistry), Expression.Constant(0.0));
Expression argument2 = Expression.NotEqual(GenerateMethodBody(and.Argument2, contextParameter, functionRegistry), Expression.Constant(0.0));
return(Expression.Condition(Expression.Or(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(LessThan))
{
LessThan lessThan = (LessThan)operation;
Expression argument1 = GenerateMethodBody(lessThan.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(lessThan.Argument2, contextParameter, functionRegistry);
return(Expression.Condition(Expression.LessThan(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(LessOrEqualThan))
{
LessOrEqualThan lessOrEqualThan = (LessOrEqualThan)operation;
Expression argument1 = GenerateMethodBody(lessOrEqualThan.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(lessOrEqualThan.Argument2, contextParameter, functionRegistry);
return(Expression.Condition(Expression.LessThanOrEqual(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(GreaterThan))
{
GreaterThan greaterThan = (GreaterThan)operation;
Expression argument1 = GenerateMethodBody(greaterThan.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(greaterThan.Argument2, contextParameter, functionRegistry);
return(Expression.Condition(Expression.GreaterThan(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(GreaterOrEqualThan))
{
GreaterOrEqualThan greaterOrEqualThan = (GreaterOrEqualThan)operation;
Expression argument1 = GenerateMethodBody(greaterOrEqualThan.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(greaterOrEqualThan.Argument2, contextParameter, functionRegistry);
return(Expression.Condition(Expression.GreaterThanOrEqual(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(Equal))
{
Equal equal = (Equal)operation;
Expression argument1 = GenerateMethodBody(equal.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(equal.Argument2, contextParameter, functionRegistry);
return(Expression.Condition(Expression.Equal(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(NotEqual))
{
NotEqual notEqual = (NotEqual)operation;
Expression argument1 = GenerateMethodBody(notEqual.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(notEqual.Argument2, contextParameter, functionRegistry);
return(Expression.Condition(Expression.NotEqual(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(Function))
{
Function function = (Function)operation;
FunctionInfo functionInfo = functionRegistry.GetFunctionInfo(function.FunctionName);
Type funcType;
Type[] parameterTypes;
Expression[] arguments;
if (functionInfo.IsDynamicFunc)
{
funcType = typeof(DynamicFunc <double, double>);
parameterTypes = new Type[] { typeof(double[]) };
Expression[] arrayArguments = new Expression[function.Arguments.Count];
for (int i = 0; i < function.Arguments.Count; i++)
{
arrayArguments[i] = GenerateMethodBody(function.Arguments[i], contextParameter, functionRegistry);
}
arguments = new Expression[1];
arguments[0] = NewArrayExpression.NewArrayInit(typeof(double), arrayArguments);
}
else
{
funcType = GetFuncType(functionInfo.NumberOfParameters);
parameterTypes = (from i in Enumerable.Range(0, functionInfo.NumberOfParameters)
select typeof(double)).ToArray();
arguments = new Expression[functionInfo.NumberOfParameters];
for (int i = 0; i < functionInfo.NumberOfParameters; i++)
{
arguments[i] = GenerateMethodBody(function.Arguments[i], contextParameter, functionRegistry);
}
}
Expression getFunctionRegistry = Expression.Property(contextParameter, "FunctionRegistry");
ParameterExpression functionInfoVariable = Expression.Variable(typeof(FunctionInfo));
Expression funcInstance;
if (!functionInfo.IsOverWritable)
{
funcInstance = Expression.Convert(
Expression.Property(
Expression.Call(
getFunctionRegistry,
typeof(IFunctionRegistry).GetRuntimeMethod("GetFunctionInfo", new Type[] { typeof(string) }),
Expression.Constant(function.FunctionName)),
"Function"),
funcType);
}
else
{
funcInstance = Expression.Constant(functionInfo.Function, funcType);
}
return(Expression.Call(
funcInstance,
funcType.GetRuntimeMethod("Invoke", parameterTypes),
arguments));
}
else
{
throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation");
}
}
/// <summary>
/// Fill the repValues array with the correct replacement values based on the user-given replacement kinds.
/// Vectors default to by-slot imputation unless otherwise specified, except for unknown sized vectors
/// which force across-slot imputation.
/// </summary>
private void GetReplacementValues(Arguments args, out object[] repValues, out BitArray[] slotIsDefault)
{
repValues = new object[Infos.Length];
slotIsDefault = new BitArray[Infos.Length];
ReplacementKind?[] imputationModes = new ReplacementKind?[Infos.Length];
List <int> columnsToImpute = null;
// REVIEW: Would like to get rid of the sourceColumns list but seems to be the best way to provide
// the cursor with what columns to cursor through.
HashSet <int> sourceColumns = null;
for (int iinfo = 0; iinfo < Infos.Length; iinfo++)
{
ReplacementKind kind = args.Column[iinfo].Kind ?? args.ReplacementKind;
switch (kind)
{
case ReplacementKind.SpecifiedValue:
repValues[iinfo] = GetSpecifiedValue(args.Column[iinfo].ReplacementString, _types[iinfo], _isNAs[iinfo]);
break;
case ReplacementKind.DefaultValue:
repValues[iinfo] = GetDefault(_types[iinfo]);
break;
case ReplacementKind.Mean:
case ReplacementKind.Min:
case ReplacementKind.Max:
if (!_types[iinfo].ItemType.IsNumber && !_types[iinfo].ItemType.IsTimeSpan && !_types[iinfo].ItemType.IsDateTime)
{
throw Host.Except("Cannot perform mean imputations on non-numeric '{0}'", _types[iinfo].ItemType);
}
imputationModes[iinfo] = kind;
Utils.Add(ref columnsToImpute, iinfo);
Utils.Add(ref sourceColumns, Infos[iinfo].Source);
break;
default:
Host.Assert(false);
throw Host.Except("Internal error, undefined ReplacementKind '{0}' assigned in NAReplaceTransform.", kind);
}
}
// Exit if there are no columns needing a replacement value imputed.
if (Utils.Size(columnsToImpute) == 0)
{
return;
}
// Impute values.
using (var ch = Host.Start("Computing Statistics"))
using (var cursor = Source.GetRowCursor(sourceColumns.Contains))
{
StatAggregator[] statAggregators = new StatAggregator[columnsToImpute.Count];
for (int ii = 0; ii < columnsToImpute.Count; ii++)
{
int iinfo = columnsToImpute[ii];
bool bySlot = args.Column[ii].Slot ?? args.ImputeBySlot;
if (_types[iinfo].IsVector && !_types[iinfo].IsKnownSizeVector && bySlot)
{
ch.Warning("By-slot imputation can not be done on variable-length column");
bySlot = false;
}
statAggregators[ii] = CreateStatAggregator(ch, _types[iinfo], imputationModes[iinfo], bySlot,
cursor, Infos[iinfo].Source);
}
while (cursor.MoveNext())
{
for (int ii = 0; ii < statAggregators.Length; ii++)
{
statAggregators[ii].ProcessRow();
}
}
for (int ii = 0; ii < statAggregators.Length; ii++)
{
repValues[columnsToImpute[ii]] = statAggregators[ii].GetStat();
}
ch.Done();
}
// Construct the slotIsDefault bit arrays.
for (int ii = 0; ii < columnsToImpute.Count; ii++)
{
int slot = columnsToImpute[ii];
if (repValues[slot] is Array)
{
Func <ColumnType, int[], BitArray> func = ComputeDefaultSlots <int>;
var meth = func.GetMethodInfo().GetGenericMethodDefinition().MakeGenericMethod(_types[slot].ItemType.RawType);
slotIsDefault[slot] = (BitArray)meth.Invoke(this, new object[] { _types[slot], repValues[slot] });
}
}
}
public void Register <TReq, TRes>(string endpoint, string version, Func <HttpContext, TReq, Task <TRes> > method, string schema)
{
MethodRegister(endpoint, version, method.GetMethodInfo(), schema);
}
/// <summary>
/// Returns the MethodInfo for the given delegate.
/// </summary>
public static MethodInfo Fn <T1, T2>(Func <T1, T2> fn)
{
Contracts.AssertValue(fn);
Contracts.Assert(fn.Target == null);
return(fn.GetMethodInfo());
}
ReturnsLazily <TReturnType, T1, T2, T3>(this IReturnValueConfiguration <ValueTask <TReturnType> > configuration, Func <T1, T2, T3, TReturnType> valueProducer)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(valueProducer, nameof(valueProducer));
return(configuration.ReturnsLazily(call =>
{
ValueProducerSignatureHelper.AssertThatValueProducerSignatureSatisfiesCallSignature(call.Method, valueProducer.GetMethodInfo(), NameOfReturnsLazilyFeature);
return new ValueTask <TReturnType>(valueProducer(call.GetArgument <T1>(0), call.GetArgument <T2>(1), call.GetArgument <T3>(2)));
}));
}
