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 TargetSourceDirective CreateTargetSource(PropertyTreeNavigator nav, IUriContext uriContext)
{
if (nav.IsProperty)
{
Exception error;
try {
Uri uri = Utility.NewUri(nav.Value.ToString());
uri = Utility.CombineUri(uriContext, uri);
return(new TargetSourceDirective(uri));
} catch (ArgumentException e) {
error = e;
} catch (UriFormatException e) {
error = e;
}
Errors.BadSourceDirective(error, nav.FileLocation);
return(null);
}
else
{
return(nav.Bind <TargetSourceDirective>());
}
}
public override PropertyTreeMetaObject StartStep(PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
foreach (var child in children.Rest()) {
string msg;
if (target.ComponentType.IsHiddenUX()) {
msg = SR.BinderMissingPropertyNoType(child.QualifiedName);
} else {
msg = SR.BinderMissingProperty(child.QualifiedName, target.ComponentType);
}
try {
var info = new InterfaceUsageInfo(InterfaceUsage.Missing, msg, null, true);
Parent.Callback.OnPropertyAnnotation(child.QualifiedName.ToString(), info);
} catch (Exception ex) {
if (ex.IsCriticalException())
throw;
throw PropertyTreesFailure.UnmatchedMembersGenericError(ex, child.FileLocation);
}
}
return target;
}
protected PropertyTreeNavigatorWrapper(PropertyTreeNavigator navigator)
{
if (navigator == null)
throw new ArgumentNullException("navigator");
this.navigator = navigator;
}
public TargetTypeDirective CreateTargetType(PropertyTreeNavigator nav)
{
if (nav.IsProperty)
{
Exception error;
try {
var tr = TypeReference.Parse(Convert.ToString(nav.Value), parent.GetBasicServices(nav));
return(new TargetTypeDirective(tr, null));
} catch (Exception ex) {
if (Failure.IsCriticalException(ex))
{
throw;
}
error = ex;
Errors.BadTargetTypeDirective(error, nav.FileLocation);
return(null);
}
}
else
{
try {
return(nav.Bind <TargetTypeDirective>());
} catch (Exception ex) {
if (Failure.IsCriticalException(ex))
{
throw;
}
Errors.BadTargetTypeDirective(ex, nav.FileLocation);
return(null);
}
}
}
public override PropertyTreeMetaObject StartStep(
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 (Exception ex) {
if (ex.IsCriticalException())
throw;
Parent.errors.CouldNotBindGenericParameters(target.ComponentType, ex, self.FileLocation);
}
Parent.Bind(target, children.First(), null);
children.Clear();
return target;
}
public TargetProviderDirective CreateTargetProvider(Type providerType, PropertyTreeNavigator nav)
{
var serviceProvider = parent.GetBasicServices(nav);
if (nav.IsProperty) {
string text = nav.Value.ToString();
Exception error;
try {
var qn = QualifiedName.Parse(text, serviceProvider);
return new TargetProviderDirective { Name = qn };
} catch (ArgumentException e) {
error = e;
} catch (FormatException e) {
error = e;
}
Errors.BadTargetProviderDirective(error, nav.FileLocation);
return null;
}
else {
try {
return nav.Bind<TargetProviderDirective>();
} catch (Exception ex) {
if (Require.IsCriticalException(ex))
throw;
Errors.BadTargetProviderDirective(ex, nav.FileLocation);
return null;
}
}
}
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 Type ConvertToType(PropertyTreeNavigator nav, Type rootType)
{
QualifiedName fixedName = nav.QualifiedName;
string name = fixedName.LocalName;
if (char.IsLower(name[0])) {
name = char.ToUpperInvariant(name[0]) + name.Substring(1);
fixedName = fixedName.ChangeLocalName(name);
}
if (string.IsNullOrEmpty(nav.Namespace)) {
// Try looking for the name in the same assembly
var choices = rootType.Assembly.GetTypesHelper()
.Where(t => t.IsPublic && t.Name == name);
if (choices.Any()) {
return choices.SingleOrThrow(() => PropertyTreesFailure.UnableToMatchTypeNameAmbiguous(nav.Name, choices));
} else {
throw PropertyTreesFailure.UnableToMatchTypeNameZero(name);
}
} else {
return AppDomain.CurrentDomain.GetTypeByQualifiedName(fixedName, true);
}
}
public override PropertyTreeMetaObject StartStep(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 = this.DirectiveFactory.CreateTargetSource(node, uriContext);
if (ss != null) {
try {
target = target.BindStreamingSource(ss, serviceProvider);
} catch (Exception ex) {
if (ex.IsCriticalException())
throw;
Parent.errors.FailedToLoadFromSource(ss.Uri, ex, node.FileLocation);
}
}
}
return target;
}
private Type ConvertToType(PropertyTreeNavigator nav, Type rootType)
{
QualifiedName fixedName = nav.QualifiedName;
string name = fixedName.LocalName;
if (char.IsLower(name[0]))
{
name = char.ToUpperInvariant(name[0]) + name.Substring(1);
fixedName = fixedName.ChangeLocalName(name);
}
if (string.IsNullOrEmpty(nav.Namespace))
{
// Try looking for the name in the same assembly
var choices = rootType.GetTypeInfo().Assembly.GetTypesHelper()
.Where(t => t.IsPublic && t.Name == name);
if (choices.Any())
{
return(choices.SingleOrThrow(() => PropertyTreesFailure.UnableToMatchTypeNameAmbiguous(nav.Name, choices)).AsType());
}
else
{
throw PropertyTreesFailure.UnableToMatchTypeNameZero(name);
}
}
else
{
return(App.GetTypeByQualifiedName(fixedName, true));
}
}
private void ApplyType(PropertyTreeMetaObject target,
PropertyTreeNavigator node)
{
if (node == null)
return;
Type type = target.ComponentType ?? typeof(object);
var serviceProvider = Parent.GetBasicServices(node);
target.BindTargetType(this.DirectiveFactory.CreateTargetType(node), serviceProvider);
}
internal PropertyTreeMetaObject BindChildNodes(PropertyTreeMetaObject target,
PropertyTreeNavigator self,
NodeList children)
{
foreach (var step in Pipeline)
{
target = step.Process(this, target, self, children);
}
return(target);
}
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;
}
private static IEnumerable <PropertyTreeNavigator> SelectChildren(PropertyTreeNavigator navigator)
{
navigator = navigator.Clone();
if (navigator.MoveToFirstChild())
{
do
{
yield return(navigator.Clone());
} while (navigator.MoveToNext());
}
}
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 StartStep(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 = ExtractParameterDictionary(op, target, Parent.GetBasicServices(self), children);
target = target.BindConstructor(ctor, args);
}
return target;
}
private void DoPropertyBind(PropertyTreeMetaObject target,
PropertyTreeNavigator navigator,
PropertyDefinition property)
{
object ancestor = null;
PropertyTreeMetaObject ancestorMeta = null;
if (property.IsExtender)
{
var ancestorType = property.DeclaringTreeDefinition.SourceClrType;
ancestorMeta = target.Ancestors.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), this))
{
LineNumber = navigator.LineNumber,
LinePosition = navigator.LinePosition,
};
try {
propertyTarget = Bind(propertyTarget, navigator, services);
target.BindSetMember(property, navigator.QualifiedName, propertyTarget, ancestorMeta, services);
} catch (NullReferenceException nre) {
// Normally a "critical" exception, consider it a conversion error
_errors.BinderConversionError(property.Name, target.ComponentType, nre, navigator.FileLocation);
} catch (ArgumentException a) {
_errors.BinderConversionError(property.Name, target.ComponentType, a, navigator.FileLocation);
} catch (PropertyTreeException) {
throw;
} catch (Exception ex) {
if (ex.IsCriticalException())
{
throw;
}
_errors.BinderConversionError(property.Name, target.ComponentType, ex, navigator.FileLocation);
}
}
public override PropertyTreeMetaObject Bind(PropertyTreeMetaObject target,
PropertyTreeNavigator navigator,
IServiceProvider serviceProvider)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (navigator == null)
{
throw new ArgumentNullException("navigator");
}
if (navigator.IsProperty)
{
var textValue = navigator.Value as string;
if (textValue != null)
{
return(BindInitializeValue(
target,
navigator,
serviceProvider,
() => target.BindInitializeValue(textValue, serviceProvider)));
}
var exprValue = navigator.Value as Expression;
if (exprValue != null)
{
var exprContext = ExpressionContext.Compose(
CurrentExpressionContext,
ExpressionContext.FromNameScope(FindNameScope(target))
);
exprValue = ExpressionUtility.LiftToCall(exprValue, exprContext);
return(BindInitializeValue(
target,
navigator,
serviceProvider,
() => target.BindInitializer(exprValue, exprContext, serviceProvider)));
}
throw new NotImplementedException();
}
var children = SelectChildren(navigator);
return(BindChildNodes(target, navigator, NodeList.Create(children)));
}
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 PropertyTreeMetaObject BindInitializeValue(PropertyTreeMetaObject target,
PropertyTreeNavigator navigator,
IServiceProvider serviceProvider,
Func <PropertyTreeMetaObject> thunk)
{
try {
return(thunk());
} catch (PropertyTreeException) {
throw;
} catch (Exception ex) {
var sp = ServiceProvider.Compose(ServiceProvider.FromValue(navigator), serviceProvider, this);
// Throw critical exceptions if they originate within PT; otherwise, allow
// callback to decide how to handle them.
if (ex.IsCriticalException())
{
throw;
}
var descriptor = serviceProvider.GetServiceOrDefault <IValueSerializerContext>();
string property = navigator.QualifiedName.ToString();
Type componentType;
if (descriptor == null || descriptor.Instance == null)
{
componentType = target.ComponentType;
}
else if (descriptor.Property == null)
{
componentType = descriptor.Instance.GetType();
}
else
{
property = descriptor.Property.Name;
componentType = descriptor.Property.DeclaringType;
}
FileLocation loc = navigator.FileLocation;
object value = navigator.Value;
_errors.BinderConversionError(property, componentType, ex, loc);
}
return(target);
}
private static QualifiedName ImpliedName(PropertyTreeNavigator nav, PropertyTreeMetaObject target)
{
QualifiedName qualifiedName = nav.QualifiedName;
if (nav.IsExpressNamespace)
{
return(qualifiedName);
}
NamespaceUri impliedNS = Utility.GetXmlnsNamespaceSafe(target.ComponentType);
if (impliedNS == null)
{
return(qualifiedName);
}
else
{
return(qualifiedName.ChangeNamespace(impliedNS));
}
}
public override PropertyTreeMetaObject StartStep(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.IsSealed) {
// TODO This predicate is probably too loose
Predicate<PropertyTreeNavigator> predicate = t => t.Name == "type";
var node = children.FindAndRemove(predicate).FirstOrDefault();
ApplyType(target, node);
}
return target;
}
public override PropertyTreeMetaObject StartStep(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 = DirectiveFactory.CreateTargetProvider(type, node);
if (pro != null) {
target = target.BindTargetProvider(pro, serviceProvider);
return target;
}
}
}
return target;
}
public TargetProviderDirective CreateTargetProvider(Type providerType, PropertyTreeNavigator nav)
{
var serviceProvider = parent.GetBasicServices(nav);
if (nav.IsProperty)
{
string text = nav.Value.ToString();
Exception error;
try {
var qn = QualifiedName.Parse(text, serviceProvider);
return(new TargetProviderDirective {
Name = qn
});
} catch (ArgumentException e) {
error = e;
} catch (FormatException e) {
error = e;
}
Errors.BadTargetProviderDirective(error, nav.FileLocation);
return(null);
}
else
{
try {
return(nav.Bind <TargetProviderDirective>());
} catch (Exception ex) {
if (Failure.IsCriticalException(ex))
{
throw;
}
Errors.BadTargetProviderDirective(ex, nav.FileLocation);
return(null);
}
}
}
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);
}
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);
}
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);
}
// 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)));
}
public TargetSourceDirective CreateTargetSource(PropertyTreeNavigator nav, IUriContext uriContext)
{
if (nav.IsProperty) {
Exception error;
try {
Uri uri = new Uri(nav.Value.ToString(), UriKind.RelativeOrAbsolute);
uri = Utility.CombineUri(uriContext, uri);
return new TargetSourceDirective(uri);
} catch (ArgumentException e) {
error = e;
} catch (UriFormatException e) {
error = e;
}
Errors.BadSourceDirective(error, nav.FileLocation);
return null;
}
else {
return nav.Bind<TargetSourceDirective>();
}
}
public TargetTypeDirective CreateTargetType(PropertyTreeNavigator nav)
{
if (nav.IsProperty) {
Exception error;
try {
var tr = TypeReference.Parse(Convert.ToString(nav.Value), parent.GetBasicServices(nav));
return new TargetTypeDirective(tr, null);
} catch (Exception ex) {
if (Require.IsCriticalException(ex))
throw;
error = ex;
Errors.BadTargetTypeDirective(error, nav.FileLocation);
return null;
}
}
else {
try {
return nav.Bind<TargetTypeDirective>();
} catch (Exception ex) {
if (Require.IsCriticalException(ex))
throw;
Errors.BadTargetTypeDirective(ex, nav.FileLocation);
return null;
}
}
}
public PropertyTreeNavigatorReader(PropertyTreeNavigator nav)
{
this.nav = nav;
}
internal PropertyTreeMetaObject BindChildNodes(PropertyTreeMetaObject target,
PropertyTreeNavigator self,
NodeList children)
{
foreach (var step in Pipeline) {
target = step.Process(target, self, children);
}
return target;
}
public PropertyTreeMetaObject Process(
PropertyTreeMetaObject target,
PropertyTreeNavigator self,
NodeList children)
{
target = StartStep(target, self, children);
return EndStep(target);
}
public virtual PropertyTreeMetaObject StartStep(PropertyTreeMetaObject target,
PropertyTreeNavigator self,
NodeList children)
{
return target;
}
internal IServiceProvider GetBasicServices(PropertyTreeNavigator nav)
{
return(ServiceProvider.Compose(this,
ServiceProvider.FromValue(nav)));
}
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);
}
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 abstract PropertyTreeMetaObject Bind(PropertyTreeMetaObject target, PropertyTreeNavigator navigator, IServiceProvider serviceProvider);
public override PropertyTreeMetaObject StartStep(PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
children.FindAndRemove(t => Apply(target, t)).All();
return target;
}
// TODO Implement property ordering based on [DependsOn]
private bool Apply(PropertyTreeMetaObject target, PropertyTreeNavigator node)
{
return _items.Any(t => t.Apply(Parent, target, node));
}
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));
}
public override PropertyTreeMetaObject Bind(PropertyTreeMetaObject target,
PropertyTreeNavigator navigator,
IServiceProvider serviceProvider)
{
if (target == null)
throw new ArgumentNullException("target");
if (navigator == null)
throw new ArgumentNullException("navigator");
if (navigator.IsProperty) {
string value = Convert.ToString(navigator.Value);
var sp = ServiceProvider.Compose(ServiceProvider.FromValue(navigator), serviceProvider, this);
var xml = (IXmlNamespaceResolver) sp.GetService(typeof(IXmlNamespaceResolver));
try {
return target.BindInitializeValue(value, sp);
} catch (Exception ex) {
// Throw critical exceptions if they originate within PT; otherwise, allow
// callback to decide how to handle them.
if (ex.IsCriticalException())
throw;
var descriptor = serviceProvider.GetService<ITypeDescriptorContext>();
string property;
Type componentType;
if (descriptor == null || descriptor.PropertyDescriptor == null) {
property = navigator.QualifiedName.ToString();
componentType = descriptor.Instance.GetType();
} else {
property = descriptor.PropertyDescriptor.Name;
componentType = descriptor.PropertyDescriptor.ComponentType;
}
FileLocation loc = navigator.FileLocation;
try {
Callback.OnConversionException(property, value, ex);
} catch (Exception ex2) {
if (Require.IsCriticalException(ex2))
throw;
throw PropertyTreesFailure.BinderConversionError(value, property, componentType, ex2, loc);
}
}
}
var children = SelectChildren(navigator);
return BindChildNodes(target, navigator, NodeList.Create(children));
}
public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
return(target.BindEndObject(parent));
}
private static IEnumerable<PropertyTreeNavigator> SelectChildren(PropertyTreeNavigator navigator)
{
navigator = navigator.Clone();
if (navigator.MoveToFirstChild()) {
do {
yield return navigator.Clone();
} while (navigator.MoveToNext());
}
}
public abstract PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent,
PropertyTreeMetaObject target,
PropertyTreeNavigator self,
NodeList children);
private static QualifiedName ImpliedName(PropertyTreeNavigator nav, PropertyTreeMetaObject target)
{
QualifiedName qualifiedName = nav.QualifiedName;
if (nav.IsExpressNamespace)
return qualifiedName;
NamespaceUri impliedNS = Utility.GetXmlnsNamespaceSafe(target.ComponentType);
if (impliedNS == null)
return qualifiedName;
else
return qualifiedName.ChangeNamespace(impliedNS);
}
public override bool MoveTo(PropertyTreeNavigator other)
{
if (other == null)
throw new ArgumentNullException("other");
DocumentPTNavigator otherNav = other as DocumentPTNavigator;
if (otherNav != null && this.current.Root == otherNav.current.Root) {
this.current = otherNav.current;
return true;
}
return false;
}
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 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);
}
public abstract PropertyTreeMetaObject Bind(PropertyTreeMetaObject target, PropertyTreeNavigator navigator, IServiceProvider serviceProvider);
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 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));
}
internal IServiceProvider GetBasicServices(PropertyTreeNavigator nav)
{
return ServiceProvider.Compose(this,
ServiceProvider.FromValue(nav));
}
public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
foreach (var child in children.Rest())
{
parent._errors.BindUnmatchedProperty(child.QualifiedName, target.ComponentType, child.FileLocation);
}
return(target);
}
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));
}
