public override PropertyTreeMetaObject BindInitializeValue(string text, IServiceProvider serviceProvider)
{
object value;
TryConvertFromText(text, serviceProvider, out value);
return(PropertyTreeMetaObject.Create(value));
}
public override PropertyTreeMetaObject BindInitializer(Expression expression, IExpressionContext context, IServiceProvider serviceProvider)
{
// No need to evaluate if the parent can accept expressions
// TODO There will be other conditions for allowing expressions
if (CanAllowExpressionInitializer(Parent))
{
return(PropertyTreeMetaObject.Create(expression));
}
var result = expression.Evaluate(context ?? ExpressionContext.Empty);
if (result == Undefined.Value)
{
return(PropertyTreeMetaObject.Null);
}
var items = result as object[];
if (items != null)
{
if (items.Length == 0 || items.All(t => t == Undefined.Value))
{
return(PropertyTreeMetaObject.Null);
}
result = string.Concat(items);
}
return(BindInitializeValue(result.ToString(), serviceProvider));
}
public override PropertyTreeMetaObject BindStreamingSource(StreamContext input, IServiceProvider serviceProvider)
{
var ss = StreamingSource.Create(this.ComponentType);
var comp = ss.Load(input, this.ComponentType);
return(PropertyTreeMetaObject.Create(comp));
}
public override PropertyTreeMetaObject BindInitializer(Expression expression, IExpressionContext context, IServiceProvider serviceProvider)
{
if (Parent.IsExpressionBag)
{
return(PropertyTreeMetaObject.Create(expression));
}
object value = expression.Evaluate(context ?? ExpressionContext.Empty);
return(PropertyTreeMetaObject.Create(value));
}
public override PropertyTreeMetaObject BindInitializeValue(string text, IServiceProvider serviceProvider)
{
object value = text;
if (ComponentType != typeof(string) && ComponentType != typeof(object))
{
TryConvertFromText(text, serviceProvider, out value);
}
return(PropertyTreeMetaObject.Create(value, this.ComponentType));
}
public override PropertyTreeMetaObject BindInitializeValue(string text, IServiceProvider serviceProvider)
{
object value;
if (TryConvertFromText(text, serviceProvider, out value))
{
return(PropertyTreeMetaObject.Create(value));
}
else
{
throw new NotImplementedException();
}
}
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 override PropertyTreeMetaObject BindEndObject(IServiceProvider serviceProvider)
{
return(PropertyTreeMetaObject.Create(inner.Component.InvokeBuilder(serviceProvider)));
}
public override PropertyTreeMetaObject BindInitializeValue(string text, IServiceProvider serviceProvider)
{
var type = TypeReference.Parse(text, serviceProvider).Resolve();
return(PropertyTreeMetaObject.Create((object)type));
}
