Skip to content

Commit 382cb34

Browse files
joaomorenojoaomoreno
committed
adopt native iterators in trees
1 parent 37402c1 commit 382cb34

19 files changed

Lines changed: 268 additions & 247 deletions

‎src/vs/base/browser/ui/tree/asyncDataTree.ts‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ import { IDisposable, dispose, DisposableStore } from 'vs/base/common/lifecycle'
1111
import { Emitter, Event } from 'vs/base/common/event';
1212
import { timeout, CancelablePromise, createCancelablePromise } from 'vs/base/common/async';
1313
import { IListStyles } from 'vs/base/browser/ui/list/listWidget';
14-
import { Iterator } from 'vs/base/common/iterator';
14+
import { Iterable } from 'vs/base/common/iterator';
1515
import { IDragAndDropData } from 'vs/base/browser/dnd';
1616
import { ElementsDragAndDropData } from 'vs/base/browser/ui/list/listView';
1717
import { isPromiseCanceledError, onUnexpectedError } from 'vs/base/common/errors';
@@ -943,7 +943,7 @@ export class AsyncDataTree<TInput, T, TFilterData = void> implements IDisposable
943943

944944
return {
945945
element: node,
946-
children: node.hasChildren ? Iterator.map(Iterator.fromArray(node.children), child => this.asTreeElement(child, viewStateContext)) : [],
946+
children: node.hasChildren ? Iterable.map(node.children, child => this.asTreeElement(child, viewStateContext)) : [],
947947
collapsible: node.hasChildren,
948948
collapsed
949949
};

‎src/vs/base/browser/ui/tree/compressedObjectTreeModel.ts‎

Lines changed: 19 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -4,14 +4,14 @@
44
*--------------------------------------------------------------------------------------------*/
55

66
import { ISpliceable } from 'vs/base/common/sequence';
7-
import { Iterator, ISequence } from 'vs/base/common/iterator';
7+
import { Iterable } from 'vs/base/common/iterator';
88
import { Event } from 'vs/base/common/event';
99
import { ITreeModel, ITreeNode, ITreeElement, ICollapseStateChangeEvent, ITreeModelSpliceEvent, TreeError, TreeFilterResult, TreeVisibility, WeakMapper } from 'vs/base/browser/ui/tree/tree';
1010
import { IObjectTreeModelOptions, ObjectTreeModel, IObjectTreeModel } from 'vs/base/browser/ui/tree/objectTreeModel';
1111

1212
// Exported only for test reasons, do not use directly
1313
export interface ICompressedTreeElement<T> extends ITreeElement<T> {
14-
readonly children?: ISequence<ICompressedTreeElement<T>>;
14+
readonly children?: Iterable<ICompressedTreeElement<T>>;
1515
readonly incompressible?: boolean;
1616
}
1717

@@ -27,7 +27,7 @@ function noCompress<T>(element: ICompressedTreeElement<T>): ITreeElement<ICompre
2727

2828
return {
2929
element: { elements, incompressible },
30-
children: Iterator.map(Iterator.from(element.children), noCompress),
30+
children: Iterable.map(Iterable.from(element.children), noCompress),
3131
collapsible: element.collapsible,
3232
collapsed: element.collapsed
3333
};
@@ -38,12 +38,11 @@ export function compress<T>(element: ICompressedTreeElement<T>): ITreeElement<IC
3838
const elements = [element.element];
3939
const incompressible = element.incompressible || false;
4040

41-
let childrenIterator: Iterator<ITreeElement<T>>;
41+
let childrenIterator: Iterable<ITreeElement<T>>;
4242
let children: ITreeElement<T>[];
4343

4444
while (true) {
45-
childrenIterator = Iterator.from(element.children);
46-
children = Iterator.collect(childrenIterator, 2);
45+
[children, childrenIterator] = Iterable.consume(Iterable.from(element.children), 2);
4746

4847
if (children.length !== 1) {
4948
break;
@@ -60,19 +59,19 @@ export function compress<T>(element: ICompressedTreeElement<T>): ITreeElement<IC
6059

6160
return {
6261
element: { elements, incompressible },
63-
children: Iterator.map(Iterator.concat(Iterator.fromArray(children), childrenIterator), compress),
62+
children: Iterable.map(Iterable.concat(children, childrenIterator), compress),
6463
collapsible: element.collapsible,
6564
collapsed: element.collapsed
6665
};
6766
}
6867

6968
function _decompress<T>(element: ITreeElement<ICompressedTreeNode<T>>, index = 0): ICompressedTreeElement<T> {
70-
let children: Iterator<ICompressedTreeElement<T>>;
69+
let children: Iterable<ICompressedTreeElement<T>>;
7170

7271
if (index < element.element.elements.length - 1) {
73-
children = Iterator.single(_decompress(element, index + 1));
72+
children = [_decompress(element, index + 1)];
7473
} else {
75-
children = Iterator.map(Iterator.from(element.children), el => _decompress(el, 0));
74+
children = Iterable.map(Iterable.from(element.children), el => _decompress(el, 0));
7675
}
7776

7877
if (index === 0 && element.element.incompressible) {
@@ -98,12 +97,12 @@ export function decompress<T>(element: ITreeElement<ICompressedTreeNode<T>>): IC
9897
return _decompress(element, 0);
9998
}
10099

101-
function splice<T>(treeElement: ICompressedTreeElement<T>, element: T, children: Iterator<ICompressedTreeElement<T>>): ICompressedTreeElement<T> {
100+
function splice<T>(treeElement: ICompressedTreeElement<T>, element: T, children: Iterable<ICompressedTreeElement<T>>): ICompressedTreeElement<T> {
102101
if (treeElement.element === element) {
103102
return { ...treeElement, children };
104103
}
105104

106-
return { ...treeElement, children: Iterator.map(Iterator.from(treeElement.children), e => splice(e, element, children)) };
105+
return { ...treeElement, children: Iterable.map(Iterable.from(treeElement.children), e => splice(e, element, children)) };
107106
}
108107

109108
interface ICompressedObjectTreeModelOptions<T, TFilterData> extends IObjectTreeModelOptions<ICompressedTreeNode<T>, TFilterData> {
@@ -136,10 +135,10 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
136135

137136
setChildren(
138137
element: T | null,
139-
children: ISequence<ICompressedTreeElement<T>> | undefined
138+
children: Iterable<ICompressedTreeElement<T>> = Iterable.empty()
140139
): void {
141140
if (element === null) {
142-
const compressedChildren = Iterator.map(Iterator.from(children), this.enabled ? compress : noCompress);
141+
const compressedChildren = Iterable.map(children, this.enabled ? compress : noCompress);
143142
this._setChildren(null, compressedChildren);
144143
return;
145144
}
@@ -155,7 +154,7 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
155154
const parent = this.model.getNode(compressedParentNode) as ITreeNode<ICompressedTreeNode<T>, TFilterData>;
156155

157156
const decompressedElement = decompress(node);
158-
const splicedElement = splice(decompressedElement, element, Iterator.from(children));
157+
const splicedElement = splice(decompressedElement, element, children);
159158
const recompressedElement = (this.enabled ? compress : noCompress)(splicedElement);
160159

161160
const parentChildren = parent.children
@@ -176,15 +175,15 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
176175
this.enabled = enabled;
177176

178177
const root = this.model.getNode();
179-
const rootChildren = Iterator.from(root.children as ITreeNode<ICompressedTreeNode<T>>[]);
180-
const decompressedRootChildren = Iterator.map(rootChildren, decompress);
181-
const recompressedRootChildren = Iterator.map(decompressedRootChildren, enabled ? compress : noCompress);
178+
const rootChildren = root.children as ITreeNode<ICompressedTreeNode<T>>[];
179+
const decompressedRootChildren = Iterable.map(rootChildren, decompress);
180+
const recompressedRootChildren = Iterable.map(decompressedRootChildren, enabled ? compress : noCompress);
182181
this._setChildren(null, recompressedRootChildren);
183182
}
184183

185184
private _setChildren(
186185
node: ICompressedTreeNode<T> | null,
187-
children: ISequence<ITreeElement<ICompressedTreeNode<T>>> | undefined
186+
children: Iterable<ITreeElement<ICompressedTreeNode<T>>>
188187
): void {
189188
const insertedElements = new Set<T | null>();
190189
const _onDidCreateNode = (node: ITreeNode<ICompressedTreeNode<T>, TFilterData>) => {
@@ -413,7 +412,7 @@ export class CompressibleObjectTreeModel<T extends NonNullable<any>, TFilterData
413412
this.model = new CompressedObjectTreeModel(user, mapList(this.nodeMapper, list), mapOptions(compressedNodeUnwrapper, options));
414413
}
415414

416-
setChildren(element: T | null, children?: ISequence<ICompressedTreeElement<T>>): void {
415+
setChildren(element: T | null, children: Iterable<ICompressedTreeElement<T>> = Iterable.empty()): void {
417416
this.model.setChildren(element, children);
418417
}
419418

‎src/vs/base/browser/ui/tree/dataTree.ts‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ import { ISpliceable } from 'vs/base/common/sequence';
88
import { ITreeNode, ITreeModel, ITreeElement, ITreeRenderer, ITreeSorter, IDataSource, TreeError } from 'vs/base/browser/ui/tree/tree';
99
import { ObjectTreeModel } from 'vs/base/browser/ui/tree/objectTreeModel';
1010
import { IListVirtualDelegate, IIdentityProvider } from 'vs/base/browser/ui/list/list';
11-
import { Iterator } from 'vs/base/common/iterator';
11+
import { Iterable } from 'vs/base/common/iterator';
1212

1313
export interface IDataTreeOptions<T, TFilterData = void> extends IAbstractTreeOptions<T, TFilterData> {
1414
readonly sorter?: ITreeSorter<T>;
@@ -158,9 +158,9 @@ export class DataTree<TInput, T, TFilterData = void> extends AbstractTree<T | nu
158158
this.model.setChildren((element === this.input ? null : element) as T, this.iterate(element, isCollapsed).elements, onDidCreateNode, onDidDeleteNode);
159159
}
160160

161-
private iterate(element: TInput | T, isCollapsed?: (el: T) => boolean | undefined): { elements: Iterator<ITreeElement<T>>, size: number } {
161+
private iterate(element: TInput | T, isCollapsed?: (el: T) => boolean | undefined): { elements: Iterable<ITreeElement<T>>, size: number } {
162162
const children = this.dataSource.getChildren(element);
163-
const elements = Iterator.map<any, ITreeElement<T>>(Iterator.fromArray(children), element => {
163+
const elements = Iterable.map(children, element => {
164164
const { elements: children, size } = this.iterate(element, isCollapsed);
165165
const collapsible = this.dataSource.hasChildren ? this.dataSource.hasChildren(element) : undefined;
166166
const collapsed = size === 0 ? undefined : (isCollapsed && isCollapsed(element));

‎src/vs/base/browser/ui/tree/indexTree.ts‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44
*--------------------------------------------------------------------------------------------*/
55

66
import 'vs/css!./media/tree';
7-
import { Iterator, ISequence } from 'vs/base/common/iterator';
7+
import { Iterable } from 'vs/base/common/iterator';
88
import { AbstractTree, IAbstractTreeOptions } from 'vs/base/browser/ui/tree/abstractTree';
99
import { ISpliceable } from 'vs/base/common/sequence';
1010
import { IndexTreeModel } from 'vs/base/browser/ui/tree/indexTreeModel';
@@ -28,7 +28,7 @@ export class IndexTree<T, TFilterData = void> extends AbstractTree<T, TFilterDat
2828
super(user, container, delegate, renderers, options);
2929
}
3030

31-
splice(location: number[], deleteCount: number, toInsert: ISequence<ITreeElement<T>> = Iterator.empty()): void {
31+
splice(location: number[], deleteCount: number, toInsert: Iterable<ITreeElement<T>> = Iterable.empty()): void {
3232
this.model.splice(location, deleteCount, toInsert);
3333
}
3434

‎src/vs/base/browser/ui/tree/indexTreeModel.ts‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@
66
import { ICollapseStateChangeEvent, ITreeElement, ITreeFilter, ITreeFilterDataResult, ITreeModel, ITreeNode, TreeVisibility, ITreeModelSpliceEvent, TreeError } from 'vs/base/browser/ui/tree/tree';
77
import { tail2 } from 'vs/base/common/arrays';
88
import { Emitter, Event, EventBufferer } from 'vs/base/common/event';
9-
import { ISequence, Iterator } from 'vs/base/common/iterator';
9+
import { Iterable } from 'vs/base/common/iterator';
1010
import { ISpliceable } from 'vs/base/common/sequence';
1111

1212
// Exported for tests
@@ -103,7 +103,7 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
103103
splice(
104104
location: number[],
105105
deleteCount: number,
106-
toInsert?: ISequence<ITreeElement<T>>,
106+
toInsert: Iterable<ITreeElement<T>> = Iterable.empty(),
107107
onDidCreateNode?: (node: ITreeNode<T, TFilterData>) => void,
108108
onDidDeleteNode?: (node: ITreeNode<T, TFilterData>) => void
109109
): void {
@@ -113,7 +113,7 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
113113

114114
const { parentNode, listIndex, revealed, visible } = this.getParentNodeWithListIndex(location);
115115
const treeListElementsToInsert: ITreeNode<T, TFilterData>[] = [];
116-
const nodesToInsertIterator = Iterator.map(Iterator.from(toInsert), el => this.createTreeNode(el, parentNode, parentNode.visible ? TreeVisibility.Visible : TreeVisibility.Hidden, revealed, treeListElementsToInsert, onDidCreateNode));
116+
const nodesToInsertIterator = Iterable.map(toInsert, el => this.createTreeNode(el, parentNode, parentNode.visible ? TreeVisibility.Visible : TreeVisibility.Hidden, revealed, treeListElementsToInsert, onDidCreateNode));
117117

118118
const lastIndex = location[location.length - 1];
119119

@@ -134,14 +134,14 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
134134
let insertedVisibleChildrenCount = 0;
135135
let renderNodeCount = 0;
136136

137-
Iterator.forEach(nodesToInsertIterator, child => {
137+
for (const child of nodesToInsertIterator) {
138138
nodesToInsert.push(child);
139139
renderNodeCount += child.renderNodeCount;
140140

141141
if (child.visible) {
142142
child.visibleChildIndex = visibleChildStartIndex + insertedVisibleChildrenCount++;
143143
}
144-
});
144+
}
145145

146146
const deletedNodes = parentNode.children.splice(lastIndex, deleteCount, ...nodesToInsert);
147147

@@ -365,21 +365,21 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
365365
treeListElements.push(node);
366366
}
367367

368-
const childElements = Iterator.from(treeElement.children);
368+
const childElements = treeElement.children || Iterable.empty();
369369
const childRevealed = revealed && visibility !== TreeVisibility.Hidden && !node.collapsed;
370-
const childNodes = Iterator.map(childElements, el => this.createTreeNode(el, node, visibility, childRevealed, treeListElements, onDidCreateNode));
370+
const childNodes = Iterable.map(childElements, el => this.createTreeNode(el, node, visibility, childRevealed, treeListElements, onDidCreateNode));
371371

372372
let visibleChildrenCount = 0;
373373
let renderNodeCount = 1;
374374

375-
Iterator.forEach(childNodes, child => {
375+
for (const child of childNodes) {
376376
node.children.push(child);
377377
renderNodeCount += child.renderNodeCount;
378378

379379
if (child.visible) {
380380
child.visibleChildIndex = visibleChildrenCount++;
381381
}
382-
});
382+
}
383383

384384
node.collapsible = node.collapsible || node.children.length > 0;
385385
node.visibleChildrenCount = visibleChildrenCount;

‎src/vs/base/browser/ui/tree/objectTree.ts‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33
* Licensed under the MIT License. See License.txt in the project root for license information.
44
*--------------------------------------------------------------------------------------------*/
55

6-
import { ISequence } from 'vs/base/common/iterator';
6+
import { Iterable } from 'vs/base/common/iterator';
77
import { AbstractTree, IAbstractTreeOptions, IAbstractTreeOptionsUpdate } from 'vs/base/browser/ui/tree/abstractTree';
88
import { ISpliceable } from 'vs/base/common/sequence';
99
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
3333
super(user, container, delegate, renderers, options as IObjectTreeOptions<T | null, TFilterData>);
3434
}
3535

36-
setChildren(element: T | null, children?: ISequence<ITreeElement<T>>): void {
36+
setChildren(element: T | null, children: Iterable<ITreeElement<T>> = Iterable.empty()): void {
3737
this.model.setChildren(element, children);
3838
}
3939

@@ -184,7 +184,7 @@ export class CompressibleObjectTree<T extends NonNullable<any>, TFilterData = vo
184184
super(user, container, delegate, compressibleRenderers, asObjectTreeOptions<T, TFilterData>(compressedTreeNodeProvider, options));
185185
}
186186

187-
setChildren(element: T | null, children?: ISequence<ICompressedTreeElement<T>>): void {
187+
setChildren(element: T | null, children: Iterable<ICompressedTreeElement<T>> = Iterable.empty()): void {
188188
this.model.setChildren(element, children);
189189
}
190190

‎src/vs/base/browser/ui/tree/objectTreeModel.ts‎

Lines changed: 11 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44
*--------------------------------------------------------------------------------------------*/
55

66
import { ISpliceable } from 'vs/base/common/sequence';
7-
import { Iterator, ISequence, getSequenceIterator } from 'vs/base/common/iterator';
7+
import { Iterable } from 'vs/base/common/iterator';
88
import { IndexTreeModel, IIndexTreeModelOptions } from 'vs/base/browser/ui/tree/indexTreeModel';
99
import { Event } from 'vs/base/common/event';
1010
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';
1414
export type ITreeNodeCallback<T, TFilterData> = (node: ITreeNode<T, TFilterData>) => void;
1515

1616
export interface IObjectTreeModel<T extends NonNullable<any>, TFilterData extends NonNullable<any> = void> extends ITreeModel<T | null, TFilterData, T | null> {
17-
setChildren(element: T | null, children: ISequence<ITreeElement<T>> | undefined): void;
17+
setChildren(element: T | null, children: Iterable<ITreeElement<T>> | undefined): void;
1818
resort(element?: T | null, recursive?: boolean): void;
1919
}
2020

@@ -62,7 +62,7 @@ export class ObjectTreeModel<T extends NonNullable<any>, TFilterData extends Non
6262

6363
setChildren(
6464
element: T | null,
65-
children: ISequence<ITreeElement<T>> | undefined,
65+
children: Iterable<ITreeElement<T>> = Iterable.empty(),
6666
onDidCreateNode?: ITreeNodeCallback<T, TFilterData>,
6767
onDidDeleteNode?: ITreeNodeCallback<T, TFilterData>
6868
): void {
@@ -72,7 +72,7 @@ export class ObjectTreeModel<T extends NonNullable<any>, TFilterData extends Non
7272

7373
private _setChildren(
7474
location: number[],
75-
children: ISequence<ITreeElement<T>> | undefined,
75+
children: Iterable<ITreeElement<T>> = Iterable.empty(),
7676
onDidCreateNode?: ITreeNodeCallback<T, TFilterData>,
7777
onDidDeleteNode?: ITreeNodeCallback<T, TFilterData>
7878
): void {
@@ -132,14 +132,12 @@ export class ObjectTreeModel<T extends NonNullable<any>, TFilterData extends Non
132132
);
133133
}
134134

135-
private preserveCollapseState(elements: ISequence<ITreeElement<T>> | undefined): ISequence<ITreeElement<T>> {
136-
let iterator = elements ? getSequenceIterator(elements) : Iterator.empty<ITreeElement<T>>();
137-
135+
private preserveCollapseState(elements: Iterable<ITreeElement<T>> = Iterable.empty()): Iterable<ITreeElement<T>> {
138136
if (this.sorter) {
139-
iterator = Iterator.fromArray(mergeSort(Iterator.collect(iterator), this.sorter.compare.bind(this.sorter)));
137+
elements = mergeSort([...elements], this.sorter.compare.bind(this.sorter));
140138
}
141139

142-
return Iterator.map(iterator, treeElement => {
140+
return Iterable.map(elements, treeElement => {
143141
let node = this.nodes.get(treeElement.element);
144142

145143
if (!node && this.identityProvider) {
@@ -182,14 +180,14 @@ export class ObjectTreeModel<T extends NonNullable<any>, TFilterData extends Non
182180
this._setChildren(location, this.resortChildren(node, recursive));
183181
}
184182

185-
private resortChildren(node: ITreeNode<T | null, TFilterData>, recursive: boolean, first = true): ISequence<ITreeElement<T>> {
186-
let childrenNodes = Iterator.fromArray(node.children as ITreeNode<T, TFilterData>[]);
183+
private resortChildren(node: ITreeNode<T | null, TFilterData>, recursive: boolean, first = true): Iterable<ITreeElement<T>> {
184+
let childrenNodes = [...node.children] as ITreeNode<T, TFilterData>[];
187185

188186
if (recursive || first) {
189-
childrenNodes = Iterator.fromArray(Iterator.collect(childrenNodes).sort(this.sorter!.compare.bind(this.sorter)));
187+
childrenNodes = mergeSort(childrenNodes, this.sorter!.compare.bind(this.sorter));
190188
}
191189

192-
return Iterator.map<ITreeNode<T | null, TFilterData>, ITreeElement<T>>(childrenNodes, node => ({
190+
return Iterable.map<ITreeNode<T | null, TFilterData>, ITreeElement<T>>(childrenNodes, node => ({
193191
element: node.element as T,
194192
collapsible: node.collapsible,
195193
collapsed: node.collapsed,

‎src/vs/base/browser/ui/tree/tree.ts‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,6 @@
44
*--------------------------------------------------------------------------------------------*/
55

66
import { Event } from 'vs/base/common/event';
7-
import { Iterator } from 'vs/base/common/iterator';
87
import { IListRenderer, IListDragOverReaction, IListDragAndDrop, ListDragOverEffect } from 'vs/base/browser/ui/list/list';
98
import { IDragAndDropData } from 'vs/base/browser/dnd';
109

@@ -74,7 +73,7 @@ export interface ITreeSorter<T> {
7473

7574
export interface ITreeElement<T> {
7675
readonly element: T;
77-
readonly children?: Iterator<ITreeElement<T>> | ITreeElement<T>[];
76+
readonly children?: Iterable<ITreeElement<T>>;
7877
readonly collapsible?: boolean;
7978
readonly collapsed?: boolean;
8079
}

0 commit comments

Comments
 (0)