/// <inheritdoc /> public override bool Matches(IBindingMetadata metadata) { _ = metadata ?? throw new ArgumentNullException(nameof(metadata)); return(metadata.Has(nameof(ContentSource)) && metadata.Get <ContentSource>(nameof(ContentSource)) == this.Source); }
private static Node AddDynamicNode(NodeTree tree, MetadataIdentity identity, IBindingMetadata metadata) { AddStaticNode(tree, metadata); Node thisNode = tree.FindNode(identity); MetadataIdentity parentIdentity = identity.Pop(); if (thisNode != null) { return(thisNode); } else if (parentIdentity != null) { Node parentNode = tree.FindNode(parentIdentity) ?? AddDynamicNode(tree, parentIdentity, metadata); if (parentNode != null) { thisNode = new Node(identity, metadata) { IsDynamic = true, }; parentNode.Properties.Add(thisNode); tree.Nodes.Add(thisNode); } } return(thisNode); }
public AggregateNode Build() { IBindingMetadata metadata = this.Schema.GetMetadata <IBindingMetadata>(); AggregateNode aggrNode = new AggregateNode() { Metadata = metadata, Index = this.State.Indexer.GetListIndex(metadata.Item.Identity), }; if (this.State.Aggregate.Targets.Count > 0) { aggrNode.Item = new MetadataNode(metadata.Item); } foreach (MetadataIdentity identity in this.State.Aggregate.Targets) { IBindingMetadata targetMetadata = identity.GetMetadata <IBindingMetadata>(); IBindingMetadata valueMetadata = targetMetadata.HasFlag(BindingMetadataFlags.Item) ? targetMetadata.Parent : targetMetadata; MetadataNode valueNode = new MetadataNode(valueMetadata) { ListIndex = this.State.Indexer.GetListIndex(identity), }; this.AddListNode(aggrNode, valueNode); } return(aggrNode); }
public void Build(IDbDataParameter adoParameter) { IBindingMetadata metadata = this.Field?.Identity.GetMetadata <IBindingMetadata>(); IBindingParameterContract contract = metadata?.Parameter; adoParameter.ParameterName = this.Name; if (contract?.Convert != null) { adoParameter.Value = contract.Convert(this.Field?.Value); } else if (this.Field != null) { adoParameter.Value = this.Field.Value; } else { adoParameter.Value = DBNull.Value; } if (contract?.Write != null) { BindingParameterInfo paramInfo = new BindingParameterInfo() { Metadata = metadata, Parameter = adoParameter, Field = this.Field, }; contract.Write(paramInfo); } }
public void Build(IDbDataParameter adoParameter) { IBindingMetadata metadata = this.Source?.Identity.Metadata.Require <IBindingMetadata>(); IBindingParameterContract contract = metadata?.Parameter; adoParameter.ParameterName = this.Name; if (contract?.Convert != null) { adoParameter.Value = contract.Convert(this.Source?.Snapshot); } else if (this.Source != null) { adoParameter.Value = this.Source.Snapshot; } else { adoParameter.Value = DBNull.Value; } if (contract?.Write != null) { BindingParameterInfo paramInfo = new BindingParameterInfo() { Metadata = metadata, Parameter = adoParameter, Field = this.Source, }; contract.Write(paramInfo); } }
public BufferWriter Compile(IEnumerable <ColumnName> columnNames) { List <Expression> body = new List <Expression>(); int index = 0; foreach (ColumnName columnName in columnNames) { IBindingMetadata metadata = columnName.Metadata.Lookup <IBindingMetadata>(); Expression value = this.GetValueExpression(metadata, columnName.Column); Expression writer = this.GetWriterExpression(index++, value); body.Add(writer); } if (!body.Any()) { return (dr, buf) => { } } ; ParameterExpression[] arguments = new[] { Arguments.DataReader, Arguments.Buffers }; Expression block = Expression.Block(body); return(Expression.Lambda <BufferWriter>(block, arguments).Compile()); }
private IEnumerable <IReference> GetValidReferences(IBindingMetadata metadata) { IReferenceMetadata referenceMetadata = metadata.Identity.Lookup <IReferenceMetadata>(); if (referenceMetadata != null) { return(referenceMetadata.References.Where(IsValid).OrderBy(r => r.Priority)); } return(Array.Empty <IReference>()); bool IsValid(IReference reference) { if (!reference.HasFlag(ReferenceFlags.Many) && !reference.Other.HasFlag(ReferenceFlags.Many)) { return(false); } IBindingMetadata metadata = reference.Find(ReferenceFlags.Child).Metadata.Identity.Lookup <IBindingMetadata>(); if (this.QueryType == QueryType.Aggregate && this.IsAggregateList(metadata)) { return(false); } return(true); } }
public IBindingValueContract GetValueContract(IBindingMetadata metadata) { if (metadata.Type.IsOpenGeneric(typeof(CustomList <>), out Type itemType)) { return(new BindingValueContract() { Read = null, Convert = info => { var listType = typeof(CustomList <>).MakeGenericType(itemType); var collectionType = typeof(ICollection <>).MakeGenericType(itemType); var newList = Expression.New(listType); var addMethod = collectionType.GetMethod("Add"); var variable = Expression.Variable(listType); var assignList = Expression.Assign(variable, newList); var addDefault = Expression.Call(variable, addMethod, Expression.Default(itemType)); return Expression.Block(new[] { variable }, assignList, addDefault, variable); } }); } return(null); }
private static void AddDataNode(NodeTree tree, DataAttribute attribute) { MetadataIdentity identity = new MetadataIdentity(tree.Schema, attribute.Name); IBindingMetadata metadata = identity.Lookup <IBindingMetadata>() ?? FindDynamicMetadata(identity); if (metadata != null) { Node node; if (metadata.HasFlag(BindingMetadataFlags.Dynamic)) { node = AddDynamicNode(tree, identity, metadata); } else { node = AddStaticNode(tree, metadata); } if (node != null) { node.Data = attribute; tree.Data.Add(node); } } }
public IBindingValueContract GetValueContract(IBindingMetadata metadata) { return(new BindingValueContract() { Read = this.GetRecordReaderMethod, Convert = metadata.Value.Convert, }); }
private Type GetOpenType(IBindingMetadata metadata) { if (metadata.Type.IsGenericType) { return(metadata.Type.GetGenericTypeDefinition()); } return(null); }
public IBindingCompositionContract GetCompositionContract(IBindingMetadata metadata) { return(new BindingCompositionContract() { Add = this.GetAddMethod(metadata), AddDynamic = this.GetAddDynamicMethod(metadata), Construct = this.GetConstructor(metadata), }); }
private void AddAggregateTargets(IEnumerable <ElementNode> elementNodes) { IBindingMetadata resultItem = this.Schema.GetMetadata <IBindingMetadata>().Item; foreach (ElementNode elementNode in elementNodes.Where(n => n.ListIndex != null && n.Value.Metadata.Parent.MemberOf.Equals(resultItem))) { this.State.Aggregate.Add(elementNode.Value.Metadata.Identity); } }
public IBindingHelperContract GetHelperContract(IBindingMetadata metadata) { if (!this.HasJsonAttribute(metadata)) { return(null); } return(this.helper); }
/// <summary> /// /// </summary> /// <param name="type"></param> /// <param name="provider"></param> /// <param name="scope"></param> /// <param name="metadata"></param> /// <param name="constructorArguments"></param> /// <param name="propertyValues"></param> public Binding(Type type, IProvider provider, IScope scope, IBindingMetadata metadata, ParameterMap constructorArguments, ParameterMap propertyValues) { Type = type; Provider = provider; Scope = scope; Metadata = metadata ?? EmptyBindingMetadata; ConstructorArguments = constructorArguments ?? new ParameterMap(null); PropertyValues = propertyValues ?? new ParameterMap(null); }
public IBindingValueContract GetValueContract(IBindingMetadata metadata) { IBindingValueContract fallback = metadata.Value; return(new BindingValueContract() { Read = ci => this.GetRecordReaderMethod(ci, fallback), Convert = fallback?.Convert, }); }
public IBindingValueContract GetValueContract(IBindingMetadata metadata) { IBindingValueContract fallback = metadata.Value; return(new BindingValueContract() { Convert = fallback.Convert, Read = ci => this.GetValueReaderProxy(ci, fallback), }); }
private Type GetOneValueType(IBindingMetadata metadata) { Type openType = this.GetOpenType(metadata); if (openType == typeof(One <>)) { return(metadata.Type.GetGenericArguments()[0]); } return(null); }
private MethodInfo GetAddMethod(IBindingMetadata metadata) { Type elementType = this.GetListElementType(metadata); if (elementType != null) { return(typeof(ICollection <>).MakeGenericType(elementType).GetMethod("Add")); } return(null); }
private MethodInfo GetAddDynamicMethod(IBindingMetadata metadata) { if (metadata.HasFlag(BindingMetadataFlags.Dynamic)) { Type dictionaryType = typeof(IDictionary <string, object>); return(dictionaryType.GetMethod("Add", new[] { typeof(string), typeof(object) })); } return(null); }
public static BindingException Create(IBindingMetadata metadata, string message = null, Exception innerException = null) { message ??= innerException?.Message; if (message != null) { return(new BindingException($"Cannot bind to {metadata.Identity}: {message}", innerException)); } return(new BindingException($"Cannot bind to {metadata.Identity}.", innerException)); }
internal static BindingException NoReferenceFound(IBindingMetadata metadata) { if (metadata.HasFlag(BindingMetadataFlags.Item)) { return(NoReferenceFound(metadata.Identity, metadata.Parent.Parent.Identity)); } else { return(NoReferenceFound(metadata.Identity, metadata.Parent.Identity)); } }
/// <summary> /// Initializes a new instance of the <see cref="Binding"/> class. /// </summary> /// <param name="service">The service that is controlled by the binding.</param> /// <param name="metadata">The binding's metadata container.</param> public Binding(Type service, IBindingMetadata metadata) { Ensure.ArgumentNotNull(service, "service"); Ensure.ArgumentNotNull(metadata, "metadata"); Service = service; Metadata = metadata; Parameters = new List<IParameter>(); ActivationActions = new List<Action<IContext, object>>(); DeactivationActions = new List<Action<IContext, object>>(); ScopeCallback = StandardScopeCallbacks.Transient; }
/// <summary> /// Initializes a new instance of the <see cref="Binding"/> class. /// </summary> /// <param name="service">The service that is controlled by the binding.</param> /// <param name="metadata">The binding's metadata container.</param> public Binding(Type service, IBindingMetadata metadata) { Ensure.ArgumentNotNull(service, "service"); Ensure.ArgumentNotNull(metadata, "metadata"); Service = service; Metadata = metadata; Parameters = new List <IParameter>(); ActivationActions = new List <Action <object> >(); DeactivationActions = new List <Action <object> >(); ScopeCallback = StandardScopeCallbacks.Transient; }
public IBindingParameterContract GetParameterContract(IBindingMetadata metadata) { if (!this.HasJsonAttribute(metadata)) { return(null); } return(new BindingParameterContract() { Convert = o => o != null ? (object)JsonConvert.SerializeObject(o, this.Settings) : DBNull.Value, }); }
public IBindingParameterContract GetParameterContract(IBindingMetadata metadata) { if (!this.HasJsonAttribute(metadata)) { return(null); } return(new BindingParameterContract() { Convert = o => o != null ? (object)JsonSerializer.Serialize(o, metadata.Type, this.Options) : DBNull.Value, }); }
public IBindingCompositionContract GetCompositionContract(IBindingMetadata metadata) { if (metadata.Type.IsOpenGeneric(typeof(CustomList <>), out Type itemType)) { return(new BindingCompositionContract() { Construct = Expression.New(typeof(CustomList <>).MakeGenericType(itemType)), Add = typeof(ICollection <>).MakeGenericType(itemType).GetMethod("Add"), }); } return(null); }
private static bool HasValidReference(IBindingMetadata metadata) { IReferenceMetadata referenceMetadata = metadata.Identity.Lookup <IReferenceMetadata>(); if (referenceMetadata != null) { IEnumerable <IReference> childReferences = referenceMetadata.References.Where(r => r.HasFlag(ReferenceFlags.Child)); return(childReferences.Any(r => r.HasFlag(ReferenceFlags.Many) || r.Other.HasFlag(ReferenceFlags.Many))); } return(false); }
public int GetListIndex(IBindingMetadata metadata) { if (metadata.HasFlag(BindingMetadataFlags.Model)) { return(ResultIndex); } else if (metadata.HasFlag(BindingMetadataFlags.Item) && metadata.Parent.HasFlag(BindingMetadataFlags.Model)) { return(ResultIndex); } return(this.GetListIndex(new BufferCacheKey(metadata.Identity))); }
public IBindingValueContract GetValueContract(IBindingMetadata metadata) { if (!this.HasJsonAttribute(metadata)) { return(null); } return(new BindingValueContract() { Convert = this.GetValueReaderProxy, Read = this.GetColumnReaderProxy, }); }
private IBindingMetadata FindDynamicMetadata(MetadataIdentity identity) { IBindingMetadata metadata = identity.GetMetadata <IBindingMetadata>(); while (metadata == null && (identity = identity.Pop()) != null) { metadata = identity.GetMetadata <IBindingMetadata>(); } if (metadata != null && metadata.HasFlag(BindingMetadataFlags.Dynamic)) { return(metadata); } return(null); }
/// <summary> /// Initializes a new instance of the <see cref="WebBinding"/> class. /// </summary> /// <param name="service">The service that is controlled by the binding.</param> /// <param name="metadata">The binding's metadata container.</param> public WebBinding(Type service, IBindingMetadata metadata) : base(service, metadata) { }
public bool Match(IBindingMetadata metadata) { return name == metadata.Name; }
public override bool Matches (IBindingMetadata metadata) { return metadata.Has ("IsSomething") && metadata.Get<bool> ("IsSomething"); }
public bool Match(IBindingMetadata metadata) { return constraints.All(c => c.Match(metadata)); }
public override bool Matches(IBindingMetadata metadata) { return metadata.Has("CanSwim") && metadata.Get<bool>("CanSwim"); }
/// <summary> /// /// </summary> /// <param name="type"></param> /// <param name="metadata"></param> public Binding(Type type, IBindingMetadata metadata) { Type = type; Metadata = metadata; }
/// <summary> /// Determines whether the specified binding metadata matches the constraint. /// </summary> /// <param name="metadata">The metadata in question.</param> /// <returns><c>True</c> if the metadata matches; otherwise <c>false</c>.</returns> public abstract bool Matches(IBindingMetadata metadata);
/// <summary> /// Determines whether the specified binding metadata matches the constraint. /// </summary> /// <param name="metadata">The metadata in question.</param> /// <returns><c>True</c> if the metadata matches; otherwise <c>false</c>.</returns> public override bool Matches(IBindingMetadata metadata) { Contract.Requires(metadata != null); return metadata.Name == this.Name; }
/// <summary> /// Determines whether the specified binding metadata matches the constraint. /// </summary> /// <param name="metadata">The metadata in question.</param> /// <returns> /// <c>True</c> if the metadata matches; otherwise <c>false</c>. /// </returns> public override bool Matches(IBindingMetadata metadata) { Ensure.ArgumentNotNull(metadata, "metadata"); return metadata.Name == Name; }