public TypedValue Create(string memberName, Tree<T> parameters) {
return DoLoggedOperation(
string.Format("create {0}", memberName),
logging => {
var result = TypedValue.Void;
Operators.Do<RuntimeOperator<T>>(
o => o.CanCreate(memberName, parameters),
o => {
result = o.Create(memberName, parameters);
logging.LogResult(o, result);
});
return result;
});
}
public virtual TypedValue Parse(Type type, TypedValue instance, Tree<T> parameters) {
return DoLoggedOperation(
string.Format("parse {0}", type),
logging => {
var result = TypedValue.Void;
Operators.Do<ParseOperator<T>>(
o => o.CanParse(type, instance, parameters),
o => {
result = o.Parse(type, instance, parameters);
logging.LogResult(o, result);
});
return result;
});
}
public TypedValue Execute(TypedValue instance, Tree<T> parameters) {
return DoLoggedOperation(
string.Format("execute {0}", instance.ValueString),
logging => {
var result = TypedValue.Void;
Operators.Do<ExecuteOperator<T>>(
o => o.CanExecute(instance, parameters),
o => {
result = o.Execute(instance, parameters);
logging.LogResult(o, result);
});
return result;
});
}
public Tree<T> Compose(TypedValue instance) {
return DoLoggedOperation(
string.Format("compose {0}", instance.ValueString),
logging => {
Tree<T> result = null;
Operators.Do<ComposeOperator<T>>(
o => o.CanCompose(instance),
o => {
result = o.Compose(instance);
logging.Write(string.Format(" by {0}", o.GetType()));
});
return result;
});
}
public bool Compare(TypedValue instance, Tree<T> parameters) {
return DoLoggedOperation(
string.Format("compare {0}", instance.ValueString),
logging => {
bool result = false;
Operators.Do<CompareOperator<T>>(
o => o.CanCompare(instance, parameters),
o => {
result = o.Compare(instance, parameters);
logging.Write(string.Format(" by {0} = {1}", o.GetType(), result));
});
return result;
});
}
public TypedValue Invoke(TypedValue instance, string memberName, Tree<T> parameters) {
return DoLoggedOperation(
instance.Type != typeof (Logging)
? string.Format("invoke {0} {1}", instance.ValueString, memberName)
: string.Empty,
logging => {
var result = TypedValue.Void;
Operators.Do<RuntimeOperator<T>>(
o => o.CanInvoke(instance, memberName, parameters),
o => {
result = o.Invoke(instance, memberName, parameters);
logging.LogResult(o, result);
});
return result;
});
}
