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));
}
