//-----------------------------------------------------------------------------------------------------------------------------------------------------
private static void EmitPropertyComparison(
FunctionMethodWriter <int> m,
PropertyInfo prop,
Local <TypeTemplate.TPrimary> otherTuple,
Local <int> compareResult)
{
var backingField = m.This <TypeTemplate.TPrimary>().BackingFieldOf <TypeTemplate.TProperty>(prop);
var otherValue = m.Local(initialValue: otherTuple.Prop <TypeTemplate.TProperty>(prop));
if (backingField.OperandType.IsValueType)
{
m.If(backingField > otherValue).Then(() => {
m.Return(1);
})
.ElseIf(backingField < otherValue).Then(() => {
m.Return(-1);
})
.ElseIf(backingField != otherValue).Then(() => {
m.Return(1);
});
}
else if (typeof(IComparable).IsAssignableFrom(backingField.OperandType))
{
compareResult.Assign(backingField.CastTo <IComparable>().Func <object, int>(x => x.CompareTo, otherValue));
m.If(compareResult != 0).Then(() => m.Return(compareResult));
}
else
{
throw new NotSupportedException("Cannot compare values of type: " + backingField.OperandType.FullName);
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public Local <T> Local <T>(IOperand <T> initialValue)
{
var local = new Local <T>(m_OwnerMethod);
local.Assign(initialValue);
return(local);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
protected override void OnEvent(EventMember member, Func <EventDecorationBuilder> decorate)
{
Local <EventInterceptorClosure <TypeTemplate.TEventArgs> > interceptorClosure = null;
Argument <EventHandler <TypeTemplate.TEventArgs> > value = null;
decorate().OnAdd()
.OnBefore(w => {
value = w.Arg1 <EventHandler <TypeTemplate.TEventArgs> >();
interceptorClosure = w.Local <EventInterceptorClosure <TypeTemplate.TEventArgs> >();
interceptorClosure.Assign(w.New <EventInterceptorClosure <TypeTemplate.TEventArgs> >());
interceptorClosure.Field(x => x.EventName).Assign(member.Name);
interceptorClosure.Field(x => x.Log).Assign(m_LogField);
interceptorClosure.Field(x => x.Handler).Assign(value);
value.Assign(
w.MakeDelegate <EventInterceptorClosure <TypeTemplate.TEventArgs>, EventHandler <TypeTemplate.TEventArgs>, TypeTemplate.TEventHandler>(
interceptorClosure,
x => x.HandleEvent
)
);
})
.OnSuccess(w =>
m_EventHandlerMapField.Add(interceptorClosure.Field(x => x.Handler), value)
);
decorate().OnRemove()
.OnBefore(w => {
value = w.Arg1 <EventHandler <TypeTemplate.TEventArgs> >();
var interceptingHandler = w.Local <EventHandler <TypeTemplate.TEventArgs> >();
w.If(m_EventHandlerMapField.TryGetValue(value, interceptingHandler) == w.Const(true)).Then(() =>
value.Assign(interceptingHandler)
);
});
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
#region IHapilForeachDoSyntax<TItem> Members
public void Do(Action <ILoopBody, Local <TElement> > body)
{
using (var scope = new StatementScope(m_BodyBlock, loopStatement: this))
{
var writer = scope.Writer;
var enumerator = writer.Local <IEnumerator <TElement> >();
enumerator.Assign(m_Collection.CastTo <IEnumerable <TElement> >().Func <IEnumerator <TElement> >(x => x.GetEnumerator));
writer.Using(enumerator).Do(() => {
m_InnerWhile = (WhileStatement)writer.While(enumerator.Func <bool>(e => e.MoveNext));
m_InnerWhile.Do(loop => {
m_Element.Assign(enumerator.Prop(e => e.Current));
body(this, m_Element);
});
});
}
}
