internal bool Matches(IContext context, Func <InvokeInfo, bool> validator, Invoke invoke) { var ignoreCase = context.IgnoreCase(); if (!MethodName.Equals(invoke.MethodName, ignoreCase)) { return(false); } var required = Parameters.Where(x => x.IsRequired).ToList(); if (invoke.Arguments.Count < required.Count) { return(false); } var invokeInfo = GetInvokeInfo(context, invoke); if (!validator(invokeInfo)) { return(false); } return(true); }
public bool Equals(RemoteProcedureDescriptor other) { return(ServiceHash.Equals(other.ServiceHash) && InterfaceHash.Equals(other.InterfaceHash) && MethodName.Equals(other.MethodName) && MethodSignature.Equals(other.MethodSignature)); }
/// <summary> /// Returns true if MethodInvoke instances are equal /// </summary> /// <param name="other">Instance of MethodInvoke to be compared</param> /// <returns>Boolean</returns> public bool Equals(MethodInvoke other) { if (ReferenceEquals(null, other)) { return(false); } if (ReferenceEquals(this, other)) { return(true); } return (( MethodName == other.MethodName || MethodName != null && MethodName.Equals(other.MethodName) ) && ( Payload == other.Payload || Payload != null && Payload.Equals(other.Payload) ) && ( ResponseTimeoutInSeconds == other.ResponseTimeoutInSeconds || ResponseTimeoutInSeconds != null && ResponseTimeoutInSeconds.Equals(other.ResponseTimeoutInSeconds) ) && ( ConnectTimeoutInSeconds == other.ConnectTimeoutInSeconds || ConnectTimeoutInSeconds != null && ConnectTimeoutInSeconds.Equals(other.ConnectTimeoutInSeconds) )); }
public override bool Equals(object obj) { var item = obj as MethodIdentity; if (item == null) { return(false); } return(MethodName.Equals(item.MethodName) && MessageType == item.MessageType); }
public bool Equals(MethodKey other) { if (Object.ReferenceEquals(other, null)) { return(false); } return(MethodName.Equals(other.MethodName) && TypeArguments == other.TypeArguments && Parameters.SequenceEqual(other.Parameters, ParameterInfoComparer.Default)); }
public bool Equals(XunitTestTheoryTask other) { if (ReferenceEquals(null, other)) { return(false); } if (ReferenceEquals(this, other)) { return(true); } // Do not include base.Equals, so we don't try to compare Id or ParentId, // which will be different for each instance, and we're trying to act like // a value type return(ProjectId.Equals(other.ProjectId) && TypeName.Equals(other.TypeName) && MethodName.Equals(other.MethodName) && TheoryName.Equals(other.TheoryName)); }
public bool Equals(InvocationExpression compareNode) { return (compareNode != null && MethodName?.Equals(compareNode.MethodName) != false && Modifiers?.Equals(compareNode.Modifiers) != false && SemanticNamespace?.Equals(compareNode.SemanticNamespace) != false && CallerIdentifier?.Equals(compareNode.CallerIdentifier) != false && SemanticClassType?.Equals(compareNode.SemanticClassType) != false && SemanticMethodSignature?.Equals(compareNode.SemanticMethodSignature) != false && #pragma warning disable CS0618 // Type or member is obsolete Parameters?.SequenceEqual(compareNode.Parameters) != false && #pragma warning restore CS0618 // Type or member is obsolete Arguments?.SequenceEqual(compareNode.Arguments) != false && SemanticReturnType?.Equals(compareNode.SemanticReturnType) != false && SemanticOriginalDefinition?.Equals(compareNode.SemanticOriginalDefinition) != false && IsExtension == compareNode.IsExtension && base.Equals(compareNode)); }
public bool Equals(XunitTestTheoryTask other) { if (ReferenceEquals(null, other)) { return(false); } if (ReferenceEquals(this, other)) { return(true); } // Don't include base.Equals, as RemoteTask.Equals includes RemoteTask.Id // in the calculation, and this is a new guid generated for each new instance // Using RemoteTask.Id in the Equals means collapsing the return values of // IUnitTestElement.GetTaskSequence into a tree will fail (as no assembly, // or class tasks will return true from Equals) return(AssemblyLocation.Equals(other.AssemblyLocation) && TypeName.Equals(other.TypeName) && MethodName.Equals(other.MethodName) && TheoryName.Equals(other.TheoryName)); }
public override CILInstructionInstance Execute(CILInstructionInstance instructionInstance, CILProgramState state, CILProgramInstance programInstance, Stack <CILInstructionInstance> callStack) { var reflectedType = TypeSpecification.GetTypeSpecified(programInstance); var reflectedMethod = (MethodBase)reflectedType.GetMethod(MethodName, GetMethodArgumentRuntimeTypes(programInstance).ToArray()); if (reflectedMethod == null && MethodName.Equals(".ctor") && ParentMethod.IsConstructor) { return(instructionInstance.GetNextInstructionInstance()); } var methodArguments = new List <object>(); for (int i = 0; i < MethodArgumentTypes.Count; i++) { var argumentType = GetMethodArgumentRuntimeTypes(programInstance)[MethodArgumentTypes.Count - i - 1]; var argument = state.Stack.Pop(); var methodArgument = ConvertHelper.ConvertIfPossible(argument, argumentType); methodArguments.Add(methodArgument); } methodArguments.Reverse(); object methodObject = null; if (CallConvention.Instance) { methodObject = state.Stack.Pop(); if (methodObject is Guid) { var objectAddress = (Guid)methodObject; methodObject = ParentMethod.GetLocalByAddress(objectAddress); } } var methodObjectToCall = methodObject; if (methodObjectToCall is CILClassInstance) { methodObjectToCall = (methodObjectToCall as CILClassInstance).BaseInstance; } if (methodObject is CILClassInstance) { var cilClass = (methodObject as CILClassInstance)._cilClass; var cilMethod = cilClass.Methods.SingleOrDefault(m => m.MethodName == this.MethodName && CILantroType.CompareArgumentTypes(m.ArgumentTypes.Select(at => at.GetRuntimeType(programInstance)).ToArray(), this.GetMethodArgumentRuntimeTypes(programInstance).ToArray())); while (cilClass != null && cilMethod == null) { cilClass = cilClass.ExtendsClass; if (cilClass != null) { cilMethod = cilClass.Methods.SingleOrDefault(m => m.MethodName == this.MethodName && CILantroType.CompareArgumentTypes(m.ArgumentTypes.Select(at => at.GetRuntimeType(programInstance)).ToArray(), this.GetMethodArgumentRuntimeTypes(programInstance).ToArray())); } } if (cilMethod != null) { var newMethodInfo = new CILantroMethodInfo(cilMethod, programInstance, cilMethod.ReturnType.GetRuntimeType(programInstance)); reflectedMethod = newMethodInfo; } } if (reflectedMethod is CILantroMethodInfo) { callStack.Push(instructionInstance.GetNextInstructionInstance()); var cilantroMethodInfo = reflectedMethod as CILantroMethodInfo; CILMethod methodToCall = null; object obj = methodObject; //object obj = null; if (CallConvention.Instance) { //obj = state.Stack.Pop(); var cilClassInstance = obj as CILClassInstance; var cilClass = cilClassInstance._cilClass; while (cilClass != null) { var matchingMethod = cilClass.Methods.FirstOrDefault(m => m.MethodName.Equals(MethodName) && CILantroType.CompareArgumentTypes(GetMethodArgumentRuntimeTypes(programInstance).ToArray(), m.ArgumentTypes.Select(ct => ct.GetRuntimeType(programInstance)).ToArray())); if (matchingMethod != null) { methodToCall = matchingMethod; break; } cilClass = programInstance.Program.Classes.FirstOrDefault(c => c.ClassName.UniqueName == cilClass.Extends.UniqueName); } } if (methodToCall == null) { methodToCall = cilantroMethodInfo.Method; } return(methodToCall.CreateInstance(obj, methodArguments.ToArray()).GetFirstInstructionInstance()); } var methodResult = reflectedMethod.Invoke(methodObjectToCall, methodArguments.ToArray()); if (MethodReturnType.GetRuntimeType(programInstance) != typeof(void)) { state.Stack.Push(methodResult); } return(instructionInstance.GetNextInstructionInstance()); }
private CodeFunction GetMethod() { CodeClass clazz = ProjectItemHelper.GetClass(ProjectItem); if (clazz != null) { foreach (CodeElement codeElement in clazz.Children) { CodeFunction codeFunction = codeElement as CodeFunction; if (codeFunction != null) { if (codeFunction.Parameters.Count == 0 && codeFunction.Type.TypeKind.Equals(vsCMTypeRef.vsCMTypeRefVoid) && MethodName.Equals(codeFunction.Name)) { return(codeFunction); } } } } return(null); }
public override CILInstructionInstance Execute(CILInstructionInstance instructionInstance, CILProgramState state, CILProgramInstance programInstance, Stack <CILInstructionInstance> callStack) { var reflectedType = TypeSpecification.GetTypeSpecified(programInstance); var reflectedMethod = (MethodBase)reflectedType.GetMethod(MethodName, GetMethodArgumentRuntimeTypes(programInstance).ToArray()); if (reflectedMethod == null && MethodName.Equals(".ctor")) { var reflectedConstructor = reflectedType.GetConstructor(GetMethodArgumentRuntimeTypes(programInstance).ToArray()); if (reflectedConstructor == null) { reflectedConstructor = reflectedType.GetConstructor(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, GetMethodArgumentRuntimeTypes(programInstance).ToArray(), null); } reflectedMethod = (MethodBase)reflectedConstructor; } var methodArguments = new List <object>(); for (int i = 0; i < MethodArgumentTypes.Count; i++) { var argumentType = GetMethodArgumentRuntimeTypes(programInstance)[MethodArgumentTypes.Count - i - 1]; var argument = state.Stack.Pop(); var methodArgument = ConvertHelper.ConvertIfPossible(argument, argumentType); methodArguments.Add(methodArgument); } methodArguments.Reverse(); if (reflectedMethod is CILantroMethodInfo) { callStack.Push(instructionInstance.GetNextInstructionInstance()); object obj = null; if (CallConvention.Instance) { obj = state.Stack.Pop(); } var cilantroMethod = reflectedMethod as CILantroMethodInfo; return(cilantroMethod.Method.CreateInstance(obj, methodArguments.ToArray()).GetFirstInstructionInstance()); } object methodObject = null; if (CallConvention.Instance) { methodObject = state.Stack.Pop(); if (methodObject is Guid) { var objectAddress = (Guid)methodObject; methodObject = ParentMethod.GetLocalByAddress(objectAddress); } } var methodObjectToCall = methodObject; if (methodObjectToCall is CILClassInstance) { methodObjectToCall = (methodObjectToCall as CILClassInstance).BaseInstance; } var methodResult = reflectedMethod.Invoke(methodObjectToCall, methodArguments.ToArray()); if (MethodReturnType.GetRuntimeType(programInstance) != typeof(void)) { state.Stack.Push(methodResult); } else if (MethodName.Equals(".ctor")) { state.Stack.Push(methodObject); } return(instructionInstance.GetNextInstructionInstance()); }
public bool IsReduceByKey() { return(MethodName.Equals("reduceByKey", StringComparison.OrdinalIgnoreCase)); }