public IBindingBuilder Register(IBindingBuilder builder)
{
foreach (var type in _asTypes)
{
builder.Services.Add(type);
}
return builder;
}
private static void Convert(IBindingBuilder builder, LambdaExpression expression)
{
Action <IBindingBuilder>[] callbacks = ConvertInternal(expression, builder, true);
for (int i = 0; i < callbacks.Length; i++)
{
callbacks[i].Invoke(builder);
}
}
static public void Do <TModel, TView, TModelValue>(
this IBindingBuilder <TModel, TView, TModelValue> builder,
Action <TModelValue, TModel, TView> action)
{
Func <TModel, TView, TModelValue> getter = builder.Getter;
builder.Do((m, v) => action(getter(m, v), m, v));
}
/// <inheritdoc/>
public void Resolve(Type service, IBindingBuilder builder)
{
var serviceInstanceType = GetServiceInstanceType(service);
if (serviceInstanceType != null)
{
builder.To(serviceInstanceType);
}
}
public static IBindingToSyntax Bind([NotNull] this IBindingBuilder builder, [NotNull] object target,
[NotNull] string targetPath)
{
Should.NotBeNull(builder, "builder");
Should.NotBeNull(target, "target");
Should.NotBeNullOrWhitespace(targetPath, "targetPath");
builder.Add(BindingBuilderConstants.Target, target);
builder.Add(BindingBuilderConstants.TargetPath, BindingPath.Create(targetPath));
return(builder.GetOrAddSyntaxBuilder());
}
static public IBindingBuilder <TModel, TView, TLoadedValue, TBindingCollection> Load <TModel, TView, TLoadedValue, TBindingCollection>(
this IBindingBuilder <TModel, TView, FilePath, TBindingCollection> builder,
Func <ILoadFormat <TLoadedValue> > loadFormatProvider)
{
return(builder.Select((mv, m, v) => SafeLoad(mv, stream =>
{
ILoadFormat <TLoadedValue> serializationFormat = loadFormatProvider();
return serializationFormat.Load(stream);
})));
}
public static IBindingToSyntax <TTarget, TSource> Bind <TTarget, TSource>([NotNull] this IBindingBuilder builder,
[NotNull] TTarget targetGeneric, [NotNull] string targetPath) where TTarget : class
{
Should.NotBeNull(builder, "builder");
Should.NotBeNull(targetGeneric, "targetGeneric");
Should.NotBeNullOrWhitespace(targetPath, "targetPath");
builder.Add(BindingBuilderConstants.Target, targetGeneric);
builder.Add(BindingBuilderConstants.TargetPath, BindingServiceProvider.BindingPathFactory(targetPath));
return(new SyntaxBuilder <TTarget, TSource>(builder));
}
private static SyntaxBuilder <object, object> GetOrAddSyntaxBuilder(this IBindingBuilder builder)
{
SyntaxBuilder <object, object> syntaxBuilder;
if (!builder.TryGetData(SyntaxBuilderConstant, out syntaxBuilder))
{
syntaxBuilder = new SyntaxBuilder <object, object>(builder);
builder.Add(SyntaxBuilderConstant, syntaxBuilder);
}
return(syntaxBuilder);
}
static public IBindingBuilder <TModel, TView, TLoadedValue, TBindingCollection> Load <TModel, TView, TLoadedValue, TBindingCollection>(
this IBindingBuilder <TModel, TView, FilePath, TBindingCollection> builder,
Func <ISerializationFormat <TLoadedValue> > serializationFormatProvider)
where TModel : IGlyphData
{
return(builder.Select((mv, m, v) => SafeLoad(mv, stream =>
{
ISerializationFormat <TLoadedValue> serializationFormat = serializationFormatProvider();
serializationFormat.KnownTypes = m.SerializationKnownTypes;
return serializationFormat.Load(stream);
})));
}
private static int OrderByTargetPath(IBindingBuilder bindingBuilder)
{
var path = bindingBuilder.GetData(BindingBuilderConstants.TargetPath);
if (path == null)
{
return(0);
}
int value;
BindingServiceProvider.BindingMemberPriorities.TryGetValue(path.Path, out value);
return(value);
}
static public void To <TModel, TView, TModelValue>(
this IBindingBuilder <TModel, TView, TModelValue> binding,
Expression <Func <TView, TModelValue> > viewGetterExpression,
IInjectionExpression injectionExpression = null)
{
var memberExpression = (MemberExpression)viewGetterExpression.Body;
var propertyInfo = (PropertyInfo)memberExpression.Member;
Delegate targetSelector = Expression.Lambda(memberExpression.Expression, viewGetterExpression.Parameters).Compile();
InjectableProperty <TView, TModelValue> injectable = propertyInfo.AsInjectable <TView, TModelValue>(targetSelector, injectionExpression);
Func <TModel, TView, TModelValue> getter = binding.Getter;
binding.Do((m, v) => injectable.Inject(v, getter(m, v)));
}
private static TResult GetOrAddSyntaxBuilder<TResult, T1, T2>(this IBuilderSyntax bindingSyntax)
where T1 : class
where TResult : IBindingInfoSyntax<T2>
{
if (bindingSyntax is TResult)
return (TResult)bindingSyntax;
IBindingBuilder builder = bindingSyntax.Builder;
object syntaxBuilder;
if (!builder.TryGetData(SyntaxBuilderConstant, out syntaxBuilder) || !(syntaxBuilder is TResult))
{
syntaxBuilder = new SyntaxBuilder<T1, T2>(builder);
builder.AddOrUpdate(SyntaxBuilderConstant, syntaxBuilder);
}
return (TResult)syntaxBuilder;
}
protected virtual void BuildParameterFromLambdaExpressionInternal <TValue>(IBindingBuilder builder, Func <LambdaExpression> expression, DataConstant <Func <IDataContext, TValue> > parameterConstant)
{
Func <IDataContext, TValue> value;
var func = LambdaExpressionToBindingExpressionConverter.ConvertParameter(builder, expression);
if (typeof(TValue) == typeof(object))
{
value = (Func <IDataContext, TValue>)(object) func;
}
else
{
value = func.CastFunc <TValue>;
}
builder.Add(parameterConstant, value);
}
internal IBinding GetOrBuildBinding(IBindingBuilder bindingBuilder)
{
if (_currentlyBuilding.Contains(bindingBuilder))
{
throw new BindingRecursionException();
}
if (!_bindings.TryGetValue(bindingBuilder, out var binding))
{
_currentlyBuilding.Add(bindingBuilder);
_bindings[bindingBuilder] = binding = bindingBuilder.Build();
}
return(binding);
}
public IContainer WithBindingBuilder(IBindingBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (!_buildersByType.TryGetValue(builder.ServiceType, out var bindingsList))
{
_buildersByType[builder.ServiceType] = bindingsList = new HashSet <IBindingBuilder>();
}
bindingsList.Add(builder);
return(this);
}
public ViewInflater(IVisualBootstrapper visualBootstrapper,
IStringPrimitiveScanner xmlAttributeParser,
ITypeInferrer typeInferrer,
IBindingBuilder bindingBuilder,
IValueConverterProvider converterProvider,
IVisualTypeResolver visualTypeResolver,
IPropertyProvider typeManipulator,
IAppliedStyleBuilder appliedStyleBuilder)
{
_visualBootstrapper = visualBootstrapper;
_typeInferrer = typeInferrer;
_bindingBuilder = bindingBuilder;
_converterProvider = converterProvider;
_visualTypeResolver = visualTypeResolver;
_typeManipulator = typeManipulator;
_appliedStyleBuilder = appliedStyleBuilder;
_attributeValueScanner = xmlAttributeParser;
}
public IContainer Bind(Type serviceType, object value, Action <IBindingBuilder> composeAction = null)
{
TypeInfo serviceTypeInfo = serviceType.GetTypeInfo();
if (serviceTypeInfo.IsGenericTypeDefinition)
{
IGenericBindingBuilder genericBuilder = new GenericConstantBindingBuilder(this, serviceType, value);
composeAction?.Invoke(genericBuilder);
return(WithGenericBindingBuilder(genericBuilder));
}
else
{
IBindingBuilder builder = (IBindingBuilder)__createConstantBindingBuilderMethod
.MakeGenericMethod(serviceType)
.Invoke(this, new object[] { value });
composeAction?.Invoke(builder);
return(WithBindingBuilder(builder));
}
}
private bool TryResolveParameter(ParameterInfo parameterInfo, out Expression argumentExpression)
{
if (!Container.TryGetBindingBuilders(parameterInfo.ParameterType, out var bindingBuilders))
{
argumentExpression = null;
return(false);
}
int selectedScore = 0;
IBindingBuilder selected = null;
foreach (IBindingBuilder bindingBuilder in bindingBuilders)
{
int score = bindingBuilder.GetScore(parameterInfo);
if (score > selectedScore)
{
selectedScore = score;
selected = bindingBuilder;
}
}
if (selected == null)
{
argumentExpression = null;
return(false);
}
IBinding binding = Container.GetOrBuildBinding(selected);
argumentExpression = binding.Expression;
return(true);
}
public IContainer Bind(Type serviceType, Type implementationType, Action <IBindingBuilder> composeAction = null)
{
TypeInfo serviceTypeInfo = serviceType.GetTypeInfo();
TypeInfo implementationTypeInfo = implementationType.GetTypeInfo();
if (serviceTypeInfo.IsGenericTypeDefinition)
{
IGenericBindingBuilder genericBuilder = new GenericTypeBindingBuilder(this, serviceType, implementationType);
composeAction?.Invoke(genericBuilder);
return(WithGenericBindingBuilder(genericBuilder));
}
else
{
IBindingBuilder builder = (IBindingBuilder)__createTypeBindingBuilderMethod
.MakeGenericMethod(serviceType, implementationType)
.Invoke(this, Array.Empty <object>());
composeAction?.Invoke(builder);
return(WithBindingBuilder(builder));
}
}
public static IBindingToSyntax <TTarget, TSource> Bind <TTarget, TSource>([NotNull] this IBindingBuilder builder, [NotNull] TTarget targetGeneric) where TTarget : class
{
return(builder.Bind <TTarget, TSource>(targetGeneric, targetGeneric.GetBindingMemberValue(DefautBindingMemberDescriptor)));
}
public static IBindingToSyntax <TTarget> Bind <TTarget>([NotNull] this IBindingBuilder builder,
[NotNull] TTarget target, [NotNull] Func <Expression <Func <TTarget, object> > > targetPath)
where TTarget : class
{
return(builder.Bind <TTarget, object>(target, targetPath));
}
public static IBindingToSyntax <TTarget, TSource> Bind <TTarget, TSource>([NotNull] this IBindingBuilder builder,
[NotNull] TTarget target,
[NotNull] Func <Expression <Func <TTarget, object> > > targetPath) where TTarget : class
{
return(builder.Bind <TTarget, TSource>(target, BindingExtensions.GetMemberPath(targetPath)));
}
public IList<IBindingBuilder> CreateBuildersFromString(object target, string bindingExpression, IList<object> sources = null)
{
Should.NotBeNull(target, "target");
Should.NotBeNullOrWhitespace(bindingExpression, "bindingExpression");
try
{
var parserResult = Parser.Parse(bindingExpression, DataContext.Empty, target, sources);
var result = new IBindingBuilder[parserResult.Count];
for (int index = 0; index < parserResult.Count; index++)
{
var builder = new BindingBuilder(parserResult[index]);
builder.Add(BindingBuilderConstants.BuildDelegate, _buildDelegate);
result[index] = builder;
}
return result;
}
catch (Exception exception)
{
exception = new InvalidOperationException(exception.Message, exception);
var builder = new BindingBuilder();
builder.Add(BindingBuilderConstants.Target, target);
builder.Add(ProviderConstant, this);
builder.Add(ExceptionConstant, exception);
builder.Add(BindingBuilderConstants.BuildDelegate, CreateInvalidaDataBindingDelegate);
return new IBindingBuilder[] { builder };
}
}
public static IBindingToSyntax <TTarget, TSource> Bind <TTarget, TSource>([NotNull] this IBindingBuilder builder,
[NotNull] TTarget targetGeneric, [NotNull] string targetPath) where TTarget : class
{
Bind(builder, targetGeneric, targetPath);
return(new SyntaxBuilder <TTarget, TSource>(builder));
}
public SyntaxBuilder(IBindingBuilder builder)
{
Should.NotBeNull(builder, "builder");
_builder = builder;
}
protected virtual void BuildFromLambdaExpressionInternal(IBindingBuilder builder, Func <LambdaExpression> expression)
{
LambdaExpressionToBindingExpressionConverter.Convert(builder, expression);
}
static public void SetToBindedObject <TModel, TView, TComponent, TBindingCollection>(this IBindingBuilder <TModel, TView, TComponent, TBindingCollection> builder)
where TView : GlyphObject
where TComponent : IGlyphComponent
{
builder.SetToObject(v => v);
}
private static Action <IBindingBuilder>[] ConvertInternal(LambdaExpression expression, IBindingBuilder builder, bool ignoreCallback)
{
Expression lastExpression;
string path;
if (BindingExtensions.TryGetMemberPath(expression.Body, ".", false, out lastExpression, out path) &&
expression.Parameters[0] == lastExpression)
{
if (ignoreCallback)
{
builder.GetOrAddBindingSources().Add(context => BindingExtensions.CreateBindingSource(context, path, null));
return(Empty.Array <Action <IBindingBuilder> >());
}
return(new Action <IBindingBuilder>[] { b => b.GetOrAddBindingSources().Add(context => BindingExtensions.CreateBindingSource(context, path, null)) });
}
var visitor = new LambdaExpressionToBindingExpressionConverter(expression);
visitor.ConvertInternal(expression);
var actions = visitor._callbacks.ToArray();
visitor._members = null;
visitor._sourceExpression = null;
visitor._currentExpression = null;
visitor._methodExpression = null;
visitor._callbacks = null;
return(actions);
}
public static IBindingToSyntax <TTarget> Bind <TTarget>([NotNull] this IBindingBuilder builder,
[NotNull] TTarget targetGeneric, [NotNull] string targetPath) where TTarget : class
{
return(builder.Bind <TTarget, object>(targetGeneric, targetPath));
}
private IBindingBuilder AddBuilder(IBindingBuilder builder)
{
lock (_builders)
_builders.Add(builder);
return(builder);
}
protected virtual IBindingBuilder CreateBindingBuilder(object targetObject, string targetPath)
{
IBindingBuilder builder = BindingServiceProvider
.BindingProvider
.CreateBuildersFromString(targetObject, ToBindingExpression(targetPath))[0];
var syntaxBuilder = new SyntaxBuilder <object, object>(builder);
SetMode(syntaxBuilder);
SetUpdateSourceTrigger(syntaxBuilder);
if (HasConverter)
{
syntaxBuilder.WithConverter(d => _converter);
}
if (HasConverterCulture)
{
syntaxBuilder.WithConverterCulture(d => ConverterCulture);
}
if (HasConverterParameter)
{
syntaxBuilder.WithConverterParameter(d => ConverterParameter);
}
if (HasFallback)
{
syntaxBuilder.WithFallback(d => Fallback);
}
if (HasCommandParameter)
{
syntaxBuilder.WithCommandParameter(d => CommandParameter);
}
if (ToggleEnabledState.HasValue)
{
syntaxBuilder.ToggleEnabledState(ToggleEnabledState.Value);
}
if (ValidatesOnExceptions)
{
syntaxBuilder.ValidatesOnExceptions();
}
if (ValidatesOnNotifyDataErrors)
{
syntaxBuilder.ValidatesOnNotifyDataErrors();
}
if (TargetNullValue != null)
{
syntaxBuilder.WithTargetNullValue(TargetNullValue);
}
if (Delay != 0)
{
syntaxBuilder.WithDelay(_delay, false);
}
if (TargetDelay != 0)
{
syntaxBuilder.WithDelay(_targetDelay, true);
}
if (HasDefaultValueOnException)
{
syntaxBuilder.DefaultValueOnException(DefaultValueOnException);
}
return(builder);
}
public void BuildFromLambdaExpression(IBindingBuilder builder, Func <LambdaExpression> expression)
{
Should.NotBeNull(builder, nameof(builder));
Should.NotBeNull(expression, nameof(expression));
BuildFromLambdaExpressionInternal(builder, expression);
}
