public void GetInterfaceMapWorksWithVariantIfaces()
{
var m0 = typeof(IMethodInvoke <object>).GetMethod("Test");
var m1 = typeof(IMethodInvoke <string>).GetMethod("Test");
var obj = new MethodInvoke();
Assert.AreEqual("MethodInvoke", m0.Invoke(obj, new Object [0]));
Assert.AreEqual("MethodInvoke", m1.Invoke(obj, new Object [0]));
}
/// <summary>
/// Create a new Instance of the specified type.
///
/// Type should have an empty constructor or a constructor with annotation.
/// </summary>
/// <param name="type">Type</param>
/// <param name="node">Configuration node.</param>
/// <returns>Created Instance</returns>
public static object CreateInstance(Type type, ConfigPathNode node)
{
object target = null;
ConstructorInfo[] constructors = type.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
if (constructors != null && constructors.Length > 0)
{
foreach (ConstructorInfo ci in constructors)
{
MethodInvoke mi = (MethodInvoke)Attribute.GetCustomAttribute(ci, typeof(MethodInvoke));
if (mi != null)
{
ParameterInfo[] parameters = ci.GetParameters();
ConfigPathNode nnode = node;
if (parameters != null && parameters.Length > 0)
{
if (!String.IsNullOrWhiteSpace(mi.Path))
{
AbstractConfigNode cnode = nnode.Find(mi.Path);
if (cnode != null && cnode.GetType() == typeof(ConfigPathNode))
{
nnode = (ConfigPathNode)cnode;
}
}
if (nnode != null)
{
ConfigParametersNode pnode = nnode.GetParameters();
if (pnode != null)
{
List <object> values = FindParameters(pnode, ci.Name, parameters);
if (values != null && values.Count > 0)
{
target = Activator.CreateInstance(type, values.ToArray());
}
}
}
}
else
{
target = Activator.CreateInstance(type);
}
}
}
}
if (target == null)
{
target = Activator.CreateInstance(type);
}
if (target != null)
{
target = ReadValues((ConfigPathNode)node, target, null);
CallMethodInvokes((ConfigPathNode)node, target);
}
return(target);
}
protected void AddFactorEdges(GraphWriter g, MethodInvoke mi)
{
var parameters = mi.method.GetParameters();
for (int i = 0; i < mi.args.Count; i++)
{
var parameter = parameters[i];
if (parameter.IsOut)
{
AddEdge(g, mi, mi.args[i], parameter.Name);
}
else
{
AddEdge(g, mi.args[i], mi, parameter.Name);
}
}
if (mi.returnValue != null)
{
AddEdge(g, mi, mi.returnValue, "");
}
if (!UseContainers)
{
// add edges from condition variables to target (if there are no such edges already)
IModelExpression target = (mi.returnValue != null) ? mi.returnValue : mi;
Set <IStatementBlock> excluded = new Set <IStatementBlock>();
if (target is Variable)
{
// if target is in the ConditionBlock, then don't connect with the condition variable
Variable targetVar = (Variable)target;
excluded.AddRange(targetVar.Containers);
}
foreach (IStatementBlock block in mi.Containers)
{
if (excluded.Contains(block))
{
continue;
}
if (block is ConditionBlock)
{
ConditionBlock cb = (ConditionBlock)block;
Variable c = cb.ConditionVariableUntyped;
List <Variable> condVars;
if (!conditionVariables.TryGetValue(target, out condVars))
{
condVars = new List <Variable>();
conditionVariables[target] = condVars;
}
if (!condVars.Contains(c))
{
AddEdge(g, c, target, "condition");
condVars.Add(c);
}
}
}
}
}
public void CanCallInstanceMethodWithoutArgsButWithResult()
{
// Arrange
// Act
var result = MethodInvoke.InstanceMethod(target, "InstanceStringMethodWithoutArgs", new object[0]);
// Assert
Assert.True(result.HasResult);
Assert.Equal("successInstanceStringMethodWithoutArgs", result.Value);
}
public void CanCallInstanceMethodWithoutArgsAndWithoutResult()
{
// Arrange
// Act
var result = MethodInvoke.InstanceMethod(target, "InstanceVoidMethodWithoutArgs", new object[0]);
// Assert
Assert.False(result.HasResult);
Assert.Null(result.Value);
}
internal void Compile(MethodInvoke method)
{
// name
method.AddElement(this);
method.AddCode(method.ParameterName);
method.AddLiteral(this.TextCaseSpecified ? (object)this.TextCase : null);
method.AddLiteral(this.Prefix);
method.AddLiteral(this.Suffix);
method.AddDefaultParameters();
}
public void CanCallMethodWithNullArgs()
{
// Arrange
// Act
var result = (string)MethodInvoke
.InstanceMethod(target, "InstanceStringMethodWhichIsOkayWhenArgIsNull", new object[] { null })
.Value;
// Assert
Assert.Equal(result, "Arg is null");
}
public static void AddSortComparerParameters(this MethodInvoke method, SortElement sort)
{
// find orders
var keys = sort.Keys ?? new KeyElement[] { };
// add
foreach (var key in keys)
{
method.AddLiteral(key.SortOrderSpecified ? key.SortOrder : SortOrder.Ascending);
}
}
/// <summary>
/// Check and Invoke annotated methods for this type.
/// </summary>
/// <typeparam name="T">Target Instance type</typeparam>
/// <param name="node">Configuration node.</param>
/// <param name="target">Target Type instance</param>
private static void CallMethodInvokes <T>(ConfigPathNode node, T target)
{
Type type = target.GetType();
MethodInfo[] methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance);
if (methods != null)
{
foreach (MethodInfo method in methods)
{
MethodInvoke mi = (MethodInvoke)Attribute.GetCustomAttribute(method, typeof(MethodInvoke));
if (mi != null)
{
bool invoked = false;
ParameterInfo[] parameters = method.GetParameters();
ConfigPathNode nnode = node;
if (parameters != null && parameters.Length > 0)
{
if (!String.IsNullOrWhiteSpace(mi.Path))
{
AbstractConfigNode cnode = nnode.Find(mi.Path);
if (cnode != null && cnode.GetType() == typeof(ConfigPathNode))
{
nnode = (ConfigPathNode)cnode;
}
}
if (nnode != null)
{
ConfigParametersNode pnode = nnode.GetParameters();
if (pnode != null)
{
List <object> values = FindParameters(pnode, method.Name, parameters);
if (values != null && values.Count > 0)
{
method.Invoke(target, values.ToArray());
invoked = true;
}
}
}
}
else
{
method.Invoke(target, null);
invoked = true;
}
if (!invoked)
{
throw new AnnotationProcessorException(String.Format("Error Invoking Method : [mehtod={0}][node={1}]",
method.Name, node.GetSearchPath()));
}
}
}
}
}
public void CanCallStaticMethodWithoutArgsAndWithoutResult()
{
// Arrange
// Act
var result = MethodInvoke
.StaticMethod <ClassWithPrivateMethods>("StaticVoidMethodWithoutArgs", new object[0]);
// Assert
Assert.False(result.HasResult);
Assert.Null(result.Value);
}
public void CanCallInstanceMethodWithArgsAndWithResult()
{
// Arrange
// Act
var result = MethodInvoke.InstanceMethod(target, "InstanceStringMethodWithArgs", new object[] { trackable });
// Assert
Assert.True(result.HasResult);
Assert.Equal("success", result.Value);
trackable.Received(1).Touch();
}
public void CanCallInstanceMethodWithArgsButWithoutResult()
{
// Arrange
// Act
var result = MethodInvoke.InstanceMethod(target, "InstanceVoidMethodWithArgs", new object[] { trackable });
// Assert
Assert.False(result.HasResult);
Assert.Null(result.Value);
trackable.Received(1).Touch();
}
public void CanCallStaticMethodWithoutArgsButWithResult()
{
// Arrange
// Act
var result = MethodInvoke
.StaticMethod <ClassWithPrivateMethods>("StaticStringMethodWithoutArgs", new object[0]);
// Assert
Assert.True(result.HasResult);
Assert.Equal("successStaticStringMethodWithoutArgs", result.Value);
}
public static void AddContextAndParameters(this MethodInvoke owner)
{
// context
owner.AddCode(Compiler.CONTEXT_NAME);
// parameters
using (var method = owner.AddMethodInvoke("new Parameters", null))
{
method.AddCode(method.ParameterName);
method.AddDefaultParameters();
}
}
public void CanCallStaticMethodWithArgsButWithoutResult()
{
// Arrange
// Act
var result = MethodInvoke
.StaticMethod <ClassWithPrivateMethods>("StaticVoidMethodWithArgs", new object[] { trackable });
// Assert
Assert.False(result.HasResult);
Assert.Null(result.Value);
trackable.Received(1).Touch();
}
public void CallingStaticMethodWithNullForValueTypeParameterThrowsException()
{
// Arrange
// Act
var caught = Assert.Throws <InvalidOperationException>(() =>
MethodInvoke.StaticMethod <ClassWithPrivateMethods>(
"StaticVoidMethodWhichIsNotOkayWhenArgIsNull",
new object[] { null }));
// Assert
Assert.Equal("Didn't find a method mathing passed parameters.", caught.Message);
}
/// <summary>
/// Draws a line to the target of a method invoke.
/// Also draws a rect if it's parameter is one.
/// </summary>
/// <param name="methodInvoke">The method invoke to draw</param>
/// <param name="separation">The separation of the line</param>
private void DrawMethodInvoke(MethodInvoke methodInvoke, Vector3 separation = new Vector3())
{
if (methodInvoke.target != null) {
Gizmos.DrawLine(transform.position + separation, methodInvoke.target.transform.position + separation);
Color temp = Gizmos.color;
Color newColor = Color.yellow;
newColor.a = 0.25f;
Gizmos.color = newColor;
Gizmos.DrawCube(methodInvoke.RectParameter.center - methodInvoke.RectParameter.size / 2, methodInvoke.RectParameter.size);
Gizmos.color = temp;
}
}
public void CanCallStaticMethodWithArgsAndWithResult()
{
// Arrange
// Act
var result = MethodInvoke
.StaticMethod <ClassWithPrivateMethods>("StaticStringMethodWithArgs", new object[] { trackable });
// Assert
Assert.True(result.HasResult);
Assert.Equal("successStaticStringMethodWithArgs", result.Value);
trackable.Received(1).Touch();
}
public void CanCallStaticMethodWithNullArgs()
{
// Arrange
// Act
var result = (string)MethodInvoke
.StaticMethod <ClassWithPrivateMethods>(
"StaticStringMethodWhichIsOkayWhenArgIsNull",
new object[] { null })
.Value;
// Assert
Assert.Equal(result, "Arg is null");
}
private Task <Dictionary <string, ControllerDetail> > ResultInvoke(IList <ControllerDetail> objControllers, ReuseableParams objReuseableParams, List <ControllerDetail> lstApsExtraCompsInvoker)
{
Dictionary <string, ControllerDetail> result = new Dictionary <string, ControllerDetail>();
MethodInvoke methodInvoke = new MethodInvoke();
foreach (ControllerDetail item in objControllers)
{
ControllerDetail controllerDetail = methodInvoke.Execute(item, objReuseableParams, lstApsExtraCompsInvoker);
if (!result.ContainsKey(controllerDetail.ComponentID.Trim()))
{
result.Add(controllerDetail.ComponentID.Trim(), item);
}
}
return(Task.FromResult(result));
}
public Executer(object value = null, MethodInvoke method = null)
{
if (value == null)
{
return;
}
if (value is T)
{
Value = (T)value;
}
else
{
throw new ArgumentException("value");
}
m_Info = method;
}
public static void AddSortComparer(this MethodInvoke method, EntryElement element)
{
// find orders
var orders = (element == null || element.Sort == null || element.Sort.Keys == null ? new KeyElement[] { } : element.Sort.Keys)
.Select(key =>
{
// init
var order = (key.SortOrderSpecified ? key.SortOrder : SortOrder.Ascending);
// done
return(Compiler.GetLiteral(order));
})
.ToArray();
// done
method.AddCode("new SortComparer({0})", string.Join(", ", orders));
}
public static void AddDefaultParameters(this MethodInvoke owner)
{
// init
var context = owner.Context;
// IFormattable
owner.AddFromContext <IFormatting>(context, "fontStyle", x => x.FontStyleSpecified, x => x.FontStyle);
owner.AddFromContext <IFormatting>(context, "fontVariant", x => x.FontVariantSpecified, x => x.FontVariant);
owner.AddFromContext <IFormatting>(context, "fontWeight", x => x.FontWeightSpecified, x => x.FontWeight);
owner.AddFromContext <IFormatting>(context, "textDecoration", x => x.TextDecorationSpecified, x => x.TextDecoration);
owner.AddFromContext <IFormatting>(context, "verticalAlign", x => x.VerticalAlignSpecified, x => x.VerticalAlign);
// strip periods
owner.AddFromContext <IStripPeriods>(context, "stripPeriods", x => x.StripPeriodsSpecified, x => x.StripPeriods);
// INamesOptions
owner.AddFromContext <INamesOptions>(context, "namesDelimiter", x => x.Delimiter != null, x => x.Delimiter);
// INameOptions
owner.AddFromContext <INameOptions>(context, "and", x => x.AndSpecified, x => x.And);
owner.AddFromContext <INameOptions>(context, "nameDelimiter", x => x.Delimiter != null, x => x.Delimiter);
owner.AddFromContext <INameOptions>(context, "delimiterPrecedesEtAl", x => x.DelimiterPrecedesEtAlSpecified, x => x.DelimiterPrecedesEtAl);
owner.AddFromContext <INameOptions>(context, "delimiterPrecedesLast", x => x.DelimiterPrecedesLastSpecified, x => x.DelimiterPrecedesLast);
owner.AddFromContext <IEtAlOptions>(context, "etAlMin", x => x.EtAlMinSpecified, x => x.EtAlMin);
owner.AddFromContext <IEtAlOptions>(context, "etAlUseFirst", x => x.EtAlUseFirstSpecified, x => x.EtAlUseFirst);
owner.AddFromContext <IEtAlOptions>(context, "etAlSubsequentMin", x => x.EtAlSubsequentMinSpecified, x => x.EtAlSubsequentMin);
owner.AddFromContext <IEtAlOptions>(context, "etAlSubsequentUseFirst", x => x.EtAlSubsequentUseFirstSpecified, x => x.EtAlSubsequentUseFirst);
owner.AddFromContext <IEtAlOptions>(context, "etAlUseLast", x => x.EtAlUseLastSpecified, x => x.EtAlUseLast);
owner.AddFromContext <INameOptions>(context, "nameFormat", x => x.FormatSpecified, x => x.Format);
owner.AddFromContext <INameOptions>(context, "initialize", x => x.InitializeSpecified, x => x.Initialize);
owner.AddFromContext <INameOptions>(context, "initializeWith", x => x.InitializeWith != null, x => x.InitializeWith);
owner.AddFromContext <INameOptions>(context, "nameAsSortOrder", x => x.NameAsSortOrderSpecified, x => x.NameAsSortOrder);
owner.AddFromContext <INameOptions>(context, "sortSeparator", x => x.SortSeparator != null, x => x.SortSeparator);
}
protected void Mutate(IEvent e)
{
MethodInvoke.InvokeMethodOptional(State, RestoreMethodName, e);
++Version;
}
/// <summary>
/// Create a new Instance of the specified type.
///
/// Type should have an empty constructor or a constructor with annotation.
/// </summary>
/// <typeparam name="T">Target Instance type</typeparam>
/// <param name="type">Type</param>
/// <param name="node">Configuration node.</param>
/// <returns>Created Instance</returns>
public static T CreateInstance <T>(Type type, ConfigPathNode node)
{
T target = default(T);
ConstructorInfo[] constructors = type.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
if (constructors != null && constructors.Length > 0)
{
foreach (ConstructorInfo ci in constructors)
{
MethodInvoke mi = (MethodInvoke)Attribute.GetCustomAttribute(ci, typeof(MethodInvoke));
if (mi != null)
{
ParameterInfo[] parameters = ci.GetParameters();
ConfigPathNode nnode = node;
if (parameters != null && parameters.Length > 0)
{
if (!String.IsNullOrWhiteSpace(mi.Path))
{
AbstractConfigNode cnode = nnode.Find(mi.Path);
if (cnode != null && cnode.GetType() == typeof(ConfigPathNode))
{
nnode = (ConfigPathNode)cnode;
}
}
if (nnode != null)
{
ConfigParametersNode pnode = nnode.GetParameters();
if (pnode != null)
{
List <object> values = FindParameters(pnode, ci.Name, parameters);
if (values != null && values.Count > 0)
{
target = (T)Activator.CreateInstance(type, values.ToArray());
break;
}
}
}
}
else
{
target = Activator.CreateInstance <T>();
break;
}
}
}
}
if (ReflectionUtils.IsNull(target))
{
target = Activator.CreateInstance <T>();
}
if (!ReflectionUtils.IsNull(target))
{
target = ReadValues((ConfigPathNode)node, target, null);
CallMethodInvokes((ConfigPathNode)node, target);
}
else
{
throw new AnnotationProcessorException(String.Format("Error creating instance of Type: [path={0}][type={1}]", node.GetSearchPath(), type.FullName));
}
return(target);
}
/// <summary>
/// The default constructor.
/// </summary>
protected BaseInterceptor()
{
MethodInvoker = new MethodInvoke();
}
public void ToCall(string methodName)
{
MethodInvoke.InstanceMethod(@object, methodName, new object[0]);
}
protected Node GetNode(GraphWriter g, IModelExpression expr)
{
if (nodeOfExpr.ContainsKey(expr))
{
return(nodeOfExpr[expr]);
}
Node nd = g.AddNode("node" + (Count++));
nodeOfExpr[expr] = nd;
nd.Label = expr.ToString();
nd.FontSize = 9;
if (expr is Variable)
{
Variable ve = (Variable)expr;
if (ve.IsObserved)
{
nd.Shape = ShapeStyle.None;
if (ve.IsBase)
{
// if the observed value is a ValueType, display it directly rather than the variable name
object value = ((HasObservedValue)ve).ObservedValue;
if (ReferenceEquals(value, null))
{
nd.Label = "null";
}
else if (value.GetType().IsValueType)
{
nd.Label = value.ToString();
}
}
}
if (!ve.IsReadOnly)
{
nd.FontSize = 10;
nd.FontColor = Color.Blue;
}
if (UseContainers && ve.Containers.Count > 0)
{
var context = ConditionContext.GetContext(ve.Containers);
if (context != null)
{
var contextNode = GetNode(g, context);
AddGroupEdge(g, contextNode, nd);
}
}
}
else if (expr is MethodInvoke)
{
MethodInvoke mi = (MethodInvoke)expr;
nd.FillColor = Color.Black;
nd.FontColor = Color.White;
nd.Shape = ShapeStyle.Box;
nd.FontSize = 8;
string methodName = mi.method.Name;
if (mi.op != null)
{
methodName = mi.op.ToString();
}
nd.Label = methodName;
if (UseContainers && mi.Containers.Count > 0)
{
var context = ConditionContext.GetContext(mi.Containers);
if (context != null)
{
var contextNode = GetNode(g, context);
AddGroupEdge(g, contextNode, nd);
}
}
}
return(nd);
}
/// <summary>
/// Add element to cache
/// </summary>
/// <param name="owner">The owner of value</param>
/// <param name="value">Value to adapted</param>
/// <param name="method">The method to execute when remove the item from cache</param>
public void Add(object owner, T value, MethodInvoke method)
{
var item = Get_By_Owner(owner);
if (item != null)
{
int index = item.Data.BinarySearch(new Executer <T> {
Value = value
});
// si esta lo sustituyo por el nuevo.
if (index >= 0)
{
RealSize -= FromByteToKiloByte(value.get_Size());
item.Data[index] = new Executer <T> {
Value = value, m_Info = method
};
RealSize += FromByteToKiloByte(value.get_Size());
return;
}
// si no esta y cabe en la memoria
if (RealSize + FromByteToKiloByte(value.get_Size()) <= Capacity)
{
item.Data.Add(new Executer <T> {
Value = value, m_Info = method
});
RealSize += FromByteToKiloByte(value.get_Size());
return;
}
//no cabe, pero pudiera caber...
if (item.get_Size() >= value.get_Size())
{
while (RealSize + FromByteToKiloByte(value.get_Size()) > Capacity)
{
//eliminacion aleatoria de los elementos del cache
int pos = random.Next(item.Data.Count);
var x = item.Data[pos];
//ejecutando la accion asociada
x.Execute();
item.Data.RemoveAt(pos);
RealSize -= FromByteToKiloByte(x.Value.get_Size());
}
item.Data.Add(new Executer <T> {
Value = value, m_Info = method
});
RealSize += FromByteToKiloByte(value.get_Size());
return;
}
}
else
{
if (RealSize + FromByteToKiloByte(value.get_Size()) <= Capacity)
{
data.Add(new CacheItem <T> {
Owner = owner, Data = new List <Executer <T> > {
new Executer <T> {
Value = value, m_Info = method
}
}
});
RealSize += FromByteToKiloByte(value.get_Size());
return;
}
}
//si no lo puedo meter en el cache ejecutar la accion asociada
new Executer <T> {
Value = value, m_Info = method
}.Execute();
}
public async Task <object> InvokeDeviceMethodAsync(string connectionId, string deviceId, MethodInvoke methodInvokeParameters)
{
Console.WriteLine("InvokeDeviceMethodAsync received for {0} with deviceId {1} ", connectionId, deviceId);
Console.WriteLine(methodInvokeParameters.ToString());
var client = objectMap[connectionId];
var request = GlueUtils.CreateMethodRequest(methodInvokeParameters);
Console.WriteLine("Invoking");
var response = await client.InvokeMethodAsync(deviceId, request, CancellationToken.None).ConfigureAwait(false);
Console.WriteLine("Response received:");
Console.WriteLine(JsonConvert.SerializeObject(response));
return(new JObject(
new JProperty("status", response.Status),
new JProperty("payload", response.ResultAsJson)
));
}
public R ToCall <R>(string methodName)
{
return((R)MethodInvoke.InstanceMethod(@object, methodName, new object[0]).Value);
}
