public override PropertyTreeMetaObject BindAddChild(OperatorDefinition definition, IReadOnlyDictionary<string, PropertyTreeMetaObject> arguments) { var result = definition.Apply(null, component, arguments); if (result == null) return Null; return CreateChild(result); }
void FindActivationConstructor() { var tt = type.GetTypeInfo(); if (tt.IsAbstract) { // Composable providers can be abstract if (type.IsProviderType() && tt.IsDefined(typeof(ComposableAttribute), false)) { var composeMember = App.GetProviderMember(type, "compose"); if (composeMember == null) { throw new NotImplementedException(); } activationConstructor = ReflectedProviderFactoryDefinitionBase.Create(type, composeMember); } } else { MethodBase ctor = TypeHelper.FindActivationConstructor(type); if (ctor != null) { activationConstructor = ReflectedPropertyTreeFactoryDefinition.Create(null, ctor); } } }
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; }
public override PropertyTreeMetaObject BindConstructor(OperatorDefinition definition, IReadOnlyDictionary<string, PropertyTreeMetaObject> arguments) { var op = definition; object component = null; object parent = null; var value = op.Apply(component, parent, arguments); if (this.Parent == null) return Create(value); else return this.Parent.CreateChild(value); }
internal void AddRange(OperatorDefinition owner, string ns, ParameterInfo[] parameters, bool extension) { foreach (var parm in parameters) { if (extension && parm.Position == 0) { continue; } this.AddInternal(new ReflectedParameterDefinition(ns, parm)); } this.FirstParameter = this.FirstOrDefault(); }
public CommonReflectionInfo(OperatorDefinition def, RoleAttribute attr, MethodBase method) { this.method = method; this.def = def; this.name = attr.ComputeName(method); var type = method.DeclaringType; if (type.IsGenericType && !type.IsGenericTypeDefinition) type = type.GetGenericTypeDefinition(); this.ns = TypeHelper.GetNamespaceName(type); parameters = new PropertyDefinitionCollection(); parameters.AddRange(def, ns, method.GetParameters(), method.IsExtension()); }
public CommonReflectionInfo(OperatorDefinition def, IRoleAttribute attr, MethodBase method) { this.method = method; this.name = attr.ComputeName(method); var type = method.DeclaringType; if (type.GetTypeInfo().IsGenericType&& !type.GetTypeInfo().IsGenericTypeDefinition) { type = type.GetGenericTypeDefinition(); } this.ns = TypeHelper.GetNamespaceName(type); parameters = new PropertyDefinitionCollection(); parameters.AddRange(def, ns, method.GetParameters(), method.IsExtension()); }
public override OperatorDefinition GetOperator(QualifiedName name, bool declaredOnly = false) { if (name == null) { throw new ArgumentNullException("name"); } OperatorDefinition result = this.Operators[name]; if (result != null) { return(result); } if (declaredOnly) { return(null); } return(EnumerateOperators().FirstOrDefault(t => Utility.OrdinalIgnoreCaseQualifiedName.Equals(t.QualifiedName, name))); }
public virtual void BindRemoveChild(OperatorDefinition definition, IReadOnlyDictionary<string, PropertyTreeMetaObject> arguments) { }
public virtual PropertyTreeMetaObject BindConstructor(OperatorDefinition definition, IReadOnlyDictionary<string, PropertyTreeMetaObject> arguments) { return this; }
public virtual PropertyTreeMetaObject BindAddChild(OperatorDefinition definition, IReadOnlyDictionary<string, PropertyTreeMetaObject> arguments) { return null; }
internal Dictionary<string, PropertyTreeMetaObject> ExtractParameterDictionary( OperatorDefinition op, PropertyTreeMetaObject target, IServiceProvider serviceProvider, NodeList children) { return Parent.ExtractParameterDictionary(op, target, serviceProvider, children); }
public void RequiredPropertiesMissing(IEnumerable<string> requiredMissing, OperatorDefinition op, FileLocation loc) { throw PropertyTreesFailure.RequiredPropertiesMissing(requiredMissing, op.ToString(), loc.LineNumber, loc.LinePosition); }
public override PropertyTreeMetaObject BindConstructor(OperatorDefinition definition, IReadOnlyDictionary<string, PropertyTreeMetaObject> arguments) { if (definition.Parameters.Count != 0) { // TODO This is an error because we can't do construction inside template throw new NotImplementedException(); } return this; }
public override PropertyTreeMetaObject BindAddChild(OperatorDefinition definition, IReadOnlyDictionary<string, PropertyTreeMetaObject> arguments) { AppendCommand(new AddChildCommand(definition, arguments)); return FromInstanceType(definition.ReturnType); }
public override PropertyTreeMetaObject BindConstructor(OperatorDefinition definition, IReadOnlyDictionary<string, PropertyTreeMetaObject> arguments) { return new BuilderMetaObject(inner.BindConstructor(definition, arguments)); }
public override void BindRemoveChild(OperatorDefinition definition, IReadOnlyDictionary<string, PropertyTreeMetaObject> arguments) { definition.Apply(null, component, arguments); }
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().DefaultProperty == null && 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 AddChildCommand(OperatorDefinition definition, IReadOnlyDictionary<string, PropertyTreeMetaObject> arguments) { this.definition = definition; this.arguments = arguments.ToDictionary(t => t.Key, t => t.Value.Component); }
internal PropertyTreeMetaObject SetProviderMember(MemberInfo member) { if (member == null) return this; if (member.MemberType == MemberTypes.TypeInfo) { this.componentType = (Type) member; return this; } else if (member.MemberType == MemberTypes.Method) { this.factoryDefinition = ReflectedProviderFactoryDefinitionBase.Create(this.componentType, member); this.componentType = ((MethodInfo) member).ReturnType; return this; } else { var component = ((FieldInfo) member).GetValue(null); return this.Parent.CreateChild(component); } }