public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
Predicate <PropertyTreeNavigator> predicate = ImplicitDirective(target, "source");
var node = children.FindAndRemove(predicate).FirstOrDefault();
if (node != null)
{
IServiceProvider serviceProvider = parent.GetBasicServices(node);
var uriContext = node as IUriContext;
TargetSourceDirective ss;
ss = parent.DirectiveFactory.CreateTargetSource(node, uriContext);
if (ss != null)
{
try {
target = target.BindStreamingSource(ss, serviceProvider);
} catch (PropertyTreeException) {
throw;
} catch (Exception ex) {
if (ex.IsCriticalException())
{
throw;
}
parent._errors.FailedToLoadFromSource(ss.Uri, ex, node.FileLocation);
}
}
}
return(target);
}
public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
Type type = target.ComponentType ?? typeof(object);
Type concreteClass = type.GetConcreteClass();
QualifiedName name = self.QualifiedName;
IServiceProvider serviceProvider = parent;
if (concreteClass != null && type != concreteClass)
{
target.BindTargetType(TypeReference.FromType(concreteClass), serviceProvider);
}
else if (type.IsComposable())
{
target.BindTargetProvider(name, null, serviceProvider);
}
if (target.Component == null && !target.ComponentType.GetTypeInfo().IsSealed)
{
// TODO This predicate is probably too loose
Predicate <PropertyTreeNavigator> predicate = t => t.Name == "type";
var node = children.FindAndRemove(predicate).FirstOrDefault();
ApplyType(parent, target, node);
}
return(PickBuilderTypeIfAvailable(target));
}
public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
target.ApplyUriContextToProperties(self.BaseUri);
children.FindAndRemove(t => Apply(parent, target, t)).All();
return(target);
}
public override PropertyTreeMetaObject BindInitializer(Expression expression, IExpressionContext context, IServiceProvider serviceProvider)
{
var values = expression.Evaluate(context);
if (values == null)
{
return(this);
}
if (!(values is IEnumerable))
{
values = new [] { values };
}
var myValues = ReflectionMetaObject.GetAddonElements((IEnumerable)values);
var addon = ReflectionMetaObject.FindAddonMethod(ComponentType, myValues);
if (addon == null)
{
var errors = serviceProvider.GetServiceOrDefault(PropertyTreeBinderErrors.Default);
errors.NoAddMethodSupported(component.GetType(), PropertyTreeBinderImpl.FindFileLocation(serviceProvider));
return(this);
}
foreach (var item in myValues)
{
addon.Invoke(Component, new object[] {
item
});
}
return(this);
}
private PropertyTreeMetaObject DoOperatorBind(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator navigator, OperatorDefinition op)
{
OperatorDefinition addon = op;
if (addon.DefaultParameter != null) {
Type itemType = ((PropertyTreeFactoryDefinition) addon).OutputType;
// TODO Use service activation (we have the output type)
var item = target.CreateChild(itemType);
var model = parent.Bind(item, navigator, null);
var args = new Dictionary<string, PropertyTreeMetaObject>
{
{ addon.DefaultParameter.Name, model }
};
try {
target.BindAddChild(op, args);
} catch (Exception ex) {
if (ex.IsCriticalException())
throw;
parent.errors.BadAddChild(target.ComponentType, ex, navigator.FileLocation);
}
} else {
// TODO The number and kinds of arguments are constrained. This should probably
// be enforced within schema operator reflection (spec)
Action<IReadOnlyDictionary<string, PropertyTreeMetaObject>> func;
var children = NodeList.Create(SelectChildren(navigator));
switch (addon.OperatorType) {
case OperatorType.Add:
func = args => {
var child = target.BindAddChild(addon, args);
if (child.ShouldBindChildren) {
parent.BindChildNodes(child, navigator, children);
}
};
break;
case OperatorType.Remove:
func = args => target.BindRemoveChild(addon, args);
break;
case OperatorType.Clear:
default:
func = args => target.BindClearChildren(addon, args);
break;
}
var services = parent.GetBasicServices(navigator);
var args2 = parent.ExtractParameterDictionary(op, target, services, children);
func(args2);
}
return target;
}
private void DoPropertyBind(PropertyTreeBinderImpl parent,
PropertyTreeMetaObject target,
PropertyTreeNavigator navigator,
PropertyDefinition property)
{
object ancestor = null;
PropertyTreeMetaObject ancestorMeta = null;
if (property.IsExtender) {
var ancestorType = property.DeclaringTreeDefinition.SourceClrType;
ancestorMeta = target.GetAncestors().Cast<PropertyTreeMetaObject>().FirstOrDefault(
t => ancestorType.IsAssignableFrom(t.ComponentType));
if (ancestorMeta != null)
ancestor = ancestorMeta.Component;
}
var component = target.Component;
PropertyTreeMetaObject propertyTarget = target.CreateChild(property, navigator.QualifiedName, ancestorMeta);
var services = new PropertyBindContext(
component,
property,
ServiceProvider.Compose(ServiceProvider.FromValue(navigator), parent))
{
LineNumber = navigator.LineNumber,
LinePosition = navigator.LinePosition,
};
propertyTarget = parent.Bind(propertyTarget, navigator, services);
target.BindSetMember(property, navigator.QualifiedName, propertyTarget, ancestorMeta, services);
}
public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent,
PropertyTreeMetaObject target,
PropertyTreeNavigator self,
NodeList children)
{
Type type = target.ComponentType ?? typeof(object);
// Select providers
if (type.IsProviderType())
{
var node = children.FindAndRemove(ImplicitDirective(target, "provider")).FirstOrDefault();
if (node != null)
{
var serviceProvider = parent.GetBasicServices(node);
var pro = parent.DirectiveFactory.CreateTargetProvider(type, node);
if (pro != null)
{
target = target.BindTargetProvider(pro, serviceProvider);
return(target);
}
}
}
return(target);
}
public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
IServiceProvider serviceProvider = parent.GetBasicServices(self);
int lineNumber = self.LineNumber;
int linePosition = self.LinePosition;
return(target.BindFileLocation(lineNumber, linePosition, serviceProvider));
}
bool IApplyMemberStep.Apply(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator node)
{
var member = target.SelectOperator(ImpliedName(node, target));
if (member != null) {
DoOperatorBind(parent, target, node, member);
return true;
}
return false;
}
bool IApplyMemberStep.Apply(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator node)
{
var member = target.SelectOperator(ImpliedName(node, target));
if (member != null)
{
DoOperatorBind(parent, target, node, member);
return(true);
}
return(false);
}
public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
if (target.ShouldConstruct)
{
var ctor = target.GetDefinition().Constructor;
if (ctor != null)
{
return(target.BindConstructor(ctor, Empty <string, PropertyTreeMetaObject> .ReadOnlyDictionary));
}
}
return(target);
}
private void ApplyType(PropertyTreeBinderImpl parent,
PropertyTreeMetaObject target,
PropertyTreeNavigator node)
{
if (node == null)
{
return;
}
var serviceProvider = parent.GetBasicServices(node);
target.BindTargetType(parent.DirectiveFactory.CreateTargetType(node), serviceProvider);
}
public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
QualifiedName name = self.QualifiedName;
var ctor = PropertyTreeDefinition.FromType(target.ComponentType).Constructor;
if (target.ShouldConstruct && ctor != null)
{
OperatorDefinition op = ctor;
var args = parent.ExtractParameterDictionary(op, target, parent.GetBasicServices(self), children);
target = target.BindConstructor(ctor, args);
}
return(target);
}
public override PropertyTreeMetaObject BindStreamingSource(StreamContext input, IServiceProvider serviceProvider)
{
var binder = serviceProvider.GetRequiredService <PropertyTreeMetaObjectBinder>();
var ss = binder.CreateStreamingSource(this, input, serviceProvider);
if (ss == null)
{
var errors = serviceProvider.GetServiceOrDefault(PropertyTreeBinderErrors.Default);
errors.CouldNotBindStreamingSource(this.ComponentType, PropertyTreeBinderImpl.FindFileLocation(serviceProvider));
return(this);
}
// Hydrate the existing instance
ss.Load(input, this.Component);
return(this);
}
bool IApplyMemberStep.Apply(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator node)
{
PropertyDefinition prop;
if (_allowDefault) {
prop = target.GetDefinition().DefaultProperty;
if (prop == null)
return false;
} else {
var im = ImpliedName(node, target);
prop = target.SelectProperty(im);
if (prop == null || prop.IsIndexer)
return false;
}
DoPropertyBind(parent, target, node, prop);
return true;
}
private bool TryAggregation(PropertyTreeMetaObject value,
QualifiedName name,
PropertyDefinition property,
IServiceProvider serviceProvider)
{
object current;
if (!property.TryGetValue(component, null, name, out current))
{
return(false);
}
var enumerable = value.Component as IEnumerable;
if (current != null && enumerable != null)
{
var items = enumerable;
if (!ReferenceEquals(current, items) && enumerable.GetEnumerator().MoveNext())
{
MethodInfo mi = FindAddonMethod(current.GetType(), enumerable);
if (mi == null)
{
// Error because aggregation will be needed on read-only properties
if (property.IsReadOnly)
{
var errors = serviceProvider.GetServiceOrDefault(PropertyTreeBinderErrors.Default);
errors.NoAddMethodSupported(component.GetType(), PropertyTreeBinderImpl.FindFileLocation(serviceProvider));
}
return(false);
}
foreach (var item in items)
{
mi.Invoke(current, new object[] { item });
}
// Success because aggregation was applied
return(true);
}
}
return(false);
}
public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
Predicate <PropertyTreeNavigator> predicate = ImplicitDirective(target, "base");
var node = children.FindAndRemove(predicate).FirstOrDefault();
Uri baseUri;
IServiceProvider serviceProvider;
if (node == null)
{
baseUri = self.BaseUri;
serviceProvider = parent;
}
else
{
baseUri = Utility.NewUri(Convert.ToString(node.Value));
serviceProvider = parent.GetBasicServices(node);
}
return(target.BindBaseUri(baseUri, serviceProvider));
}
public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
Predicate <PropertyTreeNavigator> predicate = ImplicitDirective(target, "id");
var node = children.FindAndRemove(predicate).FirstOrDefault();
if (node == null)
{
node = children.FindAndRemove("name").FirstOrDefault();
}
if (node != null)
{
// TODO Handle when a name is duplicated or contains whitespace
var ns = parent.FindNameScope(target);
string id = Convert.ToString(node.Value);
if (string.IsNullOrEmpty(id))
{
parent._errors.IdCannotBeBlank(node.FileLocation);
}
else if (ns.FindName(id) == null)
{
ns.RegisterName(id, target.Component);
}
else
{
parent._errors.IdAlreadyRegistered(id, node.FileLocation);
}
var nameProperty = target.SelectProperty(NamespaceUri.Default + "name");
if (nameProperty != null)
{
parent.DoPropertyBind(target, node, nameProperty);
}
}
return(target);
}
public override PropertyTreeMetaObject Process(
PropertyTreeBinderImpl parent,
PropertyTreeMetaObject target,
PropertyTreeNavigator self,
NodeList children)
{
if (!(target is UntypedToTypedMetaObject))
{
return(target);
}
if (!children.Any())
{
return(target);
}
try {
// TODO Only supports one child (lame spec)
var rootType = target.Root.ComponentType;
var types = children.Select(t => ConvertToType(t, rootType)).ToArray();
target = target.BindGenericParameters(types);
} catch (PropertyTreeException) {
throw;
} catch (Exception ex) {
if (ex.IsCriticalException())
{
throw;
}
parent._errors.CouldNotBindGenericParameters(target.ComponentType, ex, self.FileLocation);
}
parent.Bind(target, children.First(), null);
children.Clear();
return(target);
}
bool IApplyMemberStep.Apply(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator node)
{
PropertyDefinition prop = null;
if (_allowDefault)
{
var defaultProperties = target.GetDefinition().DefaultProperties;
if (defaultProperties.Skip(1).Any())
{
prop = defaultProperties.FirstOrDefault(p => p.TryGetValue(target.Component, node.QualifiedName));
}
if (prop == null)
{
prop = defaultProperties.FirstOrDefault();
}
if (prop == null)
{
return(false);
}
}
else
{
var im = ImpliedName(node, target);
prop = target.SelectProperty(im);
if (prop == null || prop.IsIndexer)
{
return(false);
}
}
parent.DoPropertyBind(target, node, prop);
return(true);
}
public SerializerDirectiveFactory(PropertyTreeBinderImpl parent)
{
this.parent = parent;
}
public SerializerDirectiveFactory(PropertyTreeBinderImpl parent)
{
this.parent = parent;
}
public Dictionary <string, PropertyTreeMetaObject> ExtractParameterDictionary(
OperatorDefinition op,
PropertyTreeMetaObject target,
IServiceProvider serviceProvider,
NodeList children)
{
// Named constructor arguments
var duplicates = new HashSet <QualifiedName>();
var mapped = new Dictionary <QualifiedName, PropertyTreeNavigator>();
foreach (var child in children)
{
// Implicitly map default NS to real
var impliedName = ImpliedName(child, target);
if (duplicates.Contains(impliedName))
{
// Duplicates can't bind to parameters (only to param arrays)
}
else if (mapped.ContainsKey(impliedName))
{
// Detected a duplicate
duplicates.Add(impliedName);
mapped.Remove(impliedName);
}
else
{
mapped.Add(impliedName, child);
}
}
var args = new Dictionary <string, PropertyTreeMetaObject>(op.Parameters.Count);
PropertyDefinition myParam = null;
List <string> requiredMissing = new List <string>();
foreach (PropertyDefinition p in op.Parameters)
{
// Fallback to empty ns
PropertyTreeNavigator nav;
QualifiedName impliedName = p.QualifiedName;
if (p.QualifiedName.Namespace.IsDefault)
{
impliedName = impliedName.ChangeNamespace(op.Namespace);
}
if (mapped.TryGetValue(impliedName, out nav))
{
// Binds a parameter required for activating an instance
// TODO Should we supply/use attributes from the parameter
// and/or corresponding property descriptor?
var childContext = target.CreateChild(p.PropertyType);
args[p.Name] = Bind(childContext, nav, serviceProvider);
children.Remove(nav);
}
else if (p.IsOptional)
{
PropertyTreeMetaObject defaultValue;
if (p.DefaultValue == null)
{
defaultValue = PropertyTreeMetaObject.Create(p.PropertyType);
}
else
{
defaultValue = PropertyTreeMetaObject.Create(p.DefaultValue);
}
args[p.Name] = defaultValue;
}
else if (p.IsParamArray)
{
myParam = p;
}
else if (TypeHelper.IsParameterRequired(p.PropertyType))
{
requiredMissing.Add(Utility.DisplayName(p.QualifiedName));
}
}
if (requiredMissing.Count > 0)
{
_errors.RequiredPropertiesMissing(requiredMissing, op, FindFileLocation(serviceProvider));
}
if (myParam == null && !target.GetDefinition().DefaultProperties.Any() && duplicates.Any(t => target.SelectProperty(t) != null))
{
_errors.DuplicatePropertyName(duplicates, FindFileLocation(serviceProvider));
}
// Try param array
if (myParam != null)
{
var all = new List <object>();
var elementType = myParam.PropertyType.GetElementType();
foreach (var kvp in children)
{
// Bind child nodes so tha latebound applies
var childrenList = NodeList.Create(PropertyTreeBinderImpl.SelectChildren(kvp));
var inline = BindChildNodes(PropertyTreeMetaObject.Create(elementType), kvp, childrenList);
var inlineVal = inline.Component;
all.Add(inlineVal);
}
children.Clear();
var array = Array.CreateInstance(elementType, all.Count);
((System.Collections.ICollection)all).CopyTo(array, 0);
args[myParam.Name] = PropertyTreeMetaObject.Create(array);
}
return(args);
}
public abstract PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent,
PropertyTreeMetaObject target,
PropertyTreeNavigator self,
NodeList children);
public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
return(target.BindEndObject(parent));
}
// TODO Implement property ordering based on [DependsOn]
private bool Apply(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator node)
{
return(_items.Any(t => t.Apply(parent, target, node)));
}
private PropertyTreeMetaObject DoOperatorBind(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator navigator, OperatorDefinition op)
{
OperatorDefinition addon = op;
if (addon.DefaultParameter != null)
{
Type itemType = addon.OutputType;
// TODO Use service activation (we have the output type)
var item = target.CreateChild(itemType);
var model = parent.Bind(item, navigator, null);
var args = new Dictionary <string, PropertyTreeMetaObject>
{
{ addon.DefaultParameter.Name, model }
};
try {
target.BindAddChild(op, args);
} catch (PropertyTreeException) {
throw;
} catch (Exception ex) {
if (ex.IsCriticalException())
{
throw;
}
parent._errors.BadAddChild(target.ComponentType, ex, navigator.FileLocation);
}
}
else
{
// TODO The number and kinds of arguments are constrained. This should probably
// be enforced within schema operator reflection (spec)
Action <IReadOnlyDictionary <string, PropertyTreeMetaObject> > func;
var children = NodeList.Create(SelectChildren(navigator));
switch (addon.OperatorType)
{
case OperatorType.Add:
func = args => {
var child = target.BindAddChild(addon, args);
if (child.ShouldBindChildren)
{
parent.BindChildNodes(child, navigator, children);
}
};
break;
case OperatorType.Remove:
func = args => target.BindRemoveChild(addon, args);
break;
case OperatorType.Clear:
default:
func = args => target.BindClearChildren(addon, args);
break;
}
var services = parent.GetBasicServices(navigator);
var args2 = parent.ExtractParameterDictionary(op, target, services, children);
func(args2);
}
return(target);
}