public void Validate_EventReference_TriggerEventConsumed_ShouldFail() { //arrange var workflow = WorkflowDefinition.Create("fake", "fake", "fake") .AddEvent(new EventDefinition() { Kind = EventKind.Consumed, Name = "fake" }) .StartsWith("fake", flow => flow.Callback()) .End() .Build(); var eventRef = new EventReference() { TriggerEvent = "fake" }; //act var result = new EventReferenceValidator(workflow).Validate(eventRef); //assert result.Should() .NotBeNull(); result.Errors.Should() .NotBeNullOrEmpty() .And.Contain(e => e.PropertyName == nameof(EventReference.TriggerEvent)); }
public static void ExecutePendingInteropActions(IStoreSession session, ICalendarItemSeries calendarItemSeries, IStorageTranslator <ICalendarItemBase, Event> eventTranslator = null, IXSOFactory xsoFactory = null, ICalendarInteropLog logger = null) { xsoFactory = (xsoFactory ?? XSOFactory.Default); logger = (logger ?? CalendarInteropLog.Default); eventTranslator = (eventTranslator ?? EventTranslator.Instance); try { Event @event = eventTranslator.ConvertToEntity(calendarItemSeries); EventReference eventReference = new EventReference(xsoFactory, calendarItemSeries); SeriesPendingActionsInterop seriesPendingActionsInterop = new SeriesPendingActionsInterop(logger, null) { Entity = @event, EntityKey = @event.Id, Scope = (Events)eventReference.Events }; seriesPendingActionsInterop.Execute(null); } catch (Exception ex) { ExTraceGlobals.CalendarInteropTracer.TraceError <string, Exception>(0L, "Error executing pending interop actions for series {0}. Error {1}", calendarItemSeries.SeriesId, ex); logger.SafeLogEntry(session, ex, false, "Error executing pending interop actions for series {0}.", new object[] { calendarItemSeries.SeriesId }); throw; } }
public MemberIdentifier(ITypeInfoSource ti, EventReference er) { Type = MemberType.Event; Name = er.Name; ReturnType = er.EventType; GenericArgumentCount = 0; ParameterTypes = null; ti.CacheProxyNames(er); var ed = er.Resolve(); if (ed != null) { if (ed.AddMethod != null) { IsStatic = ed.AddMethod.IsStatic; } else if (ed.RemoveMethod != null) { IsStatic = ed.RemoveMethod.IsStatic; } else { // FIXME IsStatic = false; } } else { // FIXME IsStatic = false; } HashCode = Type.GetHashCode() ^ Name.GetHashCode(); }
public RaiseEventExpression(EventReference @event, MethodReference invokeMethodReference, ExpressionCollection arguments, IEnumerable <Instruction> instructions) : base(instructions) { this.Event = @event; this.InvokeMethodReference = invokeMethodReference; this.Arguments = arguments; }
/// <summary> /// Gets the <see cref="MemberId"/> for the event. /// </summary> public static MemberId ToMemberId(this EventReference eventReference) { return(new EventId( eventReference.DeclaringType.ToTypeId(), eventReference.Name )); }
/// <summary> /// Initializes a new instance of the <see cref="EventEmitter"/> class. /// </summary> /// <param name="parent">The parent.</param> /// <param name="evt">The evt.</param> public EventEmitter(TypeEmitter parent, EventReference evt) { Parent = parent; Target = evt as EventDefinition ?? evt.Resolve(); if (Target.AddMethod != null) { add = new MethodEmitter(parent, Target.AddMethod); } else { var existing = parent.Target.GetMethod($"add_{Target.Name}", parent.Context.Module.TypeSystem.Void, new[] { evt.EventType }, new GenericParameter[0]); if (existing != null) { Target.AddMethod = existing.Resolve(); add = new MethodEmitter(parent, Target.AddMethod); } } if (Target.RemoveMethod != null) { remove = new MethodEmitter(parent, Target.RemoveMethod); } else { var existing = parent.Target.GetMethod($"remove_{Target.Name}", parent.Context.Module.TypeSystem.Void, new[] { evt.EventType }, new GenericParameter[0]); if (existing != null) { Target.RemoveMethod = existing.Resolve(); remove = new MethodEmitter(parent, Target.RemoveMethod); } } }
/// <summary> /// Try to resolve definition from reference. /// </summary> internal static EventDefinition Resolve(this EventReference evt, ReachableContext context) { var declType = evt.DeclaringType.Resolve(context); var resolver = new GenericsResolver(declType); return((declType == null) ? null : declType.Events.FirstOrDefault(x => x.AreSame(evt, resolver.Resolve))); }
static MethodAttributes GetEvtVisibility(EventReference evt) { MethodAttributes ret = MethodAttributes.Public; EventDefinition Definition = evt.Resolve(); if (Definition != null) { MethodReference addMethod = Definition.AddMethod; MethodDefinition addDecl = (addMethod == null) ? null : addMethod.Resolve(); MethodReference removeMethod = Definition.RemoveMethod; MethodDefinition removeDecl = (removeMethod == null) ? null : removeMethod.Resolve(); MethodReference invokeMethod = Definition.InvokeMethod; MethodDefinition invokeDecl = (invokeMethod == null) ? null : invokeMethod.Resolve(); if (((addDecl != null) && (removeDecl != null)) && (invokeDecl != null)) { if (((addDecl.Attributes & MethodAttributes.MemberAccessMask) == (removeDecl.Attributes & MethodAttributes.MemberAccessMask)) && ((addDecl.Attributes & MethodAttributes.MemberAccessMask) == (invokeDecl.Attributes & MethodAttributes.MemberAccessMask))) { return(addDecl.Attributes & MethodAttributes.MemberAccessMask); } } else if ((addDecl != null) && (removeDecl != null)) { if ((addDecl.Attributes & MethodAttributes.MemberAccessMask) == (removeDecl.Attributes & MethodAttributes.MemberAccessMask)) { return(addDecl.Attributes & MethodAttributes.MemberAccessMask); } } else if ((addDecl != null) && (invokeDecl != null)) { if ((addDecl.Attributes & MethodAttributes.MemberAccessMask) == (invokeDecl.Attributes & MethodAttributes.MemberAccessMask)) { return(addDecl.Attributes & MethodAttributes.MemberAccessMask); } } else if ((removeDecl != null) && (invokeDecl != null)) { if ((removeDecl.Attributes & MethodAttributes.MemberAccessMask) == (invokeDecl.Attributes & MethodAttributes.MemberAccessMask)) { return(removeDecl.Attributes & MethodAttributes.MemberAccessMask); } } else { if (addDecl != null) { return(addDecl.Attributes & MethodAttributes.MemberAccessMask); } if (removeDecl != null) { return(removeDecl.Attributes & MethodAttributes.MemberAccessMask); } if (invokeDecl != null) { return(invokeDecl.Attributes & MethodAttributes.MemberAccessMask); } } } return(ret); }
public void Equality_Default() { var a = new EventReference(); var b = new EventReference(); Assert.AreEqual(a, b); Assert.AreEqual(a.GetHashCode(), b.GetHashCode()); }
public static EventReference make(EventReference eventReference, GenericInstanceType git) { if (git == null) { return(eventReference); } return(new EventReferenceInstance(eventReference, git).makeInstance()); }
/// <summary> /// Are the given events the same? /// </summary> public static bool AreSame(this EventReference a, EventReference b, Func <GenericParameter, TypeReference> genericParamResolver) { if (a.Name != b.Name) { return(false); } return(a.EventType.AreSame(b.EventType, genericParamResolver)); }
EventReference GetEventReference(EventReference source) { EventReference mr = source; TypeReference tr = GetTypeReference(mr.DeclaringType, false); EventReference result = GetEventReference(tr, mr); return(result); }
public void DefaultValues() { var sut = new EventReference(); Assert.AreEqual(new VariableReference(), sut.Reference); Assert.AreEqual(Names.UnknownEvent, sut.EventName); Assert.AreNotEqual(0, sut.GetHashCode()); Assert.AreNotEqual(1, sut.GetHashCode()); }
private void PlaySound(EventReference sound) { if (this._playInteractionSound && !sound.IsNull) { this._soundEventInstance.stop(STOP_MODE.IMMEDIATE); this._soundEventInstance = FMODUnity.RuntimeManager.CreateInstance(sound); this._soundEventInstance.start(); } }
/// <summary> /// Creates a new transaction /// </summary> /// <param name="reference">The event reference to create the transaction for</param> /// <returns>An id of the transaction</returns> private Guid CreateNewTransaction(EventReference reference) { var transaction = Guid.NewGuid(); _transactions.Add(transaction); _activeTransaction.Push(transaction); _transactionEvents.Add(transaction, CalculateEvents(reference)); return(transaction); }
void addEventReference(EventReference eventReference) { if (eventReference == null) { return; } addMemberReference(eventReference); pushMember(eventReference.EventType); }
public void Collect(EventReference evet) { EventDefinition def; if ((def = evet as EventDefinition ?? evet.Resolve()) != null) { Collect(def); } }
public void EventReference_static() { var sst = new EventReference { EventName = Names.Event("static [EventType,P] [DeclaringType,P].E") }; AssertPrint(sst, "DeclaringType.E"); }
private static string Format(EventReference @event) { var sb = new StringBuilder(); sb.Append(CecilFormat.GetTypeName(@event.DeclaringType)); sb.Append('.'); sb.Append(@event.Name); return(sb.ToString()); }
public EventMeta Resolve(EventReference eventRef) { TypeMeta type = this.Resolve(eventRef.DeclaringType); if (type != null) { return(type.Resolve(eventRef)); } return(null); }
public void Equality_DifferentReference() { var a = new EventReference { Reference = SomeRef }; var b = new EventReference(); Assert.AreNotEqual(a, b); Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode()); }
public void EventReference() { var sst = new EventReference { EventName = Names.Event("[EventType,P] [DeclaringType,P].E"), Reference = SSTUtil.VariableReference("o") }; AssertPrint(sst, "o.E"); }
public static EventDefinition TryResolve(this ModuleDefinition scope, EventReference eventRef) { var matchingType = TryResolve(scope, eventRef.DeclaringType); if (matchingType == null) { return(null); } return(matchingType.Events.FirstOrDefault(e => e.Name == eventRef.Name)); }
public MemberIdentifier(ITypeInfoSource ti, EventReference er) { Type = MemberType.Event; Name = er.Name; ReturnType = er.EventType; GenericArgumentCount = 0; ParameterTypes = null; ti.CacheProxyNames(er); HashCode = Type.GetHashCode() ^ Name.GetHashCode(); }
protected virtual string GetEventName(EventReference @event) { EventDefinition eventDefinition = @event.Resolve(); if (eventDefinition != null && eventDefinition.Module.FilePath == this.ModuleContext.Module.FilePath) { return(this.ModuleContext.RenamedMembersMap[eventDefinition.MetadataToken.ToUInt32()]); } return(Utilities.EscapeNameIfNeeded(GenericHelper.GetNonGenericName(@event.Name), this.Language)); }
public void SettingValues() { var sut = new EventReference { Reference = SomeRef, EventName = SomeEvent }; Assert.AreEqual(SomeRef, sut.Reference); Assert.AreEqual(SomeEvent, sut.EventName); }
public static EventDefinition TryResolve(this EventReference r) { try { return(r.Resolve()); } catch (Exception) { return(null); } }
public void VisitInstruction(Instruction instr) { Instruction instruction = instr; if (instruction.Operand is FieldReference) { FieldReference fr = (FieldReference)instruction.Operand; if (fr.DeclaringType.Module.Assembly.Name.Name == Context.ExternalAssemblyName) { FieldDefinition fd = Context.InternalSymbols.GetField(fr.Name); if (fd != null) { instruction.Operand = fd; } else { Console.Error.WriteLine("Accessing fields in native libraries in not supported (yet!)"); Environment.Exit(1); } } else { TypeReference tr = GetTypeReference(fr.DeclaringType); if (tr is TypeDefinition) { instruction.Operand = (tr as TypeDefinition).Fields.GetField(fr.Name); } else { instruction.Operand = GetMemberReference(Target.MainModule.MemberReferences, fr); } } fr = (FieldReference)instruction.Operand; fr.FieldType = GetTypeReference(fr.FieldType); } else if (instruction.Operand is MethodReference) { MethodReference mr = (MethodReference)instruction.Operand; instruction.Operand = GetMethodReference(mr); } else if (instruction.Operand is TypeReference) { TypeReference tr = (TypeReference)instruction.Operand; instruction.Operand = GetTypeReference(tr); } else if (instruction.Operand is EventReference) { EventReference et = (EventReference)instruction.Operand; instruction.Operand = GetEventReference(et); } }
private EventDefinition CreateEventDefinition(EventReference reference, TypeDefinition declaringTypeDefinition, bool recursionGuard = true) { if (MemberDefinitionMap.ContainsKey(reference) || recursionGuard) { return(GetOrCreateMember(reference, declaringTypeDefinition, CreateEventDefinition)); } EventDefinition definition = new EventDefinition(reference.Name, EventAttributes.None, ImportType(reference.EventType, declaringTypeDefinition, context: null)); declaringTypeDefinition.Events.Add(definition); return(definition); }
public static void AcceptVisitor <TResult> ( this EventReference eventReference, MetadataVisitor <TResult> visitor) { if (!visitor.ShouldTraverseInto(visitor.VisitEventReference(eventReference))) { return; } eventReference.EventType.AcceptVisitor(visitor); eventReference.DeclaringType.AcceptVisitor(visitor); }