// Newly allocated stream IndexNode constructor public IndexNode(ServerProcess AProcess, Index AIndex, StreamID AStreamID, Stream AStream, IndexNodeType ANodeType) { FProcess = AProcess; FIndex = AIndex; FStreamID = AStreamID; FStream = AStream; NodeType = ANodeType; InternalInitialize(); }
protected override Task ValidateAsync() { // Check if there is a <ValueNode> with non-empty body. IndexNodeType valueNode = _indexListItems.ValueNode?.Where(v => !string.IsNullOrWhiteSpace(v.Value)) .FirstOrDefault(); if (valueNode == null) { throw new InvalidOperationException("No valid <ValueNode> found."); } return(Task.CompletedTask); }
public override async Task <IList <IVariableInformation> > GetChildrenAsync( int from, int count) { await InitAsync(); var result = new List <IVariableInformation>(); if (_store.ValidationError != null) { result.Add(_store.ValidationError); return(result.GetRange(from, count)); } var indexDic = new NatvisScope(_natvisScope); for (int index = from; index < from + count; index++) { IVariableInformation varInfo = await _store.GetOrEvaluateAsync(index, async i => { indexDic.AddScopedName("$i", $"{i}U"); string displayName = $"[{i}]"; // From the list of all <ValueNode> children, filter all with non-empty body // and return the first which Condition evaluates to true. IndexNodeType valueNode = await _indexListItems .ValueNode?.Where(v => !string.IsNullOrWhiteSpace(v.Value)) .FirstOrDefaultAsync(v => _evaluator.EvaluateConditionAsync( v.Condition, _variable, indexDic)); if (valueNode == null) { // For the current index $i, there is no <ValueNode> which passes the // Condition check. return(new ErrorVariableInformation( displayName, "<Error> No valid <ValueNode> found.")); } return(await _evaluator.GetExpressionValueOrErrorAsync( valueNode.Value, _variable, indexDic, displayName, "IndexListItems")); }); result.Add(varInfo); } return(result); }
/// <summary> /// Will return an IndexNode wrapper on a newly allocated IndexNode stream opened in exclusive mode /// it is the callers responsibility Dispose the returned IndexNode, closing and unlocking the stream /// </summary> private unsafe IndexNode AllocateNode(ServerProcess AProcess, IndexNodeType ANodeType) { // Allocate a new index node StreamID LStreamID = AProcess.StreamManager.Allocate(); Stream LStream = AProcess.StreamManager.Open(LStreamID, LockMode.Shared); // Size it (HeaderSize + ((KeyLength + DataLength | sizeof(StreamID)) * Capacity | Fanout) if (ANodeType == IndexNodeType.Routing) { LStream.SetLength(checked (IndexNode.HeaderSize + ((KeyLength + sizeof(StreamID)) * Fanout))); } else { LStream.SetLength(checked (IndexNode.HeaderSize + ((KeyLength + DataLength) * Capacity))); } return(new IndexNode(AProcess, this, LStreamID, LStream, ANodeType)); }
/// <summary> /// Initializes a new instance of the <see cref="IndexingStrategy"/> class. /// </summary> /// <param name="unique">if <c>true</c>, indicates that the values in the index are unique.</param> /// <param name="pathType">sets the <seealso cref="IndexPathType"/> property of the index.</param> /// <param name="nodeType">indicates whether the node is an element, attribute, or metadata.</param> /// <param name="keyType">sets the types of query supported by the index.</param> /// <param name="indexValueSyntax">sets the intended datatype of the item being indexed.</param> public IndexingStrategy( bool unique, IndexPathType pathType, IndexNodeType nodeType, IndexKeyType keyType, XmlDatatype indexValueSyntax) { }