public static EqualExpression Equal(FunctorInfo functor, object value, object[] tuple) { int length = tuple.Length; ConstantExpression[] expressions = new ConstantExpression[length]; for (int i = 0; i < length; ++i) { object tuple_i = tuple[i]; expressions[i] = Constant((tuple_i is Variable x1) ? x1.Value : tuple_i); } ConstantExpression _value = Constant((value is Variable x2) ? x2.Value : value); CompoundExpression compound = Compound(functor, expressions); return(Equal(compound, _value)); }
public static EqualExpression Equal(FunctorInfo functor, object[] data) { int length = data.Length; ConstantExpression[] expressions = new ConstantExpression[length - 1]; for (int i = 1; i < length; ++i) { object data_i = data[i]; expressions[i - 1] = Constant((data_i is Variable x) ? x.Value : data_i); } ConstantExpression value = Constant(data[0]); CompoundExpression compound = Compound(functor, expressions); return(Equal(compound, value)); }
/// <summary> Returns info about all callbacks registered to the event handler. </summary> public static IEnumerable <EventFunctor> GetCallbacks(CallbackEventHandler handler) { var registry = CallbackEventHandlerRef.GetCallbackRegistry(handler); var callbackList = EventCallbackRegistryRef.GetCallbackListForWriting(registry); var list = EventCallbackListRef.GetList(callbackList); // Avoids modified collection error on unregister var tempList = new List <object>(list.Count); foreach (var item in list) { tempList.Add(item); } foreach (var functor in tempList) { var functorType = functor.GetType(); if (!FunctorCache.infos.TryGetValue(functorType, out var info)) { info = new FunctorInfo(functorType); FunctorCache.infos.Add(functorType, info); } // TODO: Should it be optimized with lambdas? It might eat up a chunk of memory in extreme cases.. Need some benchmarking. var callback = (Delegate)info.m_Callback.GetValue(functor); var eventTypeId = (long)info.m_EventTypeId.GetValue(functor); var phase = (CallbackPhase)info.phase.GetValue(functor); yield return(new EventFunctor() { handler = handler, callback = callback, eventTypeId = eventTypeId, phase = phase, callbackRegistry = registry, }); } }
internal CompoundExpression(FunctorInfo functor, TermExpression[] arguments) { m_functor = functor; int length = arguments.Length; var parameters = functor.GetParameters(); var params_length = parameters.Length; if (params_length != length) { throw new ArgumentException("", nameof(arguments)); } var list = new List <TermExpression>(length); for (int i = 0; i < length; ++i) { var argument = arguments[i]; if (!parameters[i].ParameterType.IsAssignableFrom(argument.Type)) { throw new ArgumentException("", nameof(arguments)); } list.Add(argument); } m_arguments = new ReadOnlyCollection <TermExpression>(list); }
public static CompoundExpression Compound(FunctorInfo functor, params TermExpression[] arguments) { return(new CompoundExpression(functor, arguments)); }