Microsoft/vscode
1
0
Fork 0
mirror of https://github.com/microsoft/vscode.git synced 2026-05-08 17:19:48 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #94540 from microsoft/joao/iterator

Browse Source 
Adopt native iterators across the workbench
This commit is contained in:
João Moreno
2020-04-06 15:31:19 +02:00
committed by GitHub
parent c51af861d2 014c7b7087
commit 13a6b20db5
21 changed files with 255 additions and 456 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/vs/base/browser/ui/tree/asyncDataTree.ts
+2 -2
View File
@@ -11,7 +11,7 @@ import { IDisposable, dispose, DisposableStore } from 'vs/base/common/lifecycle'
import { Emitter, Event } from 'vs/base/common/event';
import { timeout, CancelablePromise, createCancelablePromise } from 'vs/base/common/async';
import { IListStyles } from 'vs/base/browser/ui/list/listWidget';
import { Iterator } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
import { IDragAndDropData } from 'vs/base/browser/dnd';
import { ElementsDragAndDropData } from 'vs/base/browser/ui/list/listView';
import { isPromiseCanceledError, onUnexpectedError } from 'vs/base/common/errors';
@@ -943,7 +943,7 @@ export class AsyncDataTree<TInput, T, TFilterData = void> implements IDisposable
return {
element: node,
children: node.hasChildren ? Iterator.map(Iterator.fromArray(node.children), child => this.asTreeElement(child, viewStateContext)) : [],
children: node.hasChildren ? Iterable.map(node.children, child => this.asTreeElement(child, viewStateContext)) : [],
collapsible: node.hasChildren,
collapsed
};
src/vs/base/browser/ui/tree/compressedObjectTreeModel.ts
+19 -20
View File
@@ -4,14 +4,14 @@
*--------------------------------------------------------------------------------------------*/
import { ISpliceable } from 'vs/base/common/sequence';
import { Iterator, ISequence } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
import { Event } from 'vs/base/common/event';
import { ITreeModel, ITreeNode, ITreeElement, ICollapseStateChangeEvent, ITreeModelSpliceEvent, TreeError, TreeFilterResult, TreeVisibility, WeakMapper } from 'vs/base/browser/ui/tree/tree';
import { IObjectTreeModelOptions, ObjectTreeModel, IObjectTreeModel } from 'vs/base/browser/ui/tree/objectTreeModel';
// Exported only for test reasons, do not use directly
export interface ICompressedTreeElement<T> extends ITreeElement<T> {
readonly children?: ISequence<ICompressedTreeElement<T>>;
readonly children?: Iterable<ICompressedTreeElement<T>>;
readonly incompressible?: boolean;
}
@@ -27,7 +27,7 @@ function noCompress<T>(element: ICompressedTreeElement<T>): ITreeElement<ICompre
return {
element: { elements, incompressible },
children: Iterator.map(Iterator.from(element.children), noCompress),
children: Iterable.map(Iterable.from(element.children), noCompress),
collapsible: element.collapsible,
collapsed: element.collapsed
};
@@ -38,12 +38,11 @@ export function compress<T>(element: ICompressedTreeElement<T>): ITreeElement<IC
const elements = [element.element];
const incompressible = element.incompressible || false;
let childrenIterator: Iterator<ITreeElement<T>>;
let childrenIterator: Iterable<ITreeElement<T>>;
let children: ITreeElement<T>[];
while (true) {
childrenIterator = Iterator.from(element.children);
children = Iterator.collect(childrenIterator, 2);
[children, childrenIterator] = Iterable.consume(Iterable.from(element.children), 2);
if (children.length !== 1) {
break;
@@ -60,19 +59,19 @@ export function compress<T>(element: ICompressedTreeElement<T>): ITreeElement<IC
return {
element: { elements, incompressible },
children: Iterator.map(Iterator.concat(Iterator.fromArray(children), childrenIterator), compress),
children: Iterable.map(Iterable.concat(children, childrenIterator), compress),
collapsible: element.collapsible,
collapsed: element.collapsed
};
}
function _decompress<T>(element: ITreeElement<ICompressedTreeNode<T>>, index = 0): ICompressedTreeElement<T> {
let children: Iterator<ICompressedTreeElement<T>>;
let children: Iterable<ICompressedTreeElement<T>>;
if (index < element.element.elements.length - 1) {
children = Iterator.single(_decompress(element, index + 1));
children = [_decompress(element, index + 1)];
} else {
children = Iterator.map(Iterator.from(element.children), el => _decompress(el, 0));
children = Iterable.map(Iterable.from(element.children), el => _decompress(el, 0));
}
if (index === 0 && element.element.incompressible) {
@@ -98,12 +97,12 @@ export function decompress<T>(element: ITreeElement<ICompressedTreeNode<T>>): IC
return _decompress(element, 0);
}
function splice<T>(treeElement: ICompressedTreeElement<T>, element: T, children: Iterator<ICompressedTreeElement<T>>): ICompressedTreeElement<T> {
function splice<T>(treeElement: ICompressedTreeElement<T>, element: T, children: Iterable<ICompressedTreeElement<T>>): ICompressedTreeElement<T> {
if (treeElement.element === element) {
return { ...treeElement, children };
}
return { ...treeElement, children: Iterator.map(Iterator.from(treeElement.children), e => splice(e, element, children)) };
return { ...treeElement, children: Iterable.map(Iterable.from(treeElement.children), e => splice(e, element, children)) };
}
interface ICompressedObjectTreeModelOptions<T, TFilterData> extends IObjectTreeModelOptions<ICompressedTreeNode<T>, TFilterData> {
@@ -136,10 +135,10 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
setChildren(
element: T | null,
children: ISequence<ICompressedTreeElement<T>> | undefined
children: Iterable<ICompressedTreeElement<T>> = Iterable.empty()
): void {
if (element === null) {
const compressedChildren = Iterator.map(Iterator.from(children), this.enabled ? compress : noCompress);
const compressedChildren = Iterable.map(children, this.enabled ? compress : noCompress);
this._setChildren(null, compressedChildren);
return;
}
@@ -155,7 +154,7 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
const parent = this.model.getNode(compressedParentNode) as ITreeNode<ICompressedTreeNode<T>, TFilterData>;
const decompressedElement = decompress(node);
const splicedElement = splice(decompressedElement, element, Iterator.from(children));
const splicedElement = splice(decompressedElement, element, children);
const recompressedElement = (this.enabled ? compress : noCompress)(splicedElement);
const parentChildren = parent.children
@@ -176,15 +175,15 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
this.enabled = enabled;
const root = this.model.getNode();
const rootChildren = Iterator.from(root.children as ITreeNode<ICompressedTreeNode<T>>[]);
const decompressedRootChildren = Iterator.map(rootChildren, decompress);
const recompressedRootChildren = Iterator.map(decompressedRootChildren, enabled ? compress : noCompress);
const rootChildren = root.children as ITreeNode<ICompressedTreeNode<T>>[];
const decompressedRootChildren = Iterable.map(rootChildren, decompress);
const recompressedRootChildren = Iterable.map(decompressedRootChildren, enabled ? compress : noCompress);
this._setChildren(null, recompressedRootChildren);
}
private _setChildren(
node: ICompressedTreeNode<T> | null,
children: ISequence<ITreeElement<ICompressedTreeNode<T>>> | undefined
children: Iterable<ITreeElement<ICompressedTreeNode<T>>>
): void {
const insertedElements = new Set<T | null>();
const _onDidCreateNode = (node: ITreeNode<ICompressedTreeNode<T>, TFilterData>) => {
@@ -413,7 +412,7 @@ export class CompressibleObjectTreeModel<T extends NonNullable<any>, TFilterData
this.model = new CompressedObjectTreeModel(user, mapList(this.nodeMapper, list), mapOptions(compressedNodeUnwrapper, options));
}
setChildren(element: T | null, children?: ISequence<ICompressedTreeElement<T>>): void {
setChildren(element: T | null, children: Iterable<ICompressedTreeElement<T>> = Iterable.empty()): void {
this.model.setChildren(element, children);
}
src/vs/base/browser/ui/tree/dataTree.ts
+3 -3
View File
@@ -8,7 +8,7 @@ import { ISpliceable } from 'vs/base/common/sequence';
import { ITreeNode, ITreeModel, ITreeElement, ITreeRenderer, ITreeSorter, IDataSource, TreeError } from 'vs/base/browser/ui/tree/tree';
import { ObjectTreeModel } from 'vs/base/browser/ui/tree/objectTreeModel';
import { IListVirtualDelegate, IIdentityProvider } from 'vs/base/browser/ui/list/list';
import { Iterator } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
export interface IDataTreeOptions<T, TFilterData = void> extends IAbstractTreeOptions<T, TFilterData> {
readonly sorter?: ITreeSorter<T>;
@@ -158,9 +158,9 @@ export class DataTree<TInput, T, TFilterData = void> extends AbstractTree<T | nu
this.model.setChildren((element === this.input ? null : element) as T, this.iterate(element, isCollapsed).elements, onDidCreateNode, onDidDeleteNode);
}
private iterate(element: TInput | T, isCollapsed?: (el: T) => boolean | undefined): { elements: Iterator<ITreeElement<T>>, size: number } {
private iterate(element: TInput | T, isCollapsed?: (el: T) => boolean | undefined): { elements: Iterable<ITreeElement<T>>, size: number } {
const children = this.dataSource.getChildren(element);
const elements = Iterator.map<any, ITreeElement<T>>(Iterator.fromArray(children), element => {
const elements = Iterable.map(children, element => {
const { elements: children, size } = this.iterate(element, isCollapsed);
const collapsible = this.dataSource.hasChildren ? this.dataSource.hasChildren(element) : undefined;
const collapsed = size === 0 ? undefined : (isCollapsed && isCollapsed(element));
src/vs/base/browser/ui/tree/indexTree.ts
+2 -2
View File
@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import 'vs/css!./media/tree';
import { Iterator, ISequence } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
import { AbstractTree, IAbstractTreeOptions } from 'vs/base/browser/ui/tree/abstractTree';
import { ISpliceable } from 'vs/base/common/sequence';
import { IndexTreeModel } from 'vs/base/browser/ui/tree/indexTreeModel';
@@ -28,7 +28,7 @@ export class IndexTree<T, TFilterData = void> extends AbstractTree<T, TFilterDat
super(user, container, delegate, renderers, options);
}
splice(location: number[], deleteCount: number, toInsert: ISequence<ITreeElement<T>> = Iterator.empty()): void {
splice(location: number[], deleteCount: number, toInsert: Iterable<ITreeElement<T>> = Iterable.empty()): void {
this.model.splice(location, deleteCount, toInsert);
}
src/vs/base/browser/ui/tree/indexTreeModel.ts
+9 -9
View File
@@ -6,7 +6,7 @@
import { ICollapseStateChangeEvent, ITreeElement, ITreeFilter, ITreeFilterDataResult, ITreeModel, ITreeNode, TreeVisibility, ITreeModelSpliceEvent, TreeError } from 'vs/base/browser/ui/tree/tree';
import { tail2 } from 'vs/base/common/arrays';
import { Emitter, Event, EventBufferer } from 'vs/base/common/event';
import { ISequence, Iterator } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
import { ISpliceable } from 'vs/base/common/sequence';
// Exported for tests
@@ -103,7 +103,7 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
splice(
location: number[],
deleteCount: number,
toInsert?: ISequence<ITreeElement<T>>,
toInsert: Iterable<ITreeElement<T>> = Iterable.empty(),
onDidCreateNode?: (node: ITreeNode<T, TFilterData>) => void,
onDidDeleteNode?: (node: ITreeNode<T, TFilterData>) => void
): void {
@@ -113,7 +113,7 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
const { parentNode, listIndex, revealed, visible } = this.getParentNodeWithListIndex(location);
const treeListElementsToInsert: ITreeNode<T, TFilterData>[] = [];
const nodesToInsertIterator = Iterator.map(Iterator.from(toInsert), el => this.createTreeNode(el, parentNode, parentNode.visible ? TreeVisibility.Visible : TreeVisibility.Hidden, revealed, treeListElementsToInsert, onDidCreateNode));
const nodesToInsertIterator = Iterable.map(toInsert, el => this.createTreeNode(el, parentNode, parentNode.visible ? TreeVisibility.Visible : TreeVisibility.Hidden, revealed, treeListElementsToInsert, onDidCreateNode));
const lastIndex = location[location.length - 1];
@@ -134,14 +134,14 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
let insertedVisibleChildrenCount = 0;
let renderNodeCount = 0;
Iterator.forEach(nodesToInsertIterator, child => {
for (const child of nodesToInsertIterator) {
nodesToInsert.push(child);
renderNodeCount += child.renderNodeCount;
if (child.visible) {
child.visibleChildIndex = visibleChildStartIndex + insertedVisibleChildrenCount++;
}
});
}
const deletedNodes = parentNode.children.splice(lastIndex, deleteCount, ...nodesToInsert);
@@ -365,21 +365,21 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
treeListElements.push(node);
}
const childElements = Iterator.from(treeElement.children);
const childElements = treeElement.children || Iterable.empty();
const childRevealed = revealed && visibility !== TreeVisibility.Hidden && !node.collapsed;
const childNodes = Iterator.map(childElements, el => this.createTreeNode(el, node, visibility, childRevealed, treeListElements, onDidCreateNode));
const childNodes = Iterable.map(childElements, el => this.createTreeNode(el, node, visibility, childRevealed, treeListElements, onDidCreateNode));
let visibleChildrenCount = 0;
let renderNodeCount = 1;
Iterator.forEach(childNodes, child => {
for (const child of childNodes) {
node.children.push(child);
renderNodeCount += child.renderNodeCount;
if (child.visible) {
child.visibleChildIndex = visibleChildrenCount++;
}
});
}
node.collapsible = node.collapsible || node.children.length > 0;
node.visibleChildrenCount = visibleChildrenCount;
src/vs/base/browser/ui/tree/objectTree.ts
+3 -3
View File
@@ -3,7 +3,7 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { ISequence } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
import { AbstractTree, IAbstractTreeOptions, IAbstractTreeOptionsUpdate } from 'vs/base/browser/ui/tree/abstractTree';
import { ISpliceable } from 'vs/base/common/sequence';
import { ITreeNode, ITreeModel, ITreeElement, ITreeRenderer, ITreeSorter, ICollapseStateChangeEvent } from 'vs/base/browser/ui/tree/tree';
@@ -33,7 +33,7 @@ export class ObjectTree<T extends NonNullable<any>, TFilterData = void> extends
super(user, container, delegate, renderers, options as IObjectTreeOptions<T | null, TFilterData>);
}
setChildren(element: T | null, children?: ISequence<ITreeElement<T>>): void {
setChildren(element: T | null, children: Iterable<ITreeElement<T>> = Iterable.empty()): void {
this.model.setChildren(element, children);
}
@@ -184,7 +184,7 @@ export class CompressibleObjectTree<T extends NonNullable<any>, TFilterData = vo
super(user, container, delegate, compressibleRenderers, asObjectTreeOptions<T, TFilterData>(compressedTreeNodeProvider, options));
}
setChildren(element: T | null, children?: ISequence<ICompressedTreeElement<T>>): void {
setChildren(element: T | null, children: Iterable<ICompressedTreeElement<T>> = Iterable.empty()): void {
this.model.setChildren(element, children);
}
src/vs/base/browser/ui/tree/objectTreeModel.ts
+11 -13
View File
@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import { ISpliceable } from 'vs/base/common/sequence';
import { Iterator, ISequence, getSequenceIterator } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
import { IndexTreeModel, IIndexTreeModelOptions } from 'vs/base/browser/ui/tree/indexTreeModel';
import { Event } from 'vs/base/common/event';
import { ITreeModel, ITreeNode, ITreeElement, ITreeSorter, ICollapseStateChangeEvent, ITreeModelSpliceEvent, TreeError } from 'vs/base/browser/ui/tree/tree';
@@ -14,7 +14,7 @@ import { mergeSort } from 'vs/base/common/arrays';
export type ITreeNodeCallback<T, TFilterData> = (node: ITreeNode<T, TFilterData>) => void;
export interface IObjectTreeModel<T extends NonNullable<any>, TFilterData extends NonNullable<any> = void> extends ITreeModel<T | null, TFilterData, T | null> {
setChildren(element: T | null, children: ISequence<ITreeElement<T>> | undefined): void;
setChildren(element: T | null, children: Iterable<ITreeElement<T>> | undefined): void;
resort(element?: T | null, recursive?: boolean): void;
}
@@ -62,7 +62,7 @@ export class ObjectTreeModel<T extends NonNullable<any>, TFilterData extends Non
setChildren(
element: T | null,
children: ISequence<ITreeElement<T>> | undefined,
children: Iterable<ITreeElement<T>> = Iterable.empty(),
onDidCreateNode?: ITreeNodeCallback<T, TFilterData>,
onDidDeleteNode?: ITreeNodeCallback<T, TFilterData>
): void {
@@ -72,7 +72,7 @@ export class ObjectTreeModel<T extends NonNullable<any>, TFilterData extends Non
private _setChildren(
location: number[],
children: ISequence<ITreeElement<T>> | undefined,
children: Iterable<ITreeElement<T>> = Iterable.empty(),
onDidCreateNode?: ITreeNodeCallback<T, TFilterData>,
onDidDeleteNode?: ITreeNodeCallback<T, TFilterData>
): void {
@@ -132,14 +132,12 @@ export class ObjectTreeModel<T extends NonNullable<any>, TFilterData extends Non
);
}
private preserveCollapseState(elements: ISequence<ITreeElement<T>> | undefined): ISequence<ITreeElement<T>> {
let iterator = elements ? getSequenceIterator(elements) : Iterator.empty<ITreeElement<T>>();
private preserveCollapseState(elements: Iterable<ITreeElement<T>> = Iterable.empty()): Iterable<ITreeElement<T>> {
if (this.sorter) {
iterator = Iterator.fromArray(mergeSort(Iterator.collect(iterator), this.sorter.compare.bind(this.sorter)));
elements = mergeSort([...elements], this.sorter.compare.bind(this.sorter));
}
return Iterator.map(iterator, treeElement => {
return Iterable.map(elements, treeElement => {
let node = this.nodes.get(treeElement.element);
if (!node && this.identityProvider) {
@@ -182,14 +180,14 @@ export class ObjectTreeModel<T extends NonNullable<any>, TFilterData extends Non
this._setChildren(location, this.resortChildren(node, recursive));
}
private resortChildren(node: ITreeNode<T | null, TFilterData>, recursive: boolean, first = true): ISequence<ITreeElement<T>> {
let childrenNodes = Iterator.fromArray(node.children as ITreeNode<T, TFilterData>[]);
private resortChildren(node: ITreeNode<T | null, TFilterData>, recursive: boolean, first = true): Iterable<ITreeElement<T>> {
let childrenNodes = [...node.children] as ITreeNode<T, TFilterData>[];
if (recursive || first) {
childrenNodes = Iterator.fromArray(Iterator.collect(childrenNodes).sort(this.sorter!.compare.bind(this.sorter)));
childrenNodes = mergeSort(childrenNodes, this.sorter!.compare.bind(this.sorter));
}
return Iterator.map<ITreeNode<T | null, TFilterData>, ITreeElement<T>>(childrenNodes, node => ({
return Iterable.map<ITreeNode<T | null, TFilterData>, ITreeElement<T>>(childrenNodes, node => ({
element: node.element as T,
collapsible: node.collapsible,
collapsed: node.collapsed,
src/vs/base/browser/ui/tree/tree.ts
+1 -2
View File
@@ -4,7 +4,6 @@
*--------------------------------------------------------------------------------------------*/
import { Event } from 'vs/base/common/event';
import { Iterator } from 'vs/base/common/iterator';
import { IListRenderer, IListDragOverReaction, IListDragAndDrop, ListDragOverEffect } from 'vs/base/browser/ui/list/list';
import { IDragAndDropData } from 'vs/base/browser/dnd';
@@ -74,7 +73,7 @@ export interface ITreeSorter<T> {
export interface ITreeElement<T> {
readonly element: T;
readonly children?: Iterator<ITreeElement<T>> | ITreeElement<T>[];
readonly children?: Iterable<ITreeElement<T>>;
readonly collapsible?: boolean;
readonly collapsed?: boolean;
}
src/vs/base/common/iterator.ts
+23 -194
View File
@@ -3,37 +3,6 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
export interface IteratorDefinedResult<T> {
readonly done: false;
readonly value: T;
}
export interface IteratorUndefinedResult {
readonly done: true;
readonly value: undefined;
}
export const FIN: IteratorUndefinedResult = { done: true, value: undefined };
export type IteratorResult<T> = IteratorDefinedResult<T> | IteratorUndefinedResult;
export interface Iterator<T> {
next(): IteratorResult<T>;
}
interface NativeIteratorYieldResult<TYield> {
done?: false;
value: TYield;
}
interface NativeIteratorReturnResult<TReturn> {
done: true;
value: TReturn;
}
type NativeIteratorResult<T, TReturn = any> = NativeIteratorYieldResult<T> | NativeIteratorReturnResult<TReturn>;
export interface NativeIterator<T> {
next(): NativeIteratorResult<T>;
}
export namespace Iterable {
const _empty: Iterable<any> = Object.freeze([]);
@@ -41,6 +10,10 @@ export namespace Iterable {
return _empty;
}
export function from<T>(iterable: Iterable<T> | undefined | null): Iterable<T> {
return iterable || _empty;
}
export function first<T>(iterable: Iterable<T>): T | undefined {
return iterable[Symbol.iterator]().next().value;
}
@@ -67,183 +40,39 @@ export namespace Iterable {
yield fn(element);
}
}
}
export module Iterator {
const _empty: Iterator<any> = {
next() {
return FIN;
}
};
export function empty<T>(): Iterator<T> {
return _empty;
}
export function single<T>(value: T): Iterator<T> {
let done = false;
return {
next(): IteratorResult<T> {
if (done) {
return FIN;
}
done = true;
return { done: false, value };
}
};
}
export function fromArray<T>(array: ReadonlyArray<T>, index = 0, length = array.length): Iterator<T> {
return {
next(): IteratorResult<T> {
if (index >= length) {
return FIN;
}
return { done: false, value: array[index++] };
}
};
}
export function fromNativeIterator<T>(it: NativeIterator<T>): Iterator<T> {
return {
next(): IteratorResult<T> {
const result = it.next();
if (result.done) {
return FIN;
}
return { done: false, value: result.value };
}
};
}
export function from<T>(elements: Iterator<T> | T[] | undefined): Iterator<T> {
if (!elements) {
return Iterator.empty();
} else if (Array.isArray(elements)) {
return Iterator.fromArray(elements);
} else {
return elements;
}
}
export function map<T, R>(iterator: Iterator<T>, fn: (t: T) => R): Iterator<R> {
return {
next() {
const element = iterator.next();
if (element.done) {
return FIN;
} else {
return { done: false, value: fn(element.value) };
}
}
};
}
export function filter<T>(iterator: Iterator<T>, fn: (t: T) => boolean): Iterator<T> {
return {
next() {
while (true) {
const element = iterator.next();
if (element.done) {
return FIN;
}
if (fn(element.value)) {
return { done: false, value: element.value };
}
}
}
};
}
export function some<T>(iterator: Iterator<T> | NativeIterator<T>, fn: (t: T) => boolean): boolean {
while (true) {
const element = iterator.next();
if (element.done) {
return false;
}
if (fn(element.value)) {
return true;
export function* concat<T>(...iterables: Iterable<T>[]): Iterable<T> {
for (const iterable of iterables) {
for (const element of iterable) {
yield element;
}
}
}
export function forEach<T>(iterator: Iterator<T>, fn: (t: T) => void): void {
for (let next = iterator.next(); !next.done; next = iterator.next()) {
fn(next.value);
}
}
export function collect<T>(iterator: Iterator<T>, atMost: number = Number.POSITIVE_INFINITY): T[] {
const result: T[] = [];
/**
* Consumes `atMost` elements from iterable and returns the consumed elements,
* and an iterable for the rest of the elements.
*/
export function consume<T>(iterable: Iterable<T>, atMost: number = Number.POSITIVE_INFINITY): [T[], Iterable<T>] {
const consumed: T[] = [];
if (atMost === 0) {
return result;
return [consumed, iterable];
}
let i = 0;
const iterator = iterable[Symbol.iterator]();
for (let next = iterator.next(); !next.done; next = iterator.next()) {
result.push(next.value);
for (let i = 0; i < atMost; i++) {
const next = iterator.next();
if (++i >= atMost) {
break;
if (next.done) {
return [consumed, Iterable.empty()];
}
consumed.push(next.value);
}
return result;
}
export function concat<T>(...iterators: Iterator<T>[]): Iterator<T> {
let i = 0;
return {
next() {
if (i >= iterators.length) {
return FIN;
}
const iterator = iterators[i];
const result = iterator.next();
if (result.done) {
i++;
return this.next();
}
return result;
}
};
}
export function chain<T>(iterator: Iterator<T>): ChainableIterator<T> {
return new ChainableIterator(iterator);
}
}
export class ChainableIterator<T> implements Iterator<T> {
constructor(private it: Iterator<T>) { }
next(): IteratorResult<T> { return this.it.next(); }
map<R>(fn: (t: T) => R): ChainableIterator<R> { return new ChainableIterator(Iterator.map(this.it, fn)); }
filter(fn: (t: T) => boolean): ChainableIterator<T> { return new ChainableIterator(Iterator.filter(this.it, fn)); }
}
export type ISequence<T> = Iterator<T> | T[];
export function getSequenceIterator<T>(arg: ISequence<T> | undefined): Iterator<T> {
if (Array.isArray(arg)) {
return Iterator.fromArray(arg);
} else if (!arg) {
return Iterator.empty();
} else {
return arg;
return [consumed, { [Symbol.iterator]() { return iterator; } }];
}
}
src/vs/base/common/map.ts
+1 -2
View File
@@ -5,7 +5,6 @@
import { URI } from 'vs/base/common/uri';
import { CharCode } from 'vs/base/common/charCode';
import { FIN } from './iterator';
/**
* @deprecated ES6: use `[...SetOrMap.values()]`
@@ -369,7 +368,7 @@ export class TernarySearchTree<E> {
this._forEach(node, value => data.push(value));
}
if (idx >= data.length) {
return FIN;
return { done: true, value: undefined };
}
if (!res) {
src/vs/base/common/resourceTree.ts
+6 -5
View File
@@ -5,7 +5,6 @@
import { memoize } from 'vs/base/common/decorators';
import * as paths from 'vs/base/common/path';
import { Iterator } from 'vs/base/common/iterator';
import { relativePath, joinPath } from 'vs/base/common/resources';
import { URI } from 'vs/base/common/uri';
import { PathIterator, values } from 'vs/base/common/map';
@@ -15,7 +14,7 @@ export interface IResourceNode<T, C = void> {
readonly relativePath: string;
readonly name: string;
readonly element: T | undefined;
readonly children: Iterator<IResourceNode<T, C>>;
readonly children: Iterable<IResourceNode<T, C>>;
readonly childrenCount: number;
readonly parent: IResourceNode<T, C> | undefined;
readonly context: C;
@@ -30,8 +29,8 @@ class Node<T, C> implements IResourceNode<T, C> {
return this._children.size;
}
get children(): Iterator<Node<T, C>> {
return Iterator.fromArray(values(this._children));
get children(): Iterable<Node<T, C>> {
return [...values(this._children)];
}
@memoize
@@ -69,7 +68,9 @@ function collect<T, C>(node: IResourceNode<T, C>, result: T[]): T[] {
result.push(node.element);
}
Iterator.forEach(node.children, child => collect(child, result));
for (const child of node.children) {
collect(child, result);
}
return result;
}
src/vs/base/test/browser/ui/tree/compressedObjectTreeModel.test.ts
+31 -31
View File
@@ -5,7 +5,7 @@
import * as assert from 'assert';
import { compress, ICompressedTreeElement, ICompressedTreeNode, decompress, CompressedObjectTreeModel } from 'vs/base/browser/ui/tree/compressedObjectTreeModel';
import { Iterator } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
import { ITreeNode } from 'vs/base/browser/ui/tree/tree';
import { ISpliceable } from 'vs/base/common/sequence';
@@ -16,7 +16,7 @@ interface IResolvedCompressedTreeElement<T> extends ICompressedTreeElement<T> {
function resolve<T>(treeElement: ICompressedTreeElement<T>): IResolvedCompressedTreeElement<T> {
const result: any = { element: treeElement.element };
const children = Iterator.collect(Iterator.map(Iterator.from(treeElement.children), resolve));
const children = [...Iterable.map(Iterable.from(treeElement.children), resolve)];
if (treeElement.incompressible) {
result.incompressible = true;
@@ -315,25 +315,25 @@ suite('CompressedObjectTree', function () {
const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
const model = new CompressedObjectTreeModel<number>('test', toSpliceable(list));
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{ element: 0 },
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(toArray(list), [[0], [1], [2]]);
assert.equal(model.size, 3);
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{ element: 3 },
{ element: 4 },
{ element: 5 },
]));
]);
assert.deepEqual(toArray(list), [[3], [4], [5]]);
assert.equal(model.size, 3);
model.setChildren(null, Iterator.empty());
model.setChildren(null);
assert.deepEqual(toArray(list), []);
assert.equal(model.size, 0);
});
@@ -342,34 +342,34 @@ suite('CompressedObjectTree', function () {
const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
const model = new CompressedObjectTreeModel<number>('test', toSpliceable(list));
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(toArray(list), [[0], [10], [11], [12], [1], [2]]);
assert.equal(model.size, 6);
model.setChildren(12, Iterator.fromArray([
model.setChildren(12, [
{ element: 120 },
{ element: 121 }
]));
]);
assert.deepEqual(toArray(list), [[0], [10], [11], [12], [120], [121], [1], [2]]);
assert.equal(model.size, 8);
model.setChildren(0, Iterator.empty());
model.setChildren(0);
assert.deepEqual(toArray(list), [[0], [1], [2]]);
assert.equal(model.size, 3);
model.setChildren(null, Iterator.empty());
model.setChildren(null);
assert.deepEqual(toArray(list), []);
assert.equal(model.size, 0);
});
@@ -378,50 +378,50 @@ suite('CompressedObjectTree', function () {
const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
const model = new CompressedObjectTreeModel<number>('test', toSpliceable(list));
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{
element: 1, children: Iterator.fromArray([{
element: 11, children: Iterator.fromArray([{
element: 111, children: Iterator.fromArray([
element: 1, children: [{
element: 11, children: [{
element: 111, children: [
{ element: 1111 },
{ element: 1112 },
{ element: 1113 },
])
}])
}])
]
}]
}]
}
]));
]);
assert.deepEqual(toArray(list), [[1, 11, 111], [1111], [1112], [1113]]);
assert.equal(model.size, 6);
model.setChildren(11, Iterator.fromArray([
model.setChildren(11, [
{ element: 111 },
{ element: 112 },
{ element: 113 },
]));
]);
assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113]]);
assert.equal(model.size, 5);
model.setChildren(113, Iterator.fromArray([
model.setChildren(113, [
{ element: 1131 }
]));
]);
assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131]]);
assert.equal(model.size, 6);
model.setChildren(1131, Iterator.fromArray([
model.setChildren(1131, [
{ element: 1132 }
]));
]);
assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131, 1132]]);
assert.equal(model.size, 7);
model.setChildren(1131, Iterator.fromArray([
model.setChildren(1131, [
{ element: 1132 },
{ element: 1133 },
]));
]);
assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131], [1132], [1133]]);
assert.equal(model.size, 8);
src/vs/base/test/browser/ui/tree/indexTreeModel.test.ts
+60 -61
View File
@@ -6,7 +6,6 @@
import * as assert from 'assert';
import { ITreeNode, ITreeFilter, TreeVisibility } from 'vs/base/browser/ui/tree/tree';
import { ISpliceable } from 'vs/base/common/sequence';
import { Iterator } from 'vs/base/common/iterator';
import { IndexTreeModel, IIndexTreeNode } from 'vs/base/browser/ui/tree/indexTreeModel';
function toSpliceable<T>(arr: T[]): ISpliceable<T> {
@@ -34,11 +33,11 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{ element: 0 },
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 3);
assert.deepEqual(list[0].element, 0);
@@ -56,17 +55,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 6);
assert.deepEqual(list[0].element, 0);
@@ -93,17 +92,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, collapsed: true, children: Iterator.fromArray([
element: 0, collapsed: true, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 3);
assert.deepEqual(list[0].element, 0);
@@ -121,11 +120,11 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{ element: 0 },
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 3);
@@ -146,17 +145,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 6);
@@ -180,17 +179,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 6);
@@ -208,17 +207,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, collapsed: true, children: Iterator.fromArray([
element: 0, collapsed: true, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 3);
@@ -233,17 +232,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 6);
@@ -264,17 +263,17 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, collapsed: true, children: Iterator.fromArray([
element: 0, collapsed: true, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(list.length, 3);
@@ -304,7 +303,7 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 1, children: [
{
@@ -319,7 +318,7 @@ suite('IndexTreeModel', function () {
{ element: 21 }
]
}
]));
]);
assert.deepEqual(list.length, 5);
assert.deepEqual(toArray(list), [1, 11, 111, 2, 21]);
@@ -337,13 +336,13 @@ suite('IndexTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 }
])
]
}
]));
]);
assert.deepEqual(list.length, 2);
@@ -406,7 +405,7 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1, { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: [
{ element: 1 },
@@ -418,7 +417,7 @@ suite('IndexTreeModel', function () {
{ element: 7 }
]
}
]));
]);
assert.deepEqual(list.length, 4);
assert.deepEqual(toArray(list), [0, 2, 4, 6]);
@@ -440,14 +439,14 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1, { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: [
{ element: 1 },
{ element: 2 }
]
}
]));
]);
assert.deepEqual(toArray(list), []);
});
@@ -463,7 +462,7 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1, { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: [
{ element: 1 },
@@ -475,7 +474,7 @@ suite('IndexTreeModel', function () {
{ element: 7 }
]
},
]));
]);
assert.deepEqual(toArray(list), [0, 1, 2, 3, 4, 5, 6, 7]);
@@ -502,7 +501,7 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<string>('test', toSpliceable(list), 'root', { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 'vscode', children: [
{ element: '.build' },
@@ -522,7 +521,7 @@ suite('IndexTreeModel', function () {
}
]
},
]));
]);
assert.deepEqual(list.length, 10);
@@ -548,7 +547,7 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<string>('test', toSpliceable(list), 'root', { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 'vscode', children: [
{ element: '.build' },
@@ -568,7 +567,7 @@ suite('IndexTreeModel', function () {
}
]
},
]));
]);
assert.deepEqual(list.length, 10);
@@ -594,7 +593,7 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<string>('test', toSpliceable(list), 'root', { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 'vscode', collapsed: true, children: [
{ element: '.build' },
@@ -614,7 +613,7 @@ suite('IndexTreeModel', function () {
}
]
},
]));
]);
assert.deepEqual(toArray(list), ['vscode']);
@@ -642,17 +641,17 @@ suite('IndexTreeModel', function () {
const list: IIndexTreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(model.getNodeLocation(list[0]), [0]);
assert.deepEqual(model.getNodeLocation(list[1]), [0, 0]);
@@ -672,7 +671,7 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<number>('test', toSpliceable(list), -1, { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{
element: 0, children: [
{ element: 1 },
@@ -684,7 +683,7 @@ suite('IndexTreeModel', function () {
{ element: 7 }
]
}
]));
]);
assert.deepEqual(model.getNodeLocation(list[0]), [0]);
assert.deepEqual(model.getNodeLocation(list[1]), [0, 1]);
@@ -704,11 +703,11 @@ suite('IndexTreeModel', function () {
const model = new IndexTreeModel<string>('test', toSpliceable(list), 'root', { filter });
model.splice([0], 0, Iterator.fromArray([
model.splice([0], 0, [
{ element: 'silver' },
{ element: 'gold' },
{ element: 'platinum' }
]));
]);
assert.deepEqual(toArray(list), ['silver', 'gold', 'platinum']);
@@ -716,11 +715,11 @@ suite('IndexTreeModel', function () {
model.refilter();
assert.deepEqual(toArray(list), ['platinum']);
model.splice([0], Number.POSITIVE_INFINITY, Iterator.fromArray([
model.splice([0], Number.POSITIVE_INFINITY, [
{ element: 'silver' },
{ element: 'gold' },
{ element: 'platinum' }
]));
]);
assert.deepEqual(toArray(list), ['platinum']);
model.refilter();
src/vs/base/test/browser/ui/tree/objectTree.test.ts
+40 -41
View File
@@ -7,7 +7,6 @@ import * as assert from 'assert';
import { ITreeNode, ITreeRenderer } from 'vs/base/browser/ui/tree/tree';
import { IListVirtualDelegate, IIdentityProvider } from 'vs/base/browser/ui/list/list';
import { ObjectTree, CompressibleObjectTree, ICompressibleTreeRenderer } from 'vs/base/browser/ui/tree/objectTree';
import { Iterator } from 'vs/base/common/iterator';
import { ICompressedTreeNode } from 'vs/base/browser/ui/tree/compressedObjectTreeModel';
suite('ObjectTree', function () {
@@ -46,17 +45,17 @@ suite('ObjectTree', function () {
});
test('should be able to navigate', () => {
tree.setChildren(null, Iterator.fromArray([
tree.setChildren(null, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
const navigator = tree.navigate();
@@ -87,17 +86,17 @@ suite('ObjectTree', function () {
});
test('should skip collapsed nodes', () => {
tree.setChildren(null, Iterator.fromArray([
tree.setChildren(null, [
{
element: 0, collapsed: true, children: Iterator.fromArray([
element: 0, collapsed: true, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
const navigator = tree.navigate();
@@ -118,17 +117,17 @@ suite('ObjectTree', function () {
test('should skip filtered elements', () => {
filter = el => el % 2 === 0;
tree.setChildren(null, Iterator.fromArray([
tree.setChildren(null, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
const navigator = tree.navigate();
@@ -150,17 +149,17 @@ suite('ObjectTree', function () {
});
test('should be able to start from node', () => {
tree.setChildren(null, Iterator.fromArray([
tree.setChildren(null, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
const navigator = tree.navigate(1);
@@ -291,50 +290,50 @@ suite('CompressibleObjectTree', function () {
const tree = new CompressibleObjectTree<number>('test', container, new Delegate(), [new Renderer()]);
tree.layout(200);
tree.setChildren(null, Iterator.fromArray([
tree.setChildren(null, [
{
element: 1, children: Iterator.fromArray([{
element: 11, children: Iterator.fromArray([{
element: 111, children: Iterator.fromArray([
element: 1, children: [{
element: 11, children: [{
element: 111, children: [
{ element: 1111 },
{ element: 1112 },
{ element: 1113 },
])
}])
}])
]
}]
}]
}
]));
]);
let rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
assert.deepEqual(rows, ['1/11/111', '1111', '1112', '1113']);
tree.setChildren(11, Iterator.fromArray([
tree.setChildren(11, [
{ element: 111 },
{ element: 112 },
{ element: 113 },
]));
]);
rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
assert.deepEqual(rows, ['1/11', '111', '112', '113']);
tree.setChildren(113, Iterator.fromArray([
tree.setChildren(113, [
{ element: 1131 }
]));
]);
rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
assert.deepEqual(rows, ['1/11', '111', '112', '113/1131']);
tree.setChildren(1131, Iterator.fromArray([
tree.setChildren(1131, [
{ element: 1132 }
]));
]);
rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
assert.deepEqual(rows, ['1/11', '111', '112', '113/1131/1132']);
tree.setChildren(1131, Iterator.fromArray([
tree.setChildren(1131, [
{ element: 1132 },
{ element: 1133 },
]));
]);
rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
assert.deepEqual(rows, ['1/11', '111', '112', '113/1131', '1132', '1133']);
@@ -348,19 +347,19 @@ suite('CompressibleObjectTree', function () {
const tree = new CompressibleObjectTree<number>('test', container, new Delegate(), [new Renderer()]);
tree.layout(200);
tree.setChildren(null, Iterator.fromArray([
tree.setChildren(null, [
{
element: 1, children: Iterator.fromArray([{
element: 11, children: Iterator.fromArray([{
element: 111, children: Iterator.fromArray([
element: 1, children: [{
element: 11, children: [{
element: 111, children: [
{ element: 1111 },
{ element: 1112 },
{ element: 1113 },
])
}])
}])
]
}]
}]
}
]));
]);
let rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
assert.deepEqual(rows, ['1/11/111', '1111', '1112', '1113']);
src/vs/base/test/browser/ui/tree/objectTreeModel.test.ts
+17 -18
View File
@@ -7,7 +7,6 @@ import * as assert from 'assert';
import { ITreeNode } from 'vs/base/browser/ui/tree/tree';
import { ISpliceable } from 'vs/base/common/sequence';
import { ObjectTreeModel } from 'vs/base/browser/ui/tree/objectTreeModel';
import { Iterator } from 'vs/base/common/iterator';
function toSpliceable<T>(arr: T[]): ISpliceable<T> {
return {
@@ -35,25 +34,25 @@ suite('ObjectTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new ObjectTreeModel<number>('test', toSpliceable(list));
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{ element: 0 },
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(toArray(list), [0, 1, 2]);
assert.equal(model.size, 3);
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{ element: 3 },
{ element: 4 },
{ element: 5 },
]));
]);
assert.deepEqual(toArray(list), [3, 4, 5]);
assert.equal(model.size, 3);
model.setChildren(null, Iterator.empty());
model.setChildren(null);
assert.deepEqual(toArray(list), []);
assert.equal(model.size, 0);
});
@@ -62,34 +61,34 @@ suite('ObjectTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new ObjectTreeModel<number>('test', toSpliceable(list));
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{
element: 0, children: Iterator.fromArray([
element: 0, children: [
{ element: 10 },
{ element: 11 },
{ element: 12 },
])
]
},
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(toArray(list), [0, 10, 11, 12, 1, 2]);
assert.equal(model.size, 6);
model.setChildren(12, Iterator.fromArray([
model.setChildren(12, [
{ element: 120 },
{ element: 121 }
]));
]);
assert.deepEqual(toArray(list), [0, 10, 11, 12, 120, 121, 1, 2]);
assert.equal(model.size, 8);
model.setChildren(0, Iterator.empty());
model.setChildren(0);
assert.deepEqual(toArray(list), [0, 1, 2]);
assert.equal(model.size, 3);
model.setChildren(null, Iterator.empty());
model.setChildren(null);
assert.deepEqual(toArray(list), []);
assert.equal(model.size, 0);
});
@@ -98,16 +97,16 @@ suite('ObjectTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new ObjectTreeModel<number>('test', toSpliceable(list));
model.setChildren(null, Iterator.fromArray([
model.setChildren(null, [
{ element: 0, collapsed: true }
]));
]);
assert.deepEqual(toArray(list), [0]);
model.setChildren(0, Iterator.fromArray([
model.setChildren(0, [
{ element: 1 },
{ element: 2 }
]));
]);
assert.deepEqual(toArray(list), [0]);
src/vs/base/test/common/iterator.test.ts
+1 -13
View File
@@ -4,19 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { Iterator, Iterable } from 'vs/base/common/iterator';
suite('Iterator', () => {
test('concat', () => {
const first = Iterator.fromArray([1, 2, 3]);
const second = Iterator.fromArray([4, 5, 6]);
const third = Iterator.fromArray([7, 8, 9]);
const actualIterator = Iterator.concat(first, second, third);
const actual = Iterator.collect(actualIterator);
assert.deepEqual(actual, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
});
});
import { Iterable } from 'vs/base/common/iterator';
suite('Iterable', function () {
src/vs/workbench/contrib/markers/browser/markersView.ts
+6 -9
View File
@@ -23,7 +23,7 @@ import { IMarkersWorkbenchService } from 'vs/workbench/contrib/markers/browser/m
import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
import { localize } from 'vs/nls';
import { IContextKey, IContextKeyService, ContextKeyEqualsExpr, ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
import { Iterator } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
import { ITreeElement, ITreeNode, ITreeContextMenuEvent, ITreeRenderer } from 'vs/base/browser/ui/tree/tree';
import { Relay, Event, Emitter } from 'vs/base/common/event';
import { WorkbenchObjectTree, ResourceNavigator, IListService, IWorkbenchObjectTreeOptions } from 'vs/platform/list/browser/listService';
@@ -50,16 +50,13 @@ import { ViewPane, IViewPaneOptions } from 'vs/workbench/browser/parts/views/vie
import { IViewDescriptorService } from 'vs/workbench/common/views';
import { IOpenerService } from 'vs/platform/opener/common/opener';
function createResourceMarkersIterator(resourceMarkers: ResourceMarkers): Iterator<ITreeElement<TreeElement>> {
const markersIt = Iterator.fromArray(resourceMarkers.markers);
return Iterator.map(markersIt, m => {
const relatedInformationIt = Iterator.from(m.relatedInformation);
const children = Iterator.map(relatedInformationIt, r => ({ element: r }));
function createResourceMarkersIterator(resourceMarkers: ResourceMarkers): Iterable<ITreeElement<TreeElement>> {
return Iterable.map(resourceMarkers.markers, m => {
const relatedInformationIt = Iterable.from(m.relatedInformation);
const children = Iterable.map(relatedInformationIt, r => ({ element: r }));
return { element: m, children };
});
}
export class MarkersView extends ViewPane implements IMarkerFilterController {
@@ -338,7 +335,7 @@ export class MarkersView extends ViewPane implements IMarkerFilterController {
} else {
resourceMarkers = this.markersWorkbenchService.markersModel.resourceMarkers;
}
this.tree.setChildren(null, Iterator.map(Iterator.fromArray(resourceMarkers), m => ({ element: m, children: createResourceMarkersIterator(m) })));
this.tree.setChildren(null, Iterable.map(resourceMarkers, m => ({ element: m, children: createResourceMarkersIterator(m) })));
}
private updateFilter() {
src/vs/workbench/contrib/preferences/browser/settingsEditor2.ts
+3 -5
View File
@@ -14,7 +14,7 @@ import { Delayer, ThrottledDelayer, timeout, IntervalTimer } from 'vs/base/commo
import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
import * as collections from 'vs/base/common/collections';
import { getErrorMessage, isPromiseCanceledError } from 'vs/base/common/errors';
import { Iterator } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
import { KeyCode } from 'vs/base/common/keyCodes';
import { Disposable } from 'vs/base/common/lifecycle';
import * as platform from 'vs/base/common/platform';
@@ -55,10 +55,8 @@ import { SettingsEditor2Input } from 'vs/workbench/services/preferences/common/p
import { Settings2EditorModel } from 'vs/workbench/services/preferences/common/preferencesModels';
import { fromNow } from 'vs/base/common/date';
function createGroupIterator(group: SettingsTreeGroupElement): Iterator<ITreeElement<SettingsTreeGroupChild>> {
const groupsIt = Iterator.fromArray(group.children);
return Iterator.map(groupsIt, g => {
function createGroupIterator(group: SettingsTreeGroupElement): Iterable<ITreeElement<SettingsTreeGroupChild>> {
return Iterable.map(group.children, g => {
return {
element: g,
children: g instanceof SettingsTreeGroupElement ?
src/vs/workbench/contrib/preferences/browser/tocTree.ts
+3 -4
View File
@@ -8,7 +8,7 @@ import { IListVirtualDelegate } from 'vs/base/browser/ui/list/list';
import { DefaultStyleController, IAccessibilityProvider } from 'vs/base/browser/ui/list/listWidget';
import { IObjectTreeOptions, ObjectTree } from 'vs/base/browser/ui/tree/objectTree';
import { ITreeElement, ITreeNode, ITreeRenderer } from 'vs/base/browser/ui/tree/tree';
import { Iterator } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
import { editorBackground, transparent, foreground } from 'vs/platform/theme/common/colorRegistry';
import { attachStyler } from 'vs/platform/theme/common/styler';
@@ -138,11 +138,10 @@ class TOCTreeDelegate implements IListVirtualDelegate<SettingsTreeElement> {
}
}
export function createTOCIterator(model: TOCTreeModel | SettingsTreeGroupElement, tree: TOCTree): Iterator<ITreeElement<SettingsTreeGroupElement>> {
export function createTOCIterator(model: TOCTreeModel | SettingsTreeGroupElement, tree: TOCTree): Iterable<ITreeElement<SettingsTreeGroupElement>> {
const groupChildren = <SettingsTreeGroupElement[]>model.children.filter(c => c instanceof SettingsTreeGroupElement);
const groupsIt = Iterator.fromArray(groupChildren);
return Iterator.map(groupsIt, g => {
return Iterable.map(groupChildren, g => {
const hasGroupChildren = g.children.some(c => c instanceof SettingsTreeGroupElement);
return {
src/vs/workbench/contrib/scm/browser/repositoryPane.ts
+4 -4
View File
@@ -35,7 +35,7 @@ import { ITreeNode, ITreeFilter, ITreeSorter, ITreeContextMenuEvent } from 'vs/b
import { ResourceTree, IResourceNode } from 'vs/base/common/resourceTree';
import { ISequence, ISplice } from 'vs/base/common/sequence';
import { ICompressibleTreeRenderer, ICompressibleKeyboardNavigationLabelProvider } from 'vs/base/browser/ui/tree/objectTree';
import { Iterator } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
import { ICompressedTreeNode, ICompressedTreeElement } from 'vs/base/browser/ui/tree/compressedObjectTreeModel';
import { URI } from 'vs/base/common/uri';
import { FileKind } from 'vs/platform/files/common/files';
@@ -397,8 +397,8 @@ interface IGroupItem {
function groupItemAsTreeElement(item: IGroupItem, mode: ViewModelMode): ICompressedTreeElement<TreeElement> {
const children = mode === ViewModelMode.List
? Iterator.map(Iterator.fromArray(item.resources), element => ({ element, incompressible: true }))
: Iterator.map(item.tree.root.children, node => asTreeElement(node, true));
? Iterable.map(item.resources, element => ({ element, incompressible: true }))
: Iterable.map(item.tree.root.children, node => asTreeElement(node, true));
return { element: item.group, children, incompressible: true, collapsible: true };
}
@@ -406,7 +406,7 @@ function groupItemAsTreeElement(item: IGroupItem, mode: ViewModelMode): ICompres
function asTreeElement(node: IResourceNode<ISCMResource, ISCMResourceGroup>, forceIncompressible: boolean): ICompressedTreeElement<TreeElement> {
return {
element: (node.childrenCount === 0 && node.element) ? node.element : node,
children: Iterator.map(node.children, node => asTreeElement(node, false)),
children: Iterable.map(node.children, node => asTreeElement(node, false)),
incompressible: !!node.element || forceIncompressible
};
}
src/vs/workbench/contrib/search/browser/searchView.ts
+10 -15
View File
@@ -13,7 +13,7 @@ import { IAction, ActionRunner } from 'vs/base/common/actions';
import { Delayer } from 'vs/base/common/async';
import * as errors from 'vs/base/common/errors';
import { Event } from 'vs/base/common/event';
import { Iterator } from 'vs/base/common/iterator';
import { Iterable } from 'vs/base/common/iterator';
import { KeyCode, KeyMod } from 'vs/base/common/keyCodes';
import { dispose, IDisposable } from 'vs/base/common/lifecycle';
import * as env from 'vs/base/common/platform';
@@ -533,7 +533,7 @@ export class SearchView extends ViewPane {
}
}
private createResultIterator(collapseResults: ISearchConfigurationProperties['collapseResults']): Iterator<ITreeElement<RenderableMatch>> {
private createResultIterator(collapseResults: ISearchConfigurationProperties['collapseResults']): Iterable<ITreeElement<RenderableMatch>> {
const folderMatches = this.searchResult.folderMatches()
.filter(fm => !fm.isEmpty())
.sort(searchMatchComparer);
@@ -542,20 +542,17 @@ export class SearchView extends ViewPane {
return this.createFolderIterator(folderMatches[0], collapseResults);
}
const foldersIt = Iterator.fromArray(folderMatches);
return Iterator.map(foldersIt, folderMatch => {
return Iterable.map(folderMatches, folderMatch => {
const children = this.createFolderIterator(folderMatch, collapseResults);
return <ITreeElement<RenderableMatch>>{ element: folderMatch, children };
});
}
private createFolderIterator(folderMatch: FolderMatch, collapseResults: ISearchConfigurationProperties['collapseResults']): Iterator<ITreeElement<RenderableMatch>> {
private createFolderIterator(folderMatch: FolderMatch, collapseResults: ISearchConfigurationProperties['collapseResults']): Iterable<ITreeElement<RenderableMatch>> {
const sortOrder = this.searchConfig.sortOrder;
const filesIt = Iterator.fromArray(
folderMatch.matches()
.sort((a, b) => searchMatchComparer(a, b, sortOrder)));
const matches = folderMatch.matches().sort((a, b) => searchMatchComparer(a, b, sortOrder));
return Iterator.map(filesIt, fileMatch => {
return Iterable.map(matches, fileMatch => {
const children = this.createFileIterator(fileMatch);
let nodeExists = true;
@@ -568,14 +565,12 @@ export class SearchView extends ViewPane {
});
}
private createFileIterator(fileMatch: FileMatch): Iterator<ITreeElement<RenderableMatch>> {
const matchesIt = Iterator.from(
fileMatch.matches()
.sort(searchMatchComparer));
return Iterator.map(matchesIt, r => (<ITreeElement<RenderableMatch>>{ element: r }));
private createFileIterator(fileMatch: FileMatch): Iterable<ITreeElement<RenderableMatch>> {
const matches = fileMatch.matches().sort(searchMatchComparer);
return Iterable.map(matches, r => (<ITreeElement<RenderableMatch>>{ element: r }));
}
private createIterator(match: FolderMatch | FileMatch | SearchResult, collapseResults: ISearchConfigurationProperties['collapseResults']): Iterator<ITreeElement<RenderableMatch>> {
private createIterator(match: FolderMatch | FileMatch | SearchResult, collapseResults: ISearchConfigurationProperties['collapseResults']): Iterable<ITreeElement<RenderableMatch>> {
return match instanceof SearchResult ? this.createResultIterator(collapseResults) :
match instanceof FolderMatch ? this.createFolderIterator(match, collapseResults) :
this.createFileIterator(match);