2880899497

Build Type

github

Committed by GitHub

Commit Message

Merge 0f24c3cb9 into bb59bc269

Pull Request Pull Request #520: Add fn:format-integer with supported pictures: "A", "a", "I" and "i"

Run Details

4782 of 5584 branches covered (85.64%)

Branch coverage included in aggregate %.

34 of 35 new or added lines in 1 file covered. (97.14%)

5 existing lines in 2 files now uncovered.

10248 of 10902 relevant lines covered (94.0%)

32959.85 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';	12✔
2	import { DONE_TOKEN, IIterator, IterationHint, ready } from '../../util/iterators';	12✔
3	import ISequence, { SwitchCasesCases } from '../ISequence';
4	import isSubtypeOf from '../isSubtypeOf';	12✔
5	import sequenceFactory from '../sequenceFactory';
6	import Value, { ValueType } from '../Value';
7	import getEffectiveBooleanValue from './getEffectiveBooleanValue';	12✔
8
9	export default class IteratorBackedSequence implements ISequence {	12✔
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,	2,810,564✔
19	valueIterator: IIterator<Value>,
20	predictedLength: number = null	×
21	) {
22	this.value = {	2,810,564✔
23	next: (hint: IterationHint) => {
24	if (this._length !== null && this._currentPosition >= this._length) {	14,566,504✔
25	return DONE_TOKEN;	102,328✔
26	}
27	if (this._cachedValues[this._currentPosition] !== undefined) {	14,464,176✔
28	return ready(this._cachedValues[this._currentPosition++]);	420,972✔
29	}
30	const value = valueIterator.next(hint);	14,043,204✔
31	if (value.done) {	14,041,600✔
32	const length = this._currentPosition;	2,470,380✔
33	this._length = length;	2,470,380✔
34	return value;	2,470,380✔
35	}
36	if (this._cacheAllValues \|\| this._currentPosition < 2) {	11,571,220✔
37	this._cachedValues[this._currentPosition] = value.value;	4,377,656✔
38	}
39	this._currentPosition++;	11,571,220✔
40	return value;	11,571,220✔
41	},
42	};
43
44	this._cacheAllValues = false;	2,810,564✔
45	this._cachedValues = [];	2,810,564✔
46	this._currentPosition = 0;	2,810,564✔
47	this._length = predictedLength;	2,810,564✔
48	}
49
50	public expandSequence(): ISequence {
51	return this._sequenceFactory.create(this.getAllValues());	140✔
52	}
53
54	public filter(callback: (value: Value, i: number, sequence: ISequence) => boolean): ISequence {
55	let i = -1;	875,760✔
56	const iterator = this.value;	875,760✔
57
58	return this._sequenceFactory.create({	875,760✔
59	next: (hint: IterationHint) => {
60	i++;	3,946,184✔
61	let value = iterator.next(hint);	3,946,184✔
62	while (!value.done) {	3,946,184✔
63	if (callback(value.value, i, this)) {	3,111,076✔
64	return value;	3,099,788✔
65	}
66
67	i++;	11,288✔
68	value = iterator.next(IterationHint.NONE);	11,288✔
69	}
70	return value;	846,396✔
71	},
72	});
73	}
74
75	public first(): Value \| null {
76	if (this._cachedValues[0] !== undefined) {	421,476✔
77	return this._cachedValues[0];	25,044✔
78	}
79
80	const iterator = this.value;	396,432✔
81	// No first cache value, the current position must have been 0
82	const firstValue = iterator.next(IterationHint.NONE);	396,432✔
83
84	this.reset();	396,352✔
85
86	if (firstValue.done) {	396,352✔
87	return null;	10,256✔
88	}
89	return firstValue.value;	386,096✔
90	}
91
92	public getAllValues(): Value[] {
93	if (	40,116!
94	this._currentPosition > this._cachedValues.length &&	40,116!
95	this._length !== this._cachedValues.length
96	) {
97	throw new Error('Implementation error: Sequence Iterator has progressed.');	×
98	}
99
100	const iterator = this.value;	40,116✔
101	this._cacheAllValues = true;	40,116✔
102
103	let val = iterator.next(IterationHint.NONE);	40,116✔
104	while (!val.done) {	39,224✔
105	val = iterator.next(IterationHint.NONE);	1,794,884✔
106	}
107
108	return this._cachedValues;	39,224✔
109	}
110
111	public getEffectiveBooleanValue(): boolean {
112	const iterator = this.value;	43,120✔
113	const oldPosition = this._currentPosition;	43,120✔
114
115	this.reset();	43,120✔
116	const it = iterator.next(IterationHint.NONE);	43,120✔
117	if (it.done) {	43,012✔
118	this.reset(oldPosition);	9,096✔
119	return false;	9,096✔
120	}
121	const firstValue = it.value;	33,916✔
122
123	if (isSubtypeOf(firstValue.type, ValueType.NODE)) {	33,916✔
124	this.reset(oldPosition);	11,232✔
125	return true;	11,232✔
126	}
127
128	const secondValue = iterator.next(IterationHint.NONE);	22,684✔
129	if (!secondValue.done) {	22,684✔
130	throw errFORG0006(	16✔
131	`Cannot determine the effective boolean value of a sequence with a length higher than one.`
132	);
133	}
134
135	this.reset(oldPosition);	22,668✔
136	return getEffectiveBooleanValue(firstValue);	22,668✔
137	}
138
139	public getLength(onlyIfCheap: boolean = false): number {	1,184✔
140	if (this._length !== null) {	199,640✔
141	return this._length;	167,924✔
142	}
143
144	if (onlyIfCheap) {	31,716✔
145	return -1;	30,728✔
146	}
147
148	const oldPosition = this._currentPosition;	988✔
149
150	const length = this.getAllValues().length;	988✔
151
152	this.reset(oldPosition);	988✔
153	return length;	988✔
154	}
155
156	public isEmpty(): boolean {
157	if (this._length === 0) {	236,284✔
158	return true;	4✔
159	}
160	const firstValue = this.first();	236,280✔
161	return firstValue === null;	236,240✔
162	}
163
164	public isSingleton(): boolean {
165	if (this._length !== null) {	210,360✔
166	return this._length === 1;	252✔
167	}
168
169	const iterator = this.value;	210,108✔
170	const oldPosition = this._currentPosition;	210,108✔
171
172	// Check there is at least one value
173	this.reset();	210,108✔
174	const it = iterator.next(IterationHint.NONE);	210,108✔
175	if (it.done) {	210,108!
UNCOV 176	this.reset(oldPosition);	×
UNCOV 177	return false;	×
178	}
179
180	const secondValue = iterator.next(IterationHint.NONE);	210,108✔
181	this.reset(oldPosition);	210,108✔
182	return secondValue.done;	210,108✔
183	}
184
185	public map(callback: (value: Value, i: number, sequence: ISequence) => Value): ISequence {
186	let i = 0;	90,476✔
187	const iterator = this.value;	90,476✔
188	return this._sequenceFactory.create(	90,476✔
189	{
190	next: (hint: IterationHint) => {
191	const value = iterator.next(hint);	1,453,900✔
192	if (value.done) {	1,453,864✔
193	return DONE_TOKEN;	23,564✔
194	}
195
196	return ready(callback(value.value, i++, this));	1,430,300✔
197	},
198	},
199	this._length
200	);
201	}
202
203	public mapAll(callback: (allValues: Value[]) => ISequence, hint: IterationHint): ISequence {
204	const iterator = this.value;	170,412✔
205	let mappedResultsIterator: IIterator<Value>;
206	const allResults: Value[] = [];	170,412✔
207	let isFirst = true;	170,412✔
208	(function processNextResult() {	170,412✔
209	for (	170,412✔
210	let value = iterator.next(isFirst ? IterationHint.NONE : hint);	170,412!
211	!value.done;
212	value = iterator.next(hint)
213	) {
214	isFirst = false;	164,584✔
215	allResults.push(value.value);	164,584✔
216	}
217	mappedResultsIterator = callback(allResults).value;	170,408✔
218	})();
219	return this._sequenceFactory.create({	170,352✔
220	next: (_hint: IterationHint) => {
221	return mappedResultsIterator.next(IterationHint.NONE);	283,668✔
222	},
223	});
224	}
225
226	public switchCases(cases: SwitchCasesCases): ISequence {
227	let resultIterator: IIterator<Value> = null;	224,776✔
228
229	const setResultIterator = (resultSequence: ISequence) => {	224,776✔
230	resultIterator = resultSequence.value;	218,704✔
231	// Try to mirror through length;
232	const resultSequenceLength = resultSequence.getLength(true);	218,704✔
233	if (resultSequenceLength !== -1) {	218,704✔
234	this._length = resultSequenceLength;	188,032✔
235	}
236	};
237
238	return this._sequenceFactory.create({	224,776✔
239	next: (hint: IterationHint) => {
240	if (resultIterator) {	333,448✔
241	return resultIterator.next(hint);	114,468✔
242	}
243
244	const isEmpty = this.isEmpty();	218,980✔
245	if (isEmpty) {	218,940✔
246	setResultIterator(cases.empty ? cases.empty(this) : cases.default(this));	9,888✔
247	return resultIterator.next(hint);	9,860✔
248	}
249
250	const isSingleton = this.isSingleton();	209,052✔
251	if (isSingleton) {	209,052✔
252	setResultIterator(	208,860✔
253	cases.singleton ? cases.singleton(this) : cases.default(this)	208,860✔
254	);
255	return resultIterator.next(hint);	208,720✔
256	}
257
258	setResultIterator(cases.multiple ? cases.multiple(this) : cases.default(this));	192✔
259	return resultIterator.next(hint);	124✔
260	},
261	});
262	}
263
264	private reset(to = 0) {	649,580✔
265	this._currentPosition = to;	903,672✔
266	}
267	}

FontoXML / fontoxpath / 2880899497

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