private static ObjectFieldDefinition CreateDefinition( IDescriptorContext context) { var descriptor = ObjectFieldDescriptor .New(context, "node"); descriptor .Argument("id", a => a.Type <NonNullType <IdType> >()) .Type <NonNullType <NodeType> >() .Resolver(async ctx => { string id = ctx.Argument <string>("id"); IdValue deserializedId = _idSerializer.Deserialize(id); if (ctx.Schema.TryGetType(deserializedId.TypeName, out ObjectType type) && type.ContextData.TryGetValue( RelayConstants.NodeResolverFactory, out object o) && o is Func <IServiceProvider, INodeResolver> factory) { INodeResolver resolver = factory.Invoke(ctx.Service <IServiceProvider>()); return(await resolver.ResolveAsync( ctx, deserializedId.Value) .ConfigureAwait(false)); } return(null); }); return(descriptor.CreateDefinition()); }
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options) { var address = LayeredNodeAddress.Parse(uri); if (address.Port >= 0 || address.UserName != "" || address.Password != "" || address.ServerName != "") { throw new MalformedUriException(uri, "Network & Authentication information not permitted"); } if (nodeType.Is(typeof(IFile))) { var uri2 = address.InnerUri; if (StringUriUtils.ContainsQuery(uri2)) { uri2 += "&shadow=true"; } else { uri2 += "?shadow=true"; } return(resolver.Resolve(uri2, nodeType)); } return(resolver.Resolve(address.InnerUri)); }
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options) { var address = LayeredNodeAddress.Parse(uri); if (address.Port >= 0 || address.UserName != "" || address.Password != "" || address.ServerName != "") { throw new MalformedUriException(uri, "Network & Authentication information not permitted"); } if (nodeType.Is(typeof(IFile))) { var uri2 = address.InnerUri; if (StringUriUtils.ContainsQuery(uri2)) { uri2 += "&shadow=true"; } else { uri2 += "?shadow=true"; } return resolver.Resolve(uri2, nodeType); } return resolver.Resolve(address.InnerUri); }
public INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { if (nodeType.GetType().IsGenericType && nodeType.GetType().GetGenericTypeDefinition() == typeof(DataFileNodeType<>)) { var innerNodeType = nodeType.InnerType ?? NodeType.File; var file = (IFile)resolver.Resolve(address.PathAndQuery, innerNodeType); var dataFileType = typeof(DataFile<>); dataFileType = dataFileType.MakeGenericType(nodeType.GetType().GetGenericArguments()); var dataFile = (INode)Activator.CreateInstance(dataFileType, file, nodeType); canCache = true; return dataFile; } else { canCache = false; return null; } }
/// <summary> /// Load design from input stream /// </summary> /// <param name="design"></param> /// <param name="assigner"></param> /// <param name="resolver"></param> /// <returns></returns> public static IModelDesign Load(Stream design, INodeIdAssigner assigner = null, INodeResolver resolver = null) { try { var model = design.DeserializeFromXml <ModelDesign>(); return(new ModelDesignFile(model, assigner, resolver ?? new CompositeModelResolver())); } catch (Exception ex) { // Try to load as type dictionary if (!design.CanSeek) { // Stream is already partitially read - need to reset - if we cannot throw throw; } try { design.Seek(0, SeekOrigin.Begin); return(LoadTypeDictionary(design, assigner, resolver)); } catch { #pragma warning disable CA2200 // Rethrow to preserve stack details throw ex; #pragma warning restore CA2200 // Rethrow to preserve stack details } } }
public INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { if (nodeType.GetType().IsGenericType&& nodeType.GetType().GetGenericTypeDefinition() == typeof(DataFileNodeType <>)) { var innerNodeType = nodeType.InnerType ?? NodeType.File; var file = (IFile)resolver.Resolve(address.PathAndQuery, innerNodeType); var dataFileType = typeof(DataFile <>); dataFileType = dataFileType.MakeGenericType(nodeType.GetType().GetGenericArguments()); var dataFile = (INode)Activator.CreateInstance(dataFileType, file, nodeType); canCache = true; return(dataFile); } else { canCache = false; return(null); } }
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options) { var result = uri.SplitOnFirst("://"); if (result.Left != this.viewFileSystem.RootDirectory.Address.Scheme) { throw new NotSupportedException(result.Left); } return(this.viewFileSystem.Resolve(TextConversion.FromEscapedHexString(result.Right), nodeType)); }
private static IDirectory ResolveRootDirectory(INodeResolver resolver, string uri, bool create) { try { return create ? resolver.ResolveDirectory(uri).Create(true) : resolver.ResolveDirectory(uri); } catch (Exception e) { Console.Error.WriteLine(e); throw; } }
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options) { Pair<string, string> result; result = uri.SplitOnFirst("://"); if (result.Left != this.imaginaryFileSystem.RootDirectory.Address.Scheme) { throw new NotSupportedException(result.Left); } return this.imaginaryFileSystem.Resolve(TextConversion.FromEscapedHexString(result.Right), nodeType); }
private static IDirectory ResolveRootDirectory(INodeResolver resolver, string uri, bool create) { try { return(create ? resolver.ResolveDirectory(uri).Create(true) : resolver.ResolveDirectory(uri)); } catch (Exception e) { Console.Error.WriteLine(e); throw; } }
public virtual INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { string value; canCache = false; if (this.QueryKey == null) { value = "true"; } else { try { if (address.QueryValues[QueryKey] == null) { return null; } value = (string)address.QueryValues[this.QueryKey]; } catch (KeyNotFoundException) { value = null; } } if (nodeType.Equals(NodeType.File) && value != null && value.ToLower() == "true") { canCache = true; var innerNodeType = nodeType.InnerType; if (innerNodeType == null) { innerNodeType = NodeType.File; } var query = StringUriUtils.BuildQuery ( address.QueryValues, QueryFilter ); var uri = address.AbsolutePath + "?" + query; return new ShadowFile((IFile)resolver.Resolve(uri, innerNodeType), address); } return null; }
public virtual INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { string value; canCache = false; if (this.QueryKey == null) { value = "true"; } else { try { if (address.QueryValues[QueryKey] == null) { return(null); } value = (string)address.QueryValues[this.QueryKey]; } catch (KeyNotFoundException) { value = null; } } if (nodeType.Equals(NodeType.File) && value != null && value.ToLower() == "true") { canCache = true; var innerNodeType = nodeType.InnerType; if (innerNodeType == null) { innerNodeType = NodeType.File; } var query = StringUriUtils.BuildQuery ( address.QueryValues, QueryFilter ); var uri = address.AbsolutePath + "?" + query; return(new ShadowFile((IFile)resolver.Resolve(uri, innerNodeType), address)); } return(null); }
public override void OnBeforeCompleteType( ITypeCompletionContext completionContext, DefinitionBase definition, IDictionary <string, object> contextData) { if ((completionContext.IsQueryType ?? false) && definition is ObjectTypeDefinition objectTypeDefinition) { ObjectFieldDefinition typeNameField = objectTypeDefinition.Fields.First( t => t.Name.Equals(IntrospectionFields.TypeName) && t.IsIntrospectionField); var index = objectTypeDefinition.Fields.IndexOf(typeNameField) + 1; var descriptor = ObjectFieldDescriptor.New( completionContext.DescriptorContext, _node); IIdSerializer serializer = completionContext.Services.GetService <IIdSerializer>() ?? new IdSerializer(); descriptor .Argument(_id, a => a.Type <NonNullType <IdType> >()) .Type <NodeType>() .Resolve(async ctx => { var id = ctx.ArgumentValue <string>(_id); IdValue deserializedId = serializer.Deserialize(id); ctx.LocalContextData = ctx.LocalContextData .SetItem(WellKnownContextData.Id, deserializedId.Value) .SetItem(WellKnownContextData.Type, deserializedId.TypeName); if (ctx.Schema.TryGetType(deserializedId.TypeName, out ObjectType type) && type.ContextData.TryGetValue( RelayConstants.NodeResolverFactory, out object?o) && o is Func <IServiceProvider, INodeResolver> factory) { INodeResolver resolver = factory.Invoke(ctx.Services); return(await resolver.ResolveAsync(ctx, deserializedId.Value) .ConfigureAwait(false)); } return(null); }); objectTypeDefinition.Fields.Insert(index, descriptor.CreateDefinition()); } }
public override INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { string value; canCache = false; if (this.QueryKey == null) { return(null); } else { try { if (address.QueryValues[this.QueryKey] == null) { return(null); } value = (string)address.QueryValues[this.QueryKey]; } catch (KeyNotFoundException) { return(null); } } if (nodeType.Equals(NodeType.File)) { canCache = true; var query = StringUriUtils.BuildQuery ( address.QueryValues, pair => pair.Key.Equals(this.QueryKey, StringComparison.CurrentCultureIgnoreCase) ); var uri = address.AbsolutePath + "?" + query; var file = resolver.ResolveFile(uri); var service = (ITempIdentityFileService)file.GetService(new TempIdentityFileServiceType(value)); canCache = true; return(service.GetTempFile()); } return(null); }
public override INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { string value; canCache = false; if (this.QueryKey == null) { return null; } else { try { if (address.QueryValues[this.QueryKey] == null) { return null; } value = (string)address.QueryValues[this.QueryKey]; } catch (KeyNotFoundException) { return null; } } if (nodeType.Equals(NodeType.File)) { canCache = true; var query = StringUriUtils.BuildQuery ( address.QueryValues, pair => pair.Key.Equals(this.QueryKey, StringComparison.CurrentCultureIgnoreCase) ); var uri = address.AbsolutePath + "?" + query; var file = resolver.ResolveFile(uri); var service = (ITempIdentityFileService)file.GetService(new TempIdentityFileServiceType(value)); canCache = true; return service.GetTempFile(); } return null; }
/// <summary> /// Load design from file and optional identifier file /// </summary> /// <param name="designFile"></param> /// <param name="resolver"></param> /// <returns></returns> public static IModelDesign Load(string designFile, INodeResolver resolver = null) { using (var stream = File.OpenRead(designFile)) { var model = stream.DeserializeFromXml <ModelDesign>(); var identifierFile = Path.ChangeExtension(designFile, "csv"); INodeIdAssigner assigner = null; if (File.Exists(identifierFile)) { using (var stream2 = File.OpenRead(identifierFile)) { assigner = new IdentifierFile(stream2, model.TargetNamespace, model.TargetVersion); } } return(new ModelDesignFile(model, assigner, resolver ?? new CompositeModelResolver())); } }
public static IObjectTypeDescriptor AsNode( this IObjectTypeDescriptor descriptor, INodeResolver nodeResolver) { if (descriptor == null) { throw new ArgumentNullException(nameof(descriptor)); } if (nodeResolver == null) { throw new ArgumentNullException(nameof(nodeResolver)); } return(AsNode(descriptor, sp => nodeResolver)); }
private static ObjectFieldDefinition CreateDefinition( IDescriptorContext context) { var descriptor = ObjectFieldDescriptor .New(context, _node); IIdSerializer _serializer = null; descriptor .Argument(_id, a => a.Type <NonNullType <IdType> >()) .Type <NonNullType <NodeType> >() .Resolver(async ctx => { IServiceProvider services = ctx.Service <IServiceProvider>(); if (_serializer is null) { _serializer = services.GetService(typeof(IIdSerializer)) is IIdSerializer s ? s : new IdSerializer(); } var id = ctx.Argument <string>(_id); IdValue deserializedId = _serializer.Deserialize(id); ctx.LocalContextData = ctx.LocalContextData .SetItem(WellKnownContextData.Id, deserializedId.Value) .SetItem(WellKnownContextData.Type, deserializedId.TypeName); if (ctx.Schema.TryGetType(deserializedId.TypeName, out ObjectType type) && type.ContextData.TryGetValue( RelayConstants.NodeResolverFactory, out var o) && o is Func <IServiceProvider, INodeResolver> factory) { INodeResolver resolver = factory.Invoke(services); return(await resolver.ResolveAsync(ctx, deserializedId.Value) .ConfigureAwait(false)); } return(null); }); return(descriptor.CreateDefinition()); }
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options) { var node = base.Find(resolver, uri, nodeType, options); if (node.Equals(this.ImaginaryFileSystem.RootDirectory)) { var dir = (ImaginaryDirectory)node; dir.Refreshed += delegate { PopulateRoot(dir); }; PopulateRoot(dir); } return node; }
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options) { var node = base.Find(resolver, uri, nodeType, options); if (node.Equals(this.ImaginaryFileSystem.RootDirectory)) { var dir = (ImaginaryDirectory)node; dir.Refreshed += delegate { PopulateRoot(dir); }; PopulateRoot(dir); } return(node); }
/// <summary> /// Construct a new <see cref="NodeDelegationWrapper"/>. /// </summary> /// <param name="innerNode"> /// The <see cref="INode"/> to delegate to. /// </param> /// <param name="resolver"> /// The resolver used to delegate <c>Resolve</c> calls. /// </param> /// <param name="nodeAdapter"> /// The adapter that will adapt adapter candidate nodes returned be the /// <c>Resolve</c> and <c>ParentDirectory</c> methods. /// </param> protected NodeDelegationWrapper(INode innerNode, INodeResolver resolver, Converter <INode, INode> nodeAdapter) : base(innerNode) { if (resolver == null) { if (this.NodeType == NodeType.Directory) { resolver = new DefaultResolver(this); } else { resolver = new DefaultResolver(this); } } this.NodeResolver = resolver; this.NodeAdapter = nodeAdapter; }
public override INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { MediaFileNodeType mediaFileNodeType; if ((mediaFileNodeType = (nodeType as MediaFileNodeType)) != null) { var file = resolver.ResolveFile(address.PathAndQuery); var mediaFile = MediaFileFactory.Default.NewMediaFile(file, mediaFileNodeType); canCache = !mediaFileNodeType.UniqueInstance; return mediaFile; } else { canCache = false; return null; } }
public override INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { MediaFileNodeType mediaFileNodeType; if ((mediaFileNodeType = (nodeType as MediaFileNodeType)) != null) { var file = resolver.ResolveFile(address.PathAndQuery); var mediaFile = MediaFileFactory.Default.NewMediaFile(file, mediaFileNodeType); canCache = !mediaFileNodeType.UniqueInstance; return(mediaFile); } else { canCache = false; return(null); } }
/// <summary> /// Initializes a new instance of the QueryResult with a prepared hit collection. /// Use this constructor if the hit collection contains all items in the memory. /// </summary> /// <param name="nodes">The <see cref="IEnumerable<Node>"/> that contains hits.</param> public QueryResult(IEnumerable <Node> nodes) { switch (nodes) { case NodeList <Node> nodeList: _result = nodeList; Count = nodeList.Count; break; case List <Node> listOfNodes: _result = new NodeResolver(listOfNodes); Count = listOfNodes.Count; break; default: var nodeArray = nodes as Node[] ?? nodes.ToArray(); _result = new NodeResolver(nodeArray); Count = nodeArray.Length; break; } }
/// <summary> /// Initializes a new instance of the QueryResult with a prepared hit collection and it's count. /// Use this constructor if the hit collection does contain all items in the memory and uses a block-read algorithm. /// </summary> /// <param name="nodes">The <see cref="IEnumerable<Node>"/> that contains hits.</param> /// <param name="totalCount">Count of items.</param> public QueryResult(IEnumerable <Node> nodes, int totalCount) { _result = new NodeResolver(nodes); Count = totalCount; }
public void Accept(INodeResolver resolver) { resolver.Resolve(this); }
/// <summary> /// Construct a new <see cref="NodeDelegationWrapper"/>. /// </summary> /// <param name="innerNode"> /// The <see cref="INode"/> to delegate to. /// </param> /// <param name="resolver"> /// The resolver used to delegate <c>Resolve</c> calls. /// </param> /// <param name="nodeAdapter"> /// The adapter that will adapt adapter candidate nodes returned be the /// <c>Resolve</c> and <c>ParentDirectory</c> methods. /// </param> protected NodeDelegationWrapper(INode innerNode, INodeResolver resolver, Converter<INode, INode> nodeAdapter) : base(innerNode) { if (resolver == null) { if (this.NodeType == NodeType.Directory) { resolver = new DefaultResolver(this); } else { resolver = new DefaultResolver(this); } } this.NodeResolver = resolver; this.NodeAdapter = nodeAdapter; }
public DelegatingResolver(INodeResolver resolver) { this.resolver = resolver; }
protected DirectoryDelegationWrapper(IDirectory innerDirectory, INodeResolver resolver, Converter<INode, INode> nodeAdapter) : base(innerDirectory, resolver, nodeAdapter) { }
/// <summary> /// Load design from file /// </summary> /// <param name="designFile"></param> /// <param name="assigner"></param> /// <param name="resolver"></param> /// <returns></returns> public static IModelDesign LoadTypeDictionary(string designFile, INodeIdAssigner assigner = null, INodeResolver resolver = null) { using (var stream = File.OpenRead(designFile)) { return(LoadTypeDictionary(stream, assigner, resolver)); } }
public JumpPointResolver(INodeResolver resolver) { this.resolver = resolver; }
public abstract INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache);
public abstract INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options);
/* =========================================== */ /// <summary> /// Initializes a new instance of the QueryResult with identifiers as hit collection. /// </summary> /// <param name="result">The IEnumerable<int> that contains ids of hits.</param> public QueryResult(IEnumerable <int> result) { _result = new NodeList <Node>(result); Count = _result.IdCount; }
/// <summary> /// Initializes a new instance of the QueryResult with /// identifiers as hit collection and it's count. /// </summary> /// <param name="result">The IEnumerable<int> that contains ids of hits.</param> /// <param name="totalCount">Count of items.</param> public QueryResult(IEnumerable <int> result, int totalCount) { _result = new NodeList <Node>(result); Count = totalCount; }
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options) { var nodeAddress = ParseUri(uri); return(Find(nodeAddress, nodeType, options)); }
/// <summary> /// Load design from input stream /// </summary> /// <param name="design"></param> /// <param name="assigner"></param> /// <param name="resolver"></param> /// <returns></returns> public static IModelDesign LoadTypeDictionary(Stream design, INodeIdAssigner assigner = null, INodeResolver resolver = null) { var types = Types.Load(design, resolver as ITypeResolver); return(new ModelDesignFile(types.ToModelDesign(), assigner, resolver ?? new CompositeModelResolver())); }
public virtual INode Resolve(INodeAddress address, NodeType nodeType) { INode node; var fromCache = GetFromCache(address, nodeType); if (fromCache != null) { return(fromCache); } lock (this.SyncLock) { if (IsContainedInShortcut(address)) { var parent = (IDirectory)this.Resolve(address.Parent, NodeType.Directory); node = parent.Resolve(address.Name, nodeType); AddToCache(address, node); return(node); } INodeResolver resolver = this; if (this.Extenders != null) { foreach (INodeResolutionFilter filter in this.Extenders.NodeResolutionFilters) { bool canCache; if ((node = filter.Filter(ref resolver, ref address, ref nodeType, out canCache)) != null) { node = Decorate(node); if (canCache) { if (node is IDirectory) { AttachShortcut((IDirectory)node); } AddToCache(node); } return(node); } } } } if (!AddressOk(address)) { throw new MalformedUriException(address.Uri, "Malformed or unsupported URI"); } lock (this.SyncLock) { if (fromCache == null) { node = CreateNode(address, nodeType); node = Decorate(node); if (node is IDirectory) { AttachShortcut((IDirectory)node); } AddToCache(node); } else { node = fromCache; } return(node); } }
/// <summary> /// For dynamic contents /// </summary> /// <param name="nodes"></param> public QueryResult(IEnumerable <Node> nodes) { _result = new _NodeResolver(nodes); }
protected DirectoryDelegationWrapper(IDirectory innerDirectory, INodeResolver resolver, Converter <INode, INode> nodeAdapter) : base(innerDirectory, resolver, nodeAdapter) { }