2880702687

Build Type

push

github

Committed by Jos Verburg

Commit Message

Improve trace message

Run Details

4772 of 5573 branches covered (85.63%)

Branch coverage included in aggregate %.

9 of 9 new or added lines in 2 files covered. (100.0%)

5 existing lines in 2 files now uncovered.

10215 of 10868 relevant lines covered (93.99%)

33059.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.77

/src/expressions/dataTypes/Sequences/IteratorBackedSequence.ts

import { errFORG0006 } from '../../functions/FunctionOperationErrors';
import { DONE_TOKEN, IIterator, IterationHint, ready } from '../../util/iterators';
import ISequence, { SwitchCasesCases } from '../ISequence';
import isSubtypeOf from '../isSubtypeOf';
import sequenceFactory from '../sequenceFactory';
import Value, { ValueType } from '../Value';
import getEffectiveBooleanValue from './getEffectiveBooleanValue';

export default class IteratorBackedSequence implements ISequence {
        public value: IIterator<Value>;

        private _cacheAllValues: boolean;
        private _cachedValues: Value[];
        private _currentPosition: number;
        private _length: number;

        constructor(
                private readonly _sequenceFactory: typeof sequenceFactory,
                valueIterator: IIterator<Value>,
                predictedLength: number = null
        ) {
                this.value = {
                        next: (hint: IterationHint) => {
                                if (this._length !== null && this._currentPosition >= this._length) {
                                        return DONE_TOKEN;
                                }
                                if (this._cachedValues[this._currentPosition] !== undefined) {
                                        return ready(this._cachedValues[this._currentPosition++]);
                                }
                                const value = valueIterator.next(hint);
                                if (value.done) {
                                        const length = this._currentPosition;
                                        this._length = length;
                                        return value;
                                }
                                if (this._cacheAllValues || this._currentPosition < 2) {
                                        this._cachedValues[this._currentPosition] = value.value;
                                }
                                this._currentPosition++;
                                return value;
                        },
                };

                this._cacheAllValues = false;
                this._cachedValues = [];
                this._currentPosition = 0;
                this._length = predictedLength;
        }

        public expandSequence(): ISequence {
                return this._sequenceFactory.create(this.getAllValues());
        }

        public filter(callback: (value: Value, i: number, sequence: ISequence) => boolean): ISequence {
                let i = -1;
                const iterator = this.value;

                return this._sequenceFactory.create({
                        next: (hint: IterationHint) => {
                                i++;
                                let value = iterator.next(hint);
                                while (!value.done) {
                                        if (callback(value.value, i, this)) {
                                                return value;
                                        }

                                        i++;
                                        value = iterator.next(IterationHint.NONE);
                                }
                                return value;
                        },
                });
        }

        public first(): Value | null {
                if (this._cachedValues[0] !== undefined) {
                        return this._cachedValues[0];
                }

                const iterator = this.value;
                // No first cache value, the current position must have been 0
                const firstValue = iterator.next(IterationHint.NONE);

                this.reset();

                if (firstValue.done) {
                        return null;
                }
                return firstValue.value;
        }

        public getAllValues(): Value[] {
                if (
                        this._currentPosition > this._cachedValues.length &&
                        this._length !== this._cachedValues.length
                ) {
                        throw new Error('Implementation error: Sequence Iterator has progressed.');
                }

                const iterator = this.value;
                this._cacheAllValues = true;

                let val = iterator.next(IterationHint.NONE);
                while (!val.done) {
                        val = iterator.next(IterationHint.NONE);
                }

                return this._cachedValues;
        }

        public getEffectiveBooleanValue(): boolean {
                const iterator = this.value;
                const oldPosition = this._currentPosition;

                this.reset();
                const it = iterator.next(IterationHint.NONE);
                if (it.done) {
                        this.reset(oldPosition);
                        return false;
                }
                const firstValue = it.value;

                if (isSubtypeOf(firstValue.type, ValueType.NODE)) {
                        this.reset(oldPosition);
                        return true;
                }

                const secondValue = iterator.next(IterationHint.NONE);
                if (!secondValue.done) {
                        throw errFORG0006(
                                `Cannot determine the effective boolean value of a sequence with a length higher than one.`
                        );
                }

                this.reset(oldPosition);
                return getEffectiveBooleanValue(firstValue);
        }

        public getLength(onlyIfCheap: boolean = false): number {
                if (this._length !== null) {
                        return this._length;
                }

                if (onlyIfCheap) {
                        return -1;
                }

                const oldPosition = this._currentPosition;

                const length = this.getAllValues().length;

                this.reset(oldPosition);
                return length;
        }

        public isEmpty(): boolean {
                if (this._length === 0) {
                        return true;
                }
                const firstValue = this.first();
                return firstValue === null;
        }

        public isSingleton(): boolean {
                if (this._length !== null) {
                        return this._length === 1;
                }

                const iterator = this.value;
                const oldPosition = this._currentPosition;

                // Check there is at least one value
                this.reset();
                const it = iterator.next(IterationHint.NONE);
                if (it.done) {
                        this.reset(oldPosition);
                        return false;
                }

                const secondValue = iterator.next(IterationHint.NONE);
                this.reset(oldPosition);
                return secondValue.done;
        }

        public map(callback: (value: Value, i: number, sequence: ISequence) => Value): ISequence {
                let i = 0;
                const iterator = this.value;
                return this._sequenceFactory.create(
                        {
                                next: (hint: IterationHint) => {
                                        const value = iterator.next(hint);
                                        if (value.done) {
                                                return DONE_TOKEN;
                                        }

                                        return ready(callback(value.value, i++, this));
                                },
                        },
                        this._length
                );
        }

        public mapAll(callback: (allValues: Value[]) => ISequence, hint: IterationHint): ISequence {
                const iterator = this.value;
                let mappedResultsIterator: IIterator<Value>;
                const allResults: Value[] = [];
                let isFirst = true;
                (function processNextResult() {
                        for (
                                let value = iterator.next(isFirst ? IterationHint.NONE : hint);
                                !value.done;
                                value = iterator.next(hint)
                        ) {
                                isFirst = false;
                                allResults.push(value.value);
                        }
                        mappedResultsIterator = callback(allResults).value;
                })();
                return this._sequenceFactory.create({
                        next: (_hint: IterationHint) => {
                                return mappedResultsIterator.next(IterationHint.NONE);
                        },
                });
        }

        public switchCases(cases: SwitchCasesCases): ISequence {
                let resultIterator: IIterator<Value> = null;

                const setResultIterator = (resultSequence: ISequence) => {
                        resultIterator = resultSequence.value;
                        // Try to mirror through length;
                        const resultSequenceLength = resultSequence.getLength(true);
                        if (resultSequenceLength !== -1) {
                                this._length = resultSequenceLength;
                        }
                };

                return this._sequenceFactory.create({
                        next: (hint: IterationHint) => {
                                if (resultIterator) {
                                        return resultIterator.next(hint);
                                }

                                const isEmpty = this.isEmpty();
                                if (isEmpty) {
                                        setResultIterator(cases.empty ? cases.empty(this) : cases.default(this));
                                        return resultIterator.next(hint);
                                }

                                const isSingleton = this.isSingleton();
                                if (isSingleton) {
                                        setResultIterator(
                                                cases.singleton ? cases.singleton(this) : cases.default(this)
                                        );
                                        return resultIterator.next(hint);
                                }

                                setResultIterator(cases.multiple ? cases.multiple(this) : cases.default(this));
                                return resultIterator.next(hint);
                        },
                });
        }

        private reset(to = 0) {
                this._currentPosition = to;
        }
}

1	import { errFORG0006 } from '../../functions/FunctionOperationErrors';	3✔
2	import { DONE_TOKEN, IIterator, IterationHint, ready } from '../../util/iterators';	3✔
3	import ISequence, { SwitchCasesCases } from '../ISequence';
4	import isSubtypeOf from '../isSubtypeOf';	3✔
5	import sequenceFactory from '../sequenceFactory';
6	import Value, { ValueType } from '../Value';
7	import getEffectiveBooleanValue from './getEffectiveBooleanValue';	3✔
8
9	export default class IteratorBackedSequence implements ISequence {	3✔
10	public value: IIterator<Value>;
11
12	private _cacheAllValues: boolean;
13	private _cachedValues: Value[];
14	private _currentPosition: number;
15	private _length: number;
16
17	constructor(
18	private readonly _sequenceFactory: typeof sequenceFactory,	702,635✔
19	valueIterator: IIterator<Value>,
20	predictedLength: number = null	×
21	) {
22	this.value = {	702,635✔
23	next: (hint: IterationHint) => {
24	if (this._length !== null && this._currentPosition >= this._length) {	3,641,614✔
25	return DONE_TOKEN;	25,582✔
26	}
27	if (this._cachedValues[this._currentPosition] !== undefined) {	3,616,032✔
28	return ready(this._cachedValues[this._currentPosition++]);	105,243✔
29	}
30	const value = valueIterator.next(hint);	3,510,789✔
31	if (value.done) {	3,510,388✔
32	const length = this._currentPosition;	617,589✔
33	this._length = length;	617,589✔
34	return value;	617,589✔
35	}
36	if (this._cacheAllValues \|\| this._currentPosition < 2) {	2,892,799✔
37	this._cachedValues[this._currentPosition] = value.value;	1,094,408✔
38	}
39	this._currentPosition++;	2,892,799✔
40	return value;	2,892,799✔
41	},
42	};
43
44	this._cacheAllValues = false;	702,635✔
45	this._cachedValues = [];	702,635✔
46	this._currentPosition = 0;	702,635✔
47	this._length = predictedLength;	702,635✔
48	}
49
50	public expandSequence(): ISequence {
51	return this._sequenceFactory.create(this.getAllValues());	35✔
52	}
53
54	public filter(callback: (value: Value, i: number, sequence: ISequence) => boolean): ISequence {
55	let i = -1;	218,940✔
56	const iterator = this.value;	218,940✔
57
58	return this._sequenceFactory.create({	218,940✔
59	next: (hint: IterationHint) => {
60	i++;	986,546✔
61	let value = iterator.next(hint);	986,546✔
62	while (!value.done) {	986,546✔
63	if (callback(value.value, i, this)) {	777,769✔
64	return value;	774,947✔
65	}
66
67	i++;	2,822✔
68	value = iterator.next(IterationHint.NONE);	2,822✔
69	}
70	return value;	211,599✔
71	},
72	});
73	}
74
75	public first(): Value \| null {
76	if (this._cachedValues[0] !== undefined) {	105,369✔
77	return this._cachedValues[0];	6,261✔
78	}
79
80	const iterator = this.value;	99,108✔
81	// No first cache value, the current position must have been 0
82	const firstValue = iterator.next(IterationHint.NONE);	99,108✔
83
84	this.reset();	99,088✔
85
86	if (firstValue.done) {	99,088✔
87	return null;	2,564✔
88	}
89	return firstValue.value;	96,524✔
90	}
91
92	public getAllValues(): Value[] {
93	if (	10,023!
94	this._currentPosition > this._cachedValues.length &&	10,023!
95	this._length !== this._cachedValues.length
96	) {
97	throw new Error('Implementation error: Sequence Iterator has progressed.');	×
98	}
99
100	const iterator = this.value;	10,023✔
101	this._cacheAllValues = true;	10,023✔
102
103	let val = iterator.next(IterationHint.NONE);	10,023✔
104	while (!val.done) {	9,800✔
105	val = iterator.next(IterationHint.NONE);	448,715✔
106	}
107
108	return this._cachedValues;	9,800✔
109	}
110
111	public getEffectiveBooleanValue(): boolean {
112	const iterator = this.value;	10,780✔
113	const oldPosition = this._currentPosition;	10,780✔
114
115	this.reset();	10,780✔
116	const it = iterator.next(IterationHint.NONE);	10,780✔
117	if (it.done) {	10,753✔
118	this.reset(oldPosition);	2,274✔
119	return false;	2,274✔
120	}
121	const firstValue = it.value;	8,479✔
122
123	if (isSubtypeOf(firstValue.type, ValueType.NODE)) {	8,479✔
124	this.reset(oldPosition);	2,808✔
125	return true;	2,808✔
126	}
127
128	const secondValue = iterator.next(IterationHint.NONE);	5,671✔
129	if (!secondValue.done) {	5,671✔
130	throw errFORG0006(	4✔
131	`Cannot determine the effective boolean value of a sequence with a length higher than one.`
132	);
133	}
134
135	this.reset(oldPosition);	5,667✔
136	return getEffectiveBooleanValue(firstValue);	5,667✔
137	}
138
139	public getLength(onlyIfCheap: boolean = false): number {	296✔
140	if (this._length !== null) {	49,910✔
141	return this._length;	41,981✔
142	}
143
144	if (onlyIfCheap) {	7,929✔
145	return -1;	7,682✔
146	}
147
148	const oldPosition = this._currentPosition;	247✔
149
150	const length = this.getAllValues().length;	247✔
151
152	this.reset(oldPosition);	247✔
153	return length;	247✔
154	}
155
156	public isEmpty(): boolean {
157	if (this._length === 0) {	59,071✔
158	return true;	1✔
159	}
160	const firstValue = this.first();	59,070✔
161	return firstValue === null;	59,060✔
162	}
163
164	public isSingleton(): boolean {
165	if (this._length !== null) {	52,590✔
166	return this._length === 1;	63✔
167	}
168
169	const iterator = this.value;	52,527✔
170	const oldPosition = this._currentPosition;	52,527✔
171
172	// Check there is at least one value
173	this.reset();	52,527✔
174	const it = iterator.next(IterationHint.NONE);	52,527✔
175	if (it.done) {	52,527!
UNCOV 176	this.reset(oldPosition);	×
UNCOV 177	return false;	×
178	}
179
180	const secondValue = iterator.next(IterationHint.NONE);	52,527✔
181	this.reset(oldPosition);	52,527✔
182	return secondValue.done;	52,527✔
183	}
184
185	public map(callback: (value: Value, i: number, sequence: ISequence) => Value): ISequence {
186	let i = 0;	22,619✔
187	const iterator = this.value;	22,619✔
188	return this._sequenceFactory.create(	22,619✔
189	{
190	next: (hint: IterationHint) => {
191	const value = iterator.next(hint);	363,475✔
192	if (value.done) {	363,466✔
193	return DONE_TOKEN;	5,891✔
194	}
195
196	return ready(callback(value.value, i++, this));	357,575✔
197	},
198	},
199	this._length
200	);
201	}
202
203	public mapAll(callback: (allValues: Value[]) => ISequence, hint: IterationHint): ISequence {
204	const iterator = this.value;	42,603✔
205	let mappedResultsIterator: IIterator<Value>;
206	const allResults: Value[] = [];	42,603✔
207	let isFirst = true;	42,603✔
208	(function processNextResult() {	42,603✔
209	for (	42,603✔
210	let value = iterator.next(isFirst ? IterationHint.NONE : hint);	42,603!
211	!value.done;
212	value = iterator.next(hint)
213	) {
214	isFirst = false;	41,146✔
215	allResults.push(value.value);	41,146✔
216	}
217	mappedResultsIterator = callback(allResults).value;	42,602✔
218	})();
219	return this._sequenceFactory.create({	42,588✔
220	next: (_hint: IterationHint) => {
221	return mappedResultsIterator.next(IterationHint.NONE);	70,917✔
222	},
223	});
224	}
225
226	public switchCases(cases: SwitchCasesCases): ISequence {
227	let resultIterator: IIterator<Value> = null;	56,194✔
228
229	const setResultIterator = (resultSequence: ISequence) => {	56,194✔
230	resultIterator = resultSequence.value;	54,676✔
231	// Try to mirror through length;
232	const resultSequenceLength = resultSequence.getLength(true);	54,676✔
233	if (resultSequenceLength !== -1) {	54,676✔
234	this._length = resultSequenceLength;	47,008✔
235	}
236	};
237
238	return this._sequenceFactory.create({	56,194✔
239	next: (hint: IterationHint) => {
240	if (resultIterator) {	83,362✔
241	return resultIterator.next(hint);	28,617✔
242	}
243
244	const isEmpty = this.isEmpty();	54,745✔
245	if (isEmpty) {	54,735✔
246	setResultIterator(cases.empty ? cases.empty(this) : cases.default(this));	2,472✔
247	return resultIterator.next(hint);	2,465✔
248	}
249
250	const isSingleton = this.isSingleton();	52,263✔
251	if (isSingleton) {	52,263✔
252	setResultIterator(	52,215✔
253	cases.singleton ? cases.singleton(this) : cases.default(this)	52,215✔
254	);
255	return resultIterator.next(hint);	52,180✔
256	}
257
258	setResultIterator(cases.multiple ? cases.multiple(this) : cases.default(this));	48✔
259	return resultIterator.next(hint);	31✔
260	},
261	});
262	}
263
264	private reset(to = 0) {	162,395✔
265	this._currentPosition = to;	225,918✔
266	}
267	}

FontoXML / fontoxpath / 2880702687

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous