public static void Synchronize <T>(this IValueStateObserver <T> state, IEventTrigger <T> evnt) where T : struct
{
state.OnChange.Register(evnt); if (evnt.IsValid)
{
evnt.Trigger(state.Value);
}
}
internal void SubscribeEvents(IEventTrigger eventTrigger, IEnumerable <Tuple <EventInfo, ulong> > events)
{
var eventsToRegister = new List <ulong>();
foreach (var eventKey in events)
{
var subscribedInfo = new Lazy <SubscribedEventInfo>(() => new SubscribedEventInfo(eventKey.Item1),
LazyThreadSafetyMode.None);
var addedSubscribedInfo = _subscribedEvents.GetOrAdd(eventKey.Item2, l => subscribedInfo.Value);
lock (addedSubscribedInfo.TriggersLock)
{
addedSubscribedInfo.Triggers.Add(eventTrigger);
}
if (subscribedInfo.IsValueCreated)
{
eventsToRegister.Add(eventKey.Item2);
}
}
if (eventsToRegister.Count > 0)
{
SendEventAction(true, eventsToRegister);
}
}
public void Register(IEventTrigger listener)
{
if (listener != null)
{
_listeners.Add(listener);
}
}
public static void Register(this IEnumerable <IEventRegister> registers, IEventTrigger listener)
{
foreach (var register in registers)
{
register.Register(listener);
}
}
internal void UnsubscribeEvents(IEventTrigger eventTrigger, IEnumerable <ulong> events)
{
var eventsToUnregister = new List <ulong>();
foreach (var eventKey in events)
{
if (_subscribedEvents.TryGetValue(eventKey, out var subscribedEventInfo))
{
lock (subscribedEventInfo.TriggersLock)
{
subscribedEventInfo.Triggers.Remove(eventTrigger);
if (subscribedEventInfo.Triggers.Count == 0)
{
eventsToUnregister.Add(eventKey);
_subscribedEvents.TryRemove(eventKey, out var _);
}
}
}
}
if (eventsToUnregister.Count > 0)
{
SendEventAction(false, eventsToUnregister);
}
}
private void TriggerEvents()
{
for (int i = 0; i < triggers.Length; i++)
{
IEventTrigger iEventTrigger = triggers[i].GetComponent(typeof(IEventTrigger)) as IEventTrigger;
iEventTrigger.OnEventTrigger();
}
}
public static void Synchronize <T>(this IReferenceHolder <T> referenceHolder, IEventTrigger evnt, bool evenDefault)
{
referenceHolder.OnReferenceSet.Register(evnt);
if (evenDefault || SafeNotDefault(referenceHolder.CurrentReference))
{
evnt.Trigger();
}
}
public object Deserialize(System.Xml.XmlReader xmlReader)
{
List <Profile> profiles = new List <Profile>();
xmlReader.ReadStartElement("Profiles");
while (xmlReader.IsStartElement("Profile"))
{
Profile item = new Profile();
xmlReader.ReadStartElement();
item.Name = xmlReader.ReadElementString("Name");
item.Enabled = bool.Parse(xmlReader.ReadElementString("Enabled"));
if (xmlReader.IsStartElement("EventTrigger"))
{
xmlReader.ReadStartElement();
ISerializer ser = SerializerProvider.GetSerializer(typeof(ITrigger));
IEventTrigger trigger = (IEventTrigger)ser.Deserialize(xmlReader);
item.EventTrigger = trigger;
xmlReader.ReadEndElement();
SerializerHelper.ReadWhiteSpace(xmlReader);
}
item.StateTriggers = new List <IStateTrigger>();
if (xmlReader.IsStartElement("StateTriggers"))
{
xmlReader.ReadStartElement();
SerializerHelper.ReadWhiteSpace(xmlReader);
while (xmlReader.IsStartElement())
{
ISerializer ser = SerializerProvider.GetSerializer(typeof(ITrigger));
IStateTrigger trigger = (IStateTrigger)ser.Deserialize(xmlReader);
item.StateTriggers.Add(trigger);
}
xmlReader.ReadEndElement();
SerializerHelper.ReadWhiteSpace(xmlReader);
}
if (xmlReader.IsStartElement("EnterStateAction"))
{
xmlReader.ReadStartElement();
SerializerHelper.ReadWhiteSpace(xmlReader);
item.ActionToExecute = SerializerHelper.DeserializeAction(xmlReader);
xmlReader.ReadEndElement();
SerializerHelper.ReadWhiteSpace(xmlReader);
}
if (xmlReader.IsStartElement("ExitStateAction"))
{
xmlReader.ReadStartElement();
SerializerHelper.ReadWhiteSpace(xmlReader);
item.ActionToExecute = SerializerHelper.DeserializeAction(xmlReader);
xmlReader.ReadEndElement();
SerializerHelper.ReadWhiteSpace(xmlReader);
}
xmlReader.ReadEndElement();
SerializerHelper.ReadWhiteSpace(xmlReader);
profiles.Add(item);
}
xmlReader.ReadEndElement();
return(profiles);
}
public void EventWithReturnValue3()
{
BeethovenFactory factory = new BeethovenFactory();
ITestEvents test = factory.Generate <ITestEvents>();
IEventTrigger trigger = factory.CreateEventTrigger(test, nameof(ITestEvents.WithReturnValue));
test.WithReturnValue += value => false;
test.WithReturnValue += value => true;
bool returnValue = (bool)trigger.Notify("123");
Assert.AreEqual(true, returnValue);
}
public static Message CreateNewMessage(string messageText, IEventTrigger executeBeforeVanish = null)
{
var message = new Message(messageText);
_messages.Add(message);
if (executeBeforeVanish != null)
{
message.OnFalseState.Register(executeBeforeVanish);
}
message.OnFalseState.Register(UpdateData);
UpdateData();
return(message);
}
public void EventSimpleRemoved1()
{
BeethovenFactory factory = new BeethovenFactory();
ITestEvents test = factory.Generate <ITestEvents>();
IEventTrigger trigger = factory.CreateEventTrigger(test, nameof(ITestEvents.Simple));
bool simpleEventCalled = false;
Action delegate1 = delegate { simpleEventCalled = true; };
test.Simple += delegate1;
test.Simple -= delegate1;
trigger.Notify();
Assert.IsFalse(simpleEventCalled);
}
public void EventWithParameters2()
{
BeethovenFactory factory = new BeethovenFactory();
ITestEvents test = factory.Generate <ITestEvents>();
IEventTrigger trigger = factory.CreateEventTrigger(test, nameof(ITestEvents.WithParameters));
double gotValue1 = 0;
string gotValue2 = null;
test.WithParameters += (value1, value2) => gotValue1 = value1;
test.WithParameters += (value1, value2) => gotValue2 = value2;
trigger.Notify(54.0, "abe");
Assert.AreEqual(54.0, gotValue1);
Assert.AreEqual("abe", gotValue2);
}
public void EventWithReturnValue1()
{
BeethovenFactory factory = new BeethovenFactory();
ITestEvents test = factory.Generate <ITestEvents>();
IEventTrigger trigger = factory.CreateEventTrigger(test, nameof(ITestEvents.WithReturnValue));
bool withReturnValueEventCalled = false;
bool otherEventCalled = false;
test.Simple += delegate { otherEventCalled = true; };
test.WithParameters += delegate { otherEventCalled = true; };
test.WithReturnValue += delegate { return(withReturnValueEventCalled = true); };
trigger.Notify("");
Assert.IsTrue(withReturnValueEventCalled);
Assert.IsFalse(otherEventCalled);
}
public void EventSimple2()
{
TypeDefinition <ITestEvents> typeDefinition = new TypeDefinition <ITestEvents>();
ITestEvents test = typeDefinition.Create();
IEventTrigger trigger = typeDefinition.CreateEventTrigger(test, nameof(ITestEvents.Simple));
bool simpleEventCalled = false;
bool otherEventCalled = false;
test.Simple += delegate { simpleEventCalled = true; };
test.WithParameters += delegate { otherEventCalled = true; };
test.WithReturnValue += delegate { return(otherEventCalled = true); };
trigger.Notify();
Assert.IsTrue(simpleEventCalled);
Assert.IsFalse(otherEventCalled);
}
public void EventWithReturnValue2()
{
BeethovenFactory factory = new BeethovenFactory();
ITestEvents test = factory.Generate <ITestEvents>();
IEventTrigger trigger = factory.CreateEventTrigger(test, nameof(ITestEvents.WithReturnValue));
string gotValue = null;
test.WithReturnValue += value =>
{
gotValue = value;
return(true);
};
bool returnValue = (bool)trigger.Notify("123");
Assert.AreEqual(true, returnValue);
Assert.AreEqual("123", gotValue);
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.CompareTag("Player") && !isActivated)
{
isActivated = true;
Character character = collision.gameObject.GetComponent <Character>();
if (destroyEquipmentItems)
{
character.DestroyEquipmentItems();
}
for (int i = 0; i < triggers.Length; i++)
{
IEventTrigger iEventTrigger = triggers[i].GetComponent(typeof(IEventTrigger)) as IEventTrigger;
iEventTrigger.OnEventTrigger();
}
}
}
/// <summary>
/// Processes determining the event trigger.
/// </summary>
/// <param name="args">
/// The args.
/// </param>
public override void Process(PlayerEventArgs args)
{
Assert.ArgumentNotNull(args, "args");
Assert.ArgumentNotNull(args.Properties, "args.Parameters");
IEventTrigger trigger = MediaFrameworkContext.GetEventTrigger(args.Properties.Template);
if (trigger != null)
{
args.Trigger = trigger;
}
else
{
LogHelper.Warn("Player event trigger couldn't be determine for the player.", this);
args.AbortPipeline();
}
}
public IPersonCollection CreatePersonCollection()
{
List <IPerson> persons = new List <IPerson>();
CollectionChangedImplementation <IPerson> collectionChanged =
new CollectionChangedImplementation <IPerson>(person => persons.IndexOf(person));
TypeDefinition <IPersonCollection> typeDefinition =
new TypeDefinition <IPersonCollection>(
new LinkedObjects(
new MappedMethod("Remove", collectionChanged, nameof(collectionChanged.PreRemove)),
persons,
collectionChanged));
IEventTrigger trigger = null;
typeDefinition.RegisterEvent(
nameof(IPersonCollection.CollectionChanged),
eventTrigger => trigger = eventTrigger);
IPersonCollection personCollection = typeDefinition.Create();
collectionChanged.CollectionChanged += (sender, args) => trigger.Notify(sender, args);
return(personCollection);
}
public ProfileChangeProcessor(
IProfileStore profileStore,
ICategoryStore categoryStore,
ICategoryLinkStore linkStore,
IEventTrigger eventTrigger,
IProfileCache profileCache,
ICategoryCache cache)
{
Ensure.Any.IsNotNull(profileStore, nameof(profileStore));
Ensure.Any.IsNotNull(categoryStore, nameof(categoryStore));
Ensure.Any.IsNotNull(linkStore, nameof(linkStore));
Ensure.Any.IsNotNull(profileCache, nameof(profileCache));
Ensure.Any.IsNotNull(cache, nameof(cache));
Ensure.Any.IsNotNull(eventTrigger, nameof(eventTrigger));
_profileStore = profileStore;
_categoryStore = categoryStore;
_linkStore = linkStore;
_eventTrigger = eventTrigger;
_profileCache = profileCache;
_cache = cache;
}
public ValidatedCallOnce(System.Func <bool> validation, IEventTrigger callback) : base(callback)
{
_validation = validation;
}
public Voidable(System.Action act)
{
_callback = new ActionEventCapsule(act);
}
public Voidable(IEventTrigger callback)
{
_callback = callback;
}
public static IEventTrigger <T> Filtered <T, K>(this IEventTrigger <K> register, Func <T, K> filter) => new EventFilter <T, K>(register, filter);
public void Register(IEventTrigger listener) => Debug.LogError($"{listener} Register in a ERROR event");
public bool Unregister(IEventTrigger listener)
{
Debug.LogError($"{listener} Unregister in a ERROR event"); return(true);
}
public ConditionalEventListener(IEventTrigger evnt, System.Func <bool> condition) : base(condition)
{
_evnt = evnt;
}
public static IEventTrigger Validated(this IEventValidator validator, IEventTrigger act) => new ConditionalEventListener(act, CombinedCondition(validator, act));
public ValidatedCallOnce(IEventValidator validator, IEventTrigger callback) : this(validator.CurrentValidationCheck, callback)
{
}
public CallOnce(IEventTrigger callback) : base(callback)
{
}
public static IEventTrigger <T, K, J> Validated <T, K, J>(this IEventValidator validator, IEventTrigger <T, K, J> act) => new ConditionalEventListener <T, K, J>(act, CombinedCondition(validator, act));
