import { INotifyPropertyChanged } from '../basecomponentmodel/INotifyPropertyChanged';
import { supportedInterfacesCompatibilityMetadataKey } from '../decorators/ClassInfo';
import { Debugger } from '../diagnostics/Debugger';
import { CancelEventArgs } from '../helpers/CancelEventArgs';
import { SubscriptionEvent } from '../utils/SubscriptionEvent';
import { InvalidOperationException } from './Exceptions';
import { SortDescription } from './SortDescription';
/**
* IEqualityComparer interface
*
* @export
* @interface IEqualityComparer
* @template T
* @wInterface System.Collections.Generic.IEqualityComparer`1
* @wNetSupport
*/
export interface IEqualityComparer<T> {
Equals(x: T, y: T): boolean;
GetHashCode(x: T): number;
}
/**
* IComparer interface
*
* @export
* @interface IComparer
* @template T
* @wInterface System.Collections.Generic.IComparer`1
* @wNetSupport
*/
export interface IComparer<T> {
Compare(x: T, y: T): number;
}
/**
* IComparable interface
*
* @export
* @interface IComparable
* @template T
* @wInterface System.IComparable`1
* @wNetSupport
*/
export interface IComparable<T> {
CompareTo(x: T): number;
}
/**
* IEquatable interface
*
* @export
* @interface IEquatable
* @template T
* @wInterface System.IEquatable`1
* @wNetSupport
*/
export interface IEquatable<T> {
Equals(other: T): boolean;
}
export interface ISupportCollection<T> {
internalArray: Array<T>;
}
/**
* IOrderedIterable interface
*
* @export
* @interface IOrderedIterable
* @extends {Iterable<V>}
* @template V
* @wInterface System.Linq.IOrderedEnumerable`1
* @wNetSupport
*/
export interface IOrderedIterable<V> extends Iterable<V> {
/**
* Creates ordered iterable
*
* @template K
* @param {(e: V) => K} keySelector
* @param {IComparer<K>} comparer
* @param {boolean} descending
* @returns {IOrderedIterable<V>}
* @memberof IOrderedIterable
* @wMethod CreateOrderedEnumerable
*/
CreateOrderedIterable<K>(
keySelector: (e: V) => K,
comparer: IComparer<K>,
descending: boolean
): IOrderedIterable<V>;
}
export interface UnTypedIterable {}
export interface IUntypedCollection {}
/**
* ICollection interface
*
* @export
* @interface ICollection
* @extends {Iterable<T>}
* @extends {ISupportCollection<T>}
* @template T
* @wInterface System.Collections.Generic.ICollection`1
* @wNetSupport
*/
export interface ICollection<T> extends Iterable<T>, ISupportCollection<T> {
/**
* The number of elemenst in the collection
*
* @type {number}
* @memberof ICollection
* @wProperty Count
*/
count: number;
/**
* Adds a value to the collection
*
* @param {T} value
* @memberof ICollection
* @wMethod Add
*/
add(value: T): void;
/**
* Clears the collection
*
* @memberof ICollection
* @wMethod Clear
*/
clear(): void;
/**
* Check if a element is contained in the collection
*
* @param {T} value
* @returns {boolean}
* @memberof ICollection
* @wMethod Contains
*/
contains(value: T): boolean;
/**
* Removes the element from the collection
*
* @param {T} value
* @returns {boolean}
* @memberof ICollection
*/
remove(value: T): boolean;
copyTo(target: Array<T>, index: number): void;
}
/**
* IPagedCollectionView interface
*
* @export
* @interface IPagedCollectionView
* @wInterface System.ComponentModel.IPagedCollectionView
*/
export interface IPagedCollectionView {
CanChangePage: boolean;
IsPageChanging: boolean;
ItemCount: number;
PageIndex: number;
PageSize: number;
TotalItemCount: number;
PageChanged: SubscriptionEvent<(e: any, args: CollectionChangeInfo) => void>;
PageChanging: SubscriptionEvent<
(e: any, args: PageChangingEventArgs) => void
>;
MoveToFirstPage(): boolean;
MoveToLastPage(): boolean;
MoveToNextPage(): boolean;
MoveToPage(pageIndex: number): boolean;
MoveToPreviousPage(): boolean;
}
/**
* IList interface
*
* @export
* @interface IList
* @extends {ICollection<T>}
* @template T
* @wInterface System.Collections.Generic.IList`1
* @wNetSupport
*/
export interface IList<T> extends ICollection<T> {
getItem(index: number): T;
setItem(index: number, value: T);
/**
* Gets the index of an element in the list
*
* @param {T} value
* @returns {number}
* @memberof IList
* @wMethod IndexOf
*/
indexOf(value: T): number;
/**
* Insert element in position
*
* @param {number} index
* @param {T} value
* @memberof IList
* @wMethod Insert
*/
insert(index: number, value: T);
/**
* Removes element at index
*
* @param {number} index
* @memberof IList
* @wMethod RemoveAt
*/
removeAt(index: number);
/**
* Sorts the list
*
* @memberof IList
* @wMethod Sort
*/
sort();
/**
* Sorts the list by comparer
*
* @param {IComparer<T>} comparer
* @memberof IList
* @wMethod Sort
*/
sort(comparer: IComparer<T>);
}
/**
* SimpleList Class
*
* @export
* @class SimpleList
* @implements {IList}
* @wType System.Collections.Generic.List`1
* @wNetSupport
*/
export class SimpleList<T> implements IList<T> {
protected static interfacesInitialized = false;
protected _internalArray: T[] = [];
protected static initializeSupportedInterfaces(): void {
if (!SimpleList.interfacesInitialized) {
const setMetadataInfo = Reflect.metadata(
supportedInterfacesCompatibilityMetadataKey,
[
'System.Collections.Generic.ICollection`1',
'System.Collections.Generic.IList`1',
'System.Collections.Generic.IList',
'System.Collections.IList',
]
);
setMetadataInfo(SimpleList);
SimpleList.interfacesInitialized = true;
}
}
constructor();
constructor(initialValues: Iterable<T>);
constructor(capacity: number);
constructor(arg?: unknown) {
const newLocal = typeof arg;
// capacity argument still not supported
if (newLocal != 'undefined' && newLocal != 'number') {
const initialValues = arg as Iterable<T>;
this.internalArray = [...initialValues];
}
SimpleList.initializeSupportedInterfaces();
}
/**
* Gets or sets the internal array.
*
* @type {T[]}
* @memberof SimpleList
*/
get internalArray(): T[] {
// eslint-disable-next-line no-underscore-dangle
return this._internalArray;
}
set internalArray(value: T[]) {
// eslint-disable-next-line no-underscore-dangle
this._internalArray = value;
}
getItem(index: number): T {
if (index >= this.internalArray.length || index < 0) {
throw new Error('Invalid index');
}
return this.internalArray[index];
}
setItem(index: number, value: T) {
if (index >= this.internalArray.length || index < 0) {
throw new Error('Invalid index');
}
this.internalArray[index] = value;
}
/**
* Index of value in list
*
* @param {T} value
* @returns
* @memberof SimpleList
* @wMethod IndexOf
*/
indexOf(value: T) {
return this.internalArray.indexOf(value);
}
/**
* Inserts element in index
*
* @param {number} index
* @param {T} value
* @memberof SimpleList
* @wMethod Insert
*/
insert(index: number, value: T) {
this.internalArray.splice(index, 0, value);
}
/**
* Removes element at index
*
* @param {number} index
* @memberof SimpleList
* @wMethod RemoveAt
*/
removeAt(index: number) {
this.internalArray.splice(index, 1);
}
/**
* Gets the count of elements in list
*
* @readonly
* @type {number}
* @memberof SimpleList
* @wProperty Count
*/
get count(): number {
return this.internalArray.length;
}
/**
* Adds an element to the list
*
* @param {T} value
* @memberof SimpleList
* @wMethod Add
*/
add(value: T): void {
this.internalArray.push(value);
}
/**
* Clears the list
*
* @memberof SimpleList
* @wMethod Clear
*/
clear(): void {
this.internalArray.splice(0, this.internalArray.length);
}
/**
* Check if a value is contained in the list
*
* @param {T} value
* @returns {boolean}
* @memberof SimpleList
* @wMethod Contains
*/
contains(value: T): boolean {
return this.internalArray.indexOf(value) !== -1;
}
/**
* Removes a value from the list
*
* @param {T} value
* @returns {boolean}
* @memberof SimpleList
* @wMethod Remove
*/
remove(value: T): boolean {
const idx = this.internalArray.indexOf(value);
if (idx !== -1) {
this.internalArray.splice(idx, 1);
return true;
} else {
return false;
}
}
/**
* Performs an action on each element of the list
*
* @param {(e: T) => void} action
* @memberof SimpleList
* @wMethod ForEach
*/
forEach(action: (e: T) => void): void {
for (const obj of this.internalArray) {
action(obj);
}
}
/**
* Adds elements of an iterable to the list
*
* @param {Iterable<T>} range
* @memberof SimpleList
* @wMethod AddRange
*/
addRange(range: Iterable<T>): void {
for (const obj of range) {
this.add(obj);
}
}
/**
* Inserts elements of an interable to the list in a position
*
* @param {number} position
* @param {Iterable<T>} range
* @memberof SimpleList
* @wMethod InserRange
*/
insertRange(position: number, range: Iterable<T>): void {
if (!(position < this.internalArray.length && position >= 0)) {
throw new Error('Invalid position');
}
this.internalArray.splice(position, 0, ...range);
}
/**
* Sorts the list
*
* @memberof SimpleList
* @wMethod Sort
*/
sort();
sort(comparer: IComparer<T>);
sort(comparison: (x: T, y: T) => number);
sort(p?: any) {
if (typeof p === 'object') {
this.internalArray = this.internalArray.sort(p.Compare);
} else if (typeof p === 'function') {
this.internalArray = this.internalArray.sort(p);
} else {
if (
this.internalArray.length > 0 &&
typeof this.internalArray[0] === 'object'
) {
this.internalArray.sort((a: any, b: any) => {
if (a?.CompareTo && b?.CompareTo) {
return a.CompareTo(b);
} else {
return 0;
}
});
} else {
this.internalArray = this.internalArray.sort();
}
}
}
/**
* Copies the list to a target array
*
* @param {T[]} target
* @param {number} index
* @memberof SimpleList
* @wMethod CopyTo
*/
copyTo(target: T[], index: number): void {
for (let i = index; i < target.length; i++) {
target[i] = this.internalArray[i];
}
}
/**
* Removes all elements from the collection by a predicate
*
* @param {(e: T) => boolean} predicate
* @returns
* @memberof SimpleList
* @wMethod RemoveAll
*/
public removeAll(predicate: (e: T) => boolean) {
let removed = 0;
for (let i = this.internalArray.length - 1; i >= 0; i--) {
if (predicate(this.internalArray[i])) {
this.removeAt(i);
removed++;
}
}
return removed;
}
/**
* Converts the list to an array
*
* @returns
* @memberof SimpleList
* @wMethod ToArray
*/
public toArray() {
return [...this.internalArray];
}
[Symbol.iterator](): Iterator<T, any, undefined> {
return this.internalArray[Symbol.iterator]();
}
}
/**
* A collection of sort descriptions
*
* @export
* @class SortDescriptionCollection
* @extends {SimpleList<SortDescription>}
* @wType System.ComponentModel.SortDescriptionCollection
*/
export class SortDescriptionCollection
extends SimpleList<SortDescription>
implements INotifyCollectionChanged
{
CollectionChanged: SubscriptionEvent<
(e: any, args: CollectionChangeInfo) => void
> = new SubscriptionEvent();
/**
* Raises the CollectionChanged event.
*
* @param {CollectionChangeInfo} info
* @memberof SortDescriptionCollection
*/
onCollectionChanged(info: CollectionChangeInfo): void {
this.CollectionChanged.fire([this, info]);
}
/**
* Inserts a new element at the specified position.
*
* @param {number} index
* @param {T} value
* @memberof SortDescriptionCollection
*/
insert(index: number, value: SortDescription): void {
super.insert(index, value);
const info = new CollectionChangeInfo(CollectionChangeAction.Add);
info.NewItems = new SimpleList([value]);
info.NewStartingIndex = index;
this.onCollectionChanged(info);
}
/**
* Removes the first element from the collection which matches the given value.
*
* @param {T} value
* @return {*} {boolean}
* @memberof SortDescriptionCollection
*/
remove(value: SortDescription): boolean {
const idx = this.internalArray.indexOf(value);
if (idx === -1) {
return false;
}
const result = super.remove(value);
const info = new CollectionChangeInfo(CollectionChangeAction.Remove);
info.OldItems = new SimpleList([value]);
info.OldStartingIndex = idx;
this.onCollectionChanged(info);
return result;
}
/**
* Removes the element at the given position.
*
* @param {number} index
* @memberof SortDescriptionCollection
*/
removeAt(index: number): void {
const oldItem = super.getItem(index);
super.removeAt(index);
const info = new CollectionChangeInfo(CollectionChangeAction.Remove);
info.OldItems = new SimpleList([oldItem]);
info.OldStartingIndex = index;
this.onCollectionChanged(info);
}
/**
* Adds the given element at the end of the collection.
*
* @param {T} value
* @memberof SortDescriptionCollection
*/
add(value: SortDescription): void {
super.add(value);
const info = new CollectionChangeInfo(CollectionChangeAction.Add);
info.NewItems = new SimpleList([value]);
info.NewStartingIndex = this.count - 1;
this.onCollectionChanged(info);
}
/**
* Removes all elements from the collection.
*
* @memberof SortDescriptionCollection
*/
clear(): void {
super.clear();
this.onCollectionChanged(
new CollectionChangeInfo(CollectionChangeAction.Reset)
);
}
/**
* Replace the element at the given position with the given element.
*
* @param {number} index
* @param {T} value
* @memberof SortDescriptionCollection
* @wMethod SetItem
*/
setItem(index: number, value: SortDescription): void {
const oldItem = super.getItem(index);
super.setItem(index, value);
const info = new CollectionChangeInfo(CollectionChangeAction.Replace);
info.OldItems = new SimpleList([oldItem]);
info.NewItems = new SimpleList([value]);
info.NewStartingIndex = index;
this.onCollectionChanged(info);
}
}
/**
* Reports changes in a collection.
*
* @export
* @class CollectionChangeInfo
* @wType System.Collections.Specialized.NotifyCollectionChangedEventArgs
*/
export class CollectionChangeInfo {
/**
* The items added or changed in the collection
*
* @type {IList<any>}
* @memberof CollectionChangeInfo
*/
public NewItems: IList<any> = null;
/**
* The index where the change occurred.
*
* @type {number}
* @memberof CollectionChangeInfo
*/
public NewStartingIndex = -1;
/**
* The items that where removed from the collection.
*
* @type {IList<any>}
* @memberof CollectionChangeInfo
*/
public OldItems: IList<any> = null;
/**
* The index where a replace action or remove occurred.
*
* @type {number}
* @memberof CollectionChangeInfo
*/
public OldStartingIndex = -1;
/**
* Creates an instance of CollectionChangeInfo.
*
* @param {CollectionChangeAction} action
* @memberof CollectionChangeInfo
*/
constructor(public action: CollectionChangeAction) {}
}
/**
* CollectionChangeAction enum
*
* @export
* @enum {number}
* @wEnum System.Collections.Specialized.NotifyCollectionChangedAction
*/
export enum CollectionChangeAction {
Add,
Remove,
Replace,
Reset,
}
/**
* INotifyCollectionChanged interface
*
* @export
* @interface INotifyCollectionChanged
* @wInterface System.Collections.Specialized.INotifyCollectionChanged
*/
export interface INotifyCollectionChanged {
CollectionChanged: SubscriptionEvent<
(e: any, args: CollectionChangeInfo) => void
>;
}
/**
* ObjectModelCollection class
*
* @export
* @class ObjectModelCollection
* @extends {SimpleList<T>}
* @template T
* @wType System.Collections.ObjectModel.Collection`1
*/
export class ObjectModelCollection<T> extends SimpleList<T> {}
/**
* ItemDataRequestedEventArgs class
*
* @export
* @class ItemDataRequestedEventArgs
* @wType Infragistics.Collections.ItemDataRequestedEventArgs
*/
export class ItemDataRequestedEventArgs {
/**
* FilterConditions property
*
* @type {*}
* @memberof ItemDataRequestedEventArgs
*/
FilterConditions: any = null;
/**
* ItemsCount property
*
* @type {number}
* @memberof ItemDataRequestedEventArgs
*/
ItemsCount: number = null;
/**
* SortDescriptions Property
*
* @type {*}
* @memberof ItemDataRequestedEventArgs
*/
SortDescriptions: any = null;
/**
* StartIndex property.
*
* @type {number}
* @memberof ItemDataRequestedEventArgs
*/
StartIndex: number = null;
}
/**
* PageChangingEventArgs class
*
* @export
* @class PageChangingEventArgs
* @wType System.ComponentModel.PageChangingEventArgs
*/
export class PageChangingEventArgs extends CancelEventArgs {
/**
* New page index internal field
*
* @private
* @type {number}
* @memberof PageChangingEventArgs
*/
private newPageIndex: number;
/**
*Creates an instance of PageChangingEventArgs.
* @param {number} newPageIndex
* @memberof PageChangingEventArgs
*/
constructor(newPageIndex: number) {
super();
this.newPageIndex = newPageIndex;
}
/**
* StartIndex property.
*
* @type {number}
* @memberof PageChangingEventArgs
*/
get NewPageIndex(): number {
return this.newPageIndex;
}
}
/**
* Collection which reports changes to its observers.
*
* @export
* @class ObservableCollection
* @extends {ObjectModelCollection<T>}
* @implements {INotifyPropertyChanged}
* @template T
* @wType System.Collections.ObjectModel.ObservableCollection`1
*/
export class ObservableCollection<T>
extends ObjectModelCollection<T>
implements INotifyCollectionChanged, INotifyPropertyChanged
{
/**
* Flag to indicate if supported interfaces have been initialized.
*
* @private
* @static
* @memberof ObservableCollection
*/
protected static interfacesInitialized = false;
/**
* Event to indicate that a property have changed.
*
* @memberof ObservableCollection
*/
public PropertyChanged: SubscriptionEvent<
(e: any, args: { PropertyName: string }) => void
> = new SubscriptionEvent();
/**
* Event to indicate that the collection have changed.
*
* @memberof ObservableCollection
*/
public CollectionChanged: SubscriptionEvent<
(e: any, args: CollectionChangeInfo) => void
> = new SubscriptionEvent();
/**
* Event AddNewItem have changed.
*
* @memberof ObservableCollection
* @wIgnore
*/
public AddNewItem: SubscriptionEvent<
(e: any, args: CollectionChangeInfo) => void
> = new SubscriptionEvent();
/**
* Creates an instance of ObservableCollection.
*
* @param {Iterable<T>} [initial]
* @memberof ObservableCollection
*/
constructor(initial?: Iterable<T>) {
super();
if (typeof initial !== 'undefined' && initial !== null) {
this.internalArray = [...initial];
}
ObservableCollection.initializeSupportedInterfaces();
}
/**
* Initialize the interfaces supported by this collection.
*
* @private
* @static
* @memberof ObservableCollection
*/
protected static initializeSupportedInterfaces(): void {
if (!ObservableCollection.interfacesInitialized) {
const setMetadataInfo = Reflect.metadata(
supportedInterfacesCompatibilityMetadataKey,
[
'System.ComponentModel.INotifyPropertyChanged',
'System.Collections.IEnumerable',
'System.Collections.Generic.IList`1',
'System.Collections.IList',
'System.Collections.Specialized.INotifyCollectionChanged',
]
);
setMetadataInfo(ObservableCollection);
ObservableCollection.interfacesInitialized = true;
}
}
/**
* Inserts a new element at the specified position.
*
* @param {number} index
* @param {T} value
* @memberof ObservableCollection
*/
insert(index: number, value: T): void {
super.insert(index, value);
const changeEventInfo = new CollectionChangeInfo(
CollectionChangeAction.Add
);
changeEventInfo.NewItems = new SimpleList([value]);
changeEventInfo.NewStartingIndex = index;
this.onCollectionChanged(changeEventInfo);
this.onPropertyChanged({ PropertyName: 'Count' });
}
/**
* Removes the first element from the collection which matches the given value.
*
* @param {T} value
* @return {*} {boolean}
* @memberof ObservableCollection
*/
remove(value: T): boolean {
const idx = this.internalArray.indexOf(value);
if (idx === -1) {
return false;
}
const result = super.remove(value);
const changeEventInfo = new CollectionChangeInfo(
CollectionChangeAction.Remove
);
changeEventInfo.OldItems = new SimpleList([value]);
changeEventInfo.OldStartingIndex = idx;
this.onCollectionChanged(changeEventInfo);
this.onPropertyChanged({ PropertyName: 'Count' });
return result;
}
/**
* Removes the element at the given position.
*
* @param {number} index
* @memberof ObservableCollection
*/
removeAt(index: number): void {
const oldItem = super.getItem(index);
super.removeAt(index);
const changeEventInfo = new CollectionChangeInfo(
CollectionChangeAction.Remove
);
changeEventInfo.OldItems = new SimpleList([oldItem]);
changeEventInfo.OldStartingIndex = index;
this.onCollectionChanged(changeEventInfo);
this.onPropertyChanged({ PropertyName: 'Count' });
}
/**
* Adds the given element at the end of the collection.
*
* @param {T} value
* @memberof ObservableCollection
*/
add(value: T): void {
super.add(value);
const changeEventInfo = new CollectionChangeInfo(
CollectionChangeAction.Add
);
changeEventInfo.NewItems = new SimpleList([value]);
changeEventInfo.NewStartingIndex = this.count - 1;
this.onCollectionChanged(changeEventInfo);
this.onPropertyChanged({ PropertyName: 'Count' });
}
/**
* Adds elements of an iterable to the list
*
* @param {Iterable<T>} range
* @memberof ObservableCollection
* @wIgnore
*/
silentAddRange(range: Iterable<T>) {
for (const obj of range) {
super.add(obj);
}
const changeEventInfo = new CollectionChangeInfo(
CollectionChangeAction.Add
);
changeEventInfo.NewItems = new SimpleList([range]);
changeEventInfo.NewStartingIndex = this.count - 1;
this.onCollectionChanged(changeEventInfo);
this.onPropertyChanged({ PropertyName: 'Count' });
}
/**
* Removes all elements from the collection.
*
* @memberof ObservableCollection
*/
clear(): void {
super.clear();
this.onCollectionChanged(
new CollectionChangeInfo(CollectionChangeAction.Reset)
);
this.onPropertyChanged({ PropertyName: 'Count' });
}
/**
* Replace the element at the given position with the given element.
*
* @param {number} index
* @param {T} value
* @memberof ObservableCollection
* @wMethod SetItem
*/
setItem(index: number, value: T): void {
const oldItem = super.getItem(index);
super.setItem(index, value);
const changeEventInfo = new CollectionChangeInfo(
CollectionChangeAction.Replace
);
changeEventInfo.OldItems = new SimpleList([oldItem]);
changeEventInfo.NewItems = new SimpleList([value]);
changeEventInfo.NewStartingIndex = index;
this.onCollectionChanged(changeEventInfo);
}
/**
* Removes all elements from the collection.
*
* @protected
* @memberof ObservableCollection
* @wMethod ClearItems
*/
protected clearItems(): void {
this.clear();
}
/**
* Trigger a `CollectionChanged` event.
*
* @protected
* @param {CollectionChangeInfo} info
* @memberof ObservableCollection
* @wMethod OnCollectionChanged
*/
protected onCollectionChanged(info: CollectionChangeInfo): void {
this.CollectionChanged.fire([this, info]);
}
/**
* Trigger a `PropertyChanged` event.
*
* @protected
* @param {{ PropertyName: string }} info
* @memberof ObservableCollection
* @wMethod OnPropertyChanged
*/
protected onPropertyChanged(info: { PropertyName: string }): void {
this.PropertyChanged.fire([this, info]);
}
}
/**
* SimpleQueue class
*
* @export
* @class SimpleQueue
* @implements {Iterable<T>}
* @template T
* @wType System.Collections.Generic.Queue`1
*/
export class SimpleQueue<T> implements Iterable<T> {
public internalArray: T[] = [];
constructor(initialData?: Iterable<T>) {
if (typeof initialData !== 'undefined') {
this.internalArray = [...initialData];
}
}
/**
* Count the elements in queue
*
* @readonly
* @type {number}
* @memberof SimpleQueue
* @wProperty Count
*/
get count(): number {
return this.internalArray.length;
}
/**
* Enqueue an element in the queue
*
* @param {T} value
* @returns
* @memberof SimpleQueue
* @wMethod Enqueue
*/
public enqueue(value: T) {
return this.internalArray.push(value);
}
/**
* Dequeue an element of the queue
*
* @returns {T}
* @memberof SimpleQueue
* @wMethod Dequeue
*/
public dequeue(): T {
return this.internalArray.shift();
}
[Symbol.iterator](): Iterator<T, any, undefined> {
return this.internalArray[Symbol.iterator]();
}
}
/**
* ReadOnlyCollection class
*
* @export
* @class ReadonlyCollection
* @extends {SimpleList<T>}
* @template T
* @wType System.Collections.ObjectModel.ReadOnlyCollection`1
*/
export class ReadonlyCollection<T> extends SimpleList<T> {
constructor(contents?: Iterable<T>) {
super(contents);
}
// NOTE: this methods intentionally throw an exception, because
// it is not allowed to modify a read only collection.
insert(index: number, value: T) {
throw Error('Operation not supported');
}
remove(value: T): boolean {
throw Error('Operation not supported');
}
removeAt(index: number) {
throw Error('Operation not supported');
}
add(value: T): void {
throw Error('Operation not supported');
}
clear(): void {
throw Error('Operation not supported');
}
setItem(index: number, value: T) {
throw Error('Operation not supported');
}
}
//
// IterUtils
//
export function iuToArray<T>(iterable: Iterable<T>): Array<T> {
return [...iterable];
}
class SelectIteratorWrapper<T, K> implements Iterator<K> {
private index = 0;
constructor(
private innerIterator: Iterator<T>,
private funcWithIndex?: (e: T, i?: number) => K
) {}
next(): IteratorResult<K, any> {
const nextValue = this.innerIterator.next();
if (!nextValue.done) {
return {
value: this.funcWithIndex(nextValue.value, this.index++),
done: false,
};
}
return { value: undefined, done: true };
}
}
export function iuSelect<T, K>(
func: (e: T, i?: number) => K,
iterable: Iterable<T>
): Iterable<K> {
return {
[Symbol.iterator]() {
return new SelectIteratorWrapper(iterable[Symbol.iterator](), func);
},
};
}
class WhereIteratorWrapper<T> implements Iterator<T> {
constructor(
private innerIterator: Iterator<T>,
private predicate: (e: T) => boolean
) {}
next(value?: any): IteratorResult<T, any> {
let next = this.innerIterator.next();
while (!next.done && !this.predicate(next.value)) {
next = this.innerIterator.next();
}
return next;
}
}
export function iuWhere<T>(
predicate: (e: T) => boolean,
iterable: Iterable<T>
): Iterable<T> {
return {
[Symbol.iterator]() {
return new WhereIteratorWrapper(iterable[Symbol.iterator](), predicate);
},
};
}
export function iuFirst<T>(
iterable: Iterable<T>,
predicate?: (e: T) => boolean
): T {
if (
iterable instanceof Array &&
iterable.length > 0 &&
(typeof predicate === 'undefined' || predicate(iterable[0]))
) {
return iterable[0];
} else {
const iterator = iterable[Symbol.iterator]();
let next = iterator.next();
while (!next.done) {
if (typeof predicate == 'undefined' || predicate(next.value)) {
return next.value;
}
next = iterator.next();
}
}
throw Error('Elements not available');
}
/**
* Returns the first element of the iterable for which predicate returns `true`,
* or a default value if the predicate returns `false` for every element.
* If no predicate is provided, returns the first element of the iterable, or
* a default value when the iterable is empty.
*
* @export
* @template T
* @param {Iterable<T>} iterable
* @param {(e: T) => boolean} [predicate]
* @param {T} [defaultValue=null]
* @return {*} {T}
*/
export function iuFirstOrDefault<T>(
iterable: Iterable<T>,
predicate?: (e: T) => boolean,
defaultValue: T = null
): T {
if (
iterable instanceof Array &&
iterable.length > 0 &&
(typeof predicate === 'undefined' || predicate(iterable[0]))
) {
return iterable[0];
} else if (iterable != null) {
const iterator = iterable[Symbol.iterator]();
let next = iterator.next();
while (!next.done) {
if (typeof predicate == 'undefined' || predicate(next.value)) {
return next.value;
}
next = iterator.next();
}
}
return defaultValue;
}
export function iuCount<T>(
iterable: Iterable<T>,
predicate?: (e: T) => boolean
): number {
if (iterable instanceof Array && !predicate) {
return iterable.length;
} else if (iterable instanceof SimpleList && !predicate) {
return iterable.count;
} else {
const iterator = iterable[Symbol.iterator]();
let i = 0;
let itResult = iterator.next();
while (!itResult.done) {
const current = itResult.value;
itResult = iterator.next();
if (predicate && !predicate(current)) {
continue;
}
i++;
}
return i;
}
}
class TakeIteratorWrapper<T> implements Iterator<T> {
constructor(private innerIterator: Iterator<T>, private count: number) {}
next(value?: any): IteratorResult<T, any> {
if (this.count > 0) {
this.count--;
const next = this.innerIterator.next();
return next;
} else {
return { value: undefined, done: true };
}
}
}
export function iuTake<T>(count: number, iterable: Iterable<T>): Iterable<T> {
return {
[Symbol.iterator]() {
return new TakeIteratorWrapper(iterable[Symbol.iterator](), count);
},
};
}
export function iuToList<T>(iterable: Iterable<T>): SimpleList<T> {
return new SimpleList(iterable);
}
export function iuLast<T>(
iterable: Iterable<T>,
predicate?: (e: T) => boolean
): T {
if (iterable instanceof Array && iterable.length > 0 && !predicate) {
return iterable[iterable.length - 1];
} else {
const iterator = iterable[Symbol.iterator]();
let next = iterator.next();
let found = false;
let lastValue = null;
while (!next.done) {
if (predicate) {
if (predicate(next.value)) {
found = true;
lastValue = next.value;
}
} else {
found = true;
lastValue = next.value;
}
next = iterator.next();
}
if (!found) {
throw Error('Elements not available');
} else {
return lastValue;
}
}
}
export function iuLastOrDefault<T>(
iterable: Iterable<T>,
predicate?: (e: T) => boolean
): T {
if (iterable == null) {
throw Error('ArgumentNullException');
}
if (iterable instanceof Array && iterable.length > 0) {
if (predicate == undefined) {
return iterable[iterable.length - 1];
} else {
for (let i = iterable.length - 1; i >= 0; i--) {
if (predicate(iterable[i])) {
return iterable[i];
}
}
}
} else {
for (const val of Array.from(iterable).reverse()) {
if (predicate == undefined || predicate(val)) {
return val;
}
}
}
// here we have the problem of value types
// in this case we should not return null
// this work is still pending
return null;
}
export function iuElementAt<T>(iterable: Iterable<T>, index: number): T {
if (iterable instanceof Array && iterable.length > index && index >= 0) {
return iterable[index];
} else if (iterable instanceof SimpleList) {
return iterable.getItem(index);
} else {
const iterator = iterable[Symbol.iterator]();
let next = iterator.next();
let found = false;
let lastValue;
let i = 0;
while (!next.done) {
if (i == index) {
found = true;
lastValue = next.value;
break;
}
next = iterator.next();
i++;
}
if (!found) {
throw Error('Elements not available');
} else {
return lastValue;
}
}
}
export function iuElementAtOrDefault<T>(
iterable: Iterable<T>,
index: number
): T {
if (iterable == null) {
throw Error('ArgumentNullException');
}
if (iterable instanceof Array && iterable.length > index && index >= 0) {
return iterable[index];
} else {
const iterator = iterable[Symbol.iterator]();
let result = iterator.next();
let i = 0;
while (!result.done) {
if (i == index) {
return result.value;
}
result = iterator.next();
i++;
}
}
return null;
}
export function iuAny<T>(iterable: Iterable<T>, predicate?: (e: T) => boolean) {
if (iterable instanceof Array && typeof predicate === 'undefined') {
return iterable.length > 0;
} else if (
iterable instanceof SimpleList &&
typeof predicate === 'undefined'
) {
return iterable.count > 0;
} else {
const iterator = iterable[Symbol.iterator]();
let next = iterator.next();
if (typeof predicate === 'undefined') {
return !next.done;
} else {
let found = false;
while (!next.done) {
if (predicate(next.value)) {
found = true;
break;
}
next = iterator.next();
}
return found;
}
}
}
/**
* Verifies if a predicate is `true` for all the elements of an iterable
*
* @export
* @template T
* @param {Iterable<T>} iterable sequence to verify
* @param {(e: T) => boolean} [predicate] predicate
* @return {*} true if the predicate is valid for all elements of the sequence
*/
export function iuAll<T>(iterable: Iterable<T>, predicate: (e: T) => boolean) {
for (const element of iterable) {
if (!predicate(element)) {
return false;
}
}
return true;
}
export function iuSingle<T>(
iterable: Iterable<T>,
predicate?: (e: T) => boolean
) {
const errNotSingle = 'Sequence does not contain exactly one element';
const errNoElements =
'Sequence does not contain exactly one element that satisfies the condition';
let found = false;
let result: T = null;
if (
iterable instanceof Array &&
iterable.length == 1 &&
(typeof predicate == 'undefined' || predicate(iterable[0]))
) {
return iterable[0];
} else if (
iterable instanceof SimpleList &&
iterable.count == 1 &&
(typeof predicate == 'undefined' || predicate(iterable.getItem(0)))
) {
return iterable.getItem(0);
} else {
const iterator = iterable[Symbol.iterator]();
let next = iterator.next();
while (!next.done) {
if (typeof predicate == 'undefined' || predicate(next.value)) {
if (found) {
throw new Error(errNotSingle);
}
result = next.value;
found = true;
}
next = iterator.next();
}
}
if (!found) {
throw new Error(errNoElements);
}
return result;
}
class ConcatIterator<T> implements Iterator<T> {
private firstFinished: boolean;
private iterator: Iterator<T>;
constructor(private iterable1: Iterable<T>, private iterable2: Iterable<T>) {
this.iterator = iterable1[Symbol.iterator]();
}
next(value?: any): IteratorResult<T> {
let result: IteratorResult<T> = null;
if (!this.firstFinished) {
result = this.iterator.next();
if (!result.done) {
return result;
}
this.firstFinished = true;
this.iterator = this.iterable2[Symbol.iterator]();
}
return this.iterator.next();
}
}
export function iuConcat<T>(
first: Iterable<T>,
second: Iterable<T>
): Iterable<T> {
if (first == null || second == null) {
throw new Error('ArgumentNullException');
}
return {
[Symbol.iterator]() {
return new ConcatIterator<T>(first, second);
},
};
}
/**
* Returns whether the iterable contains a specified element.
*
* @param iterable - The iterable source.
* @param value - The element to find.
*/
export function iuContains<T>(
iterable: Iterable<T>,
value: T,
comparer?: any
): boolean {
if (iterable == null) {
throw new Error('ArgumentNullException');
}
// Use 'Equals' to compare elements if available. If not, use '==='.
let isEqual: Function = getCompareFunction<T>(value);
for (const v of iterable) {
if (isEqual(value, v)) {
return true;
}
}
return false;
}
/**
* Base class for DistinctIterator, IntersectIterator and ExceptIterator.
*
* This class contains the logic to detect if the elements have an 'Equals()'
* function, and use it if available to compare elements. If 'Equals()' is
* not available, then '===' is used to compare elements.
*
* The logic to discriminate which elements are returned must be implemented
* on the derived classes.
*/
abstract class BaseDieIterator<T> implements Iterator<T> {
protected baseSet: Set<T>;
protected iterator: Iterator<T>;
protected nextResult: IteratorResult<T, any>;
protected baseSetHas: Function;
protected baseSetDelete: Function;
constructor(first: Iterable<T>, second: Iterable<T>) {
this.iterator = first[Symbol.iterator]();
this.baseSet = new Set(second);
this.baseSetHas = null;
// Get the first element to find out if it has an 'Equals()' function.
this.nextResult = this.iterator.next();
if (!this.nextResult.done) {
if (
this.nextResult?.value &&
typeof this.nextResult.value.Equals === 'function'
) {
// This is slow - O(n): use slow implementations of 'has()'
// and 'delete()' to use 'Equals()' to compare elements.
this.baseSetHas = (value: T): boolean =>
iuContains(this.baseSet, value);
this.baseSetDelete = (value: T): boolean => {
let found = false;
this.baseSet.forEach((x) => {
if (value['Equals'](x)) {
found = true;
this.baseSet.delete(x);
}
});
return found;
};
} else {
// This is fast - O(1): uses the Set directly, but Set does not use 'Equals()'.
// This approach is valid for value types and objects without 'Equals()'.
this.baseSetHas = (value: T): boolean => this.baseSet.has(value);
this.baseSetDelete = (value: T): boolean => this.baseSet.delete(value);
}
}
}
next(_value?: any): IteratorResult<T> {
if (this.nextResult.done) {
return this.nextResult;
}
while (!this.nextResult.done) {
if (this.returnCondition()) {
this.beforeReturn();
const return_result = this.nextResult;
this.nextResult = this.iterator.next();
return return_result;
}
this.nextResult = this.iterator.next();
}
return this.nextResult;
}
abstract returnCondition(): boolean;
abstract beforeReturn(): void;
}
class DistinctIterator<T> extends BaseDieIterator<T> {
constructor(private iterable: Iterable<T>) {
super(iterable, []);
}
returnCondition(): boolean {
return !this.baseSetHas(this.nextResult.value);
}
beforeReturn(): void {
this.baseSet.add(this.nextResult.value);
}
}
function getCompareFunction<T>(value: T): (x: any, y: any) => boolean {
let isEqual: (x: any, y: any) => boolean = null;
if (value && typeof value['Equals'] === 'function') {
isEqual = (left: T, right: T): boolean => left['Equals'](right);
} else {
isEqual = (left: T, right: T): boolean => left === right;
}
return isEqual;
}
/**
* Returns distinct elements from the iterable.
*
* @param iterable - The iterable source.
*/
export function iuDistinct<T>(
iterable: Iterable<T>,
comparer?: any
): Iterable<T> {
if (iterable == null) {
throw new Error('ArgumentNullException');
}
return {
[Symbol.iterator]() {
return new DistinctIterator<T>(iterable);
},
};
}
class IntersectIterator<T> extends BaseDieIterator<T> {
constructor(private first: Iterable<T>, private second: Iterable<T>) {
super(first, second);
}
returnCondition(): boolean {
return this.baseSetHas(this.nextResult.value);
}
beforeReturn(): void {
this.baseSetDelete(this.nextResult.value);
}
}
/**
* Returns the set intersection of two iterables.
*
* @param first
* @param second
*/
export function iuIntersect<T>(
first: Iterable<T>,
second: Iterable<T>,
comparer?: any
): Iterable<T> {
if (first == null || second == null) {
throw new Error('ArgumentNullException');
}
return {
[Symbol.iterator]() {
return new IntersectIterator<T>(first, second);
},
};
}
/**
* Defines a custom {Iterable<T>} object that will iterate thru two
* iterables by ignoring the ones in the second iterable that already exists in the
* first one.
*
* @class UnionIterator
* @implements {Iterable<T>}
* @template T
*/
class UnionIterator<T> implements Iterable<T> {
protected nextResult: IteratorResult<T, any>;
/**
* Creates an instance of UnionIterator for two iterable objects
* @param {Iterable<T>} first the iterable containing the first set of elements
* @param {Iterable<T>} second the iterable containing the second set of elements, the ones
* already in first will be discarded.
* @memberof UnionIterator
*/
constructor(private first: Iterable<T>, private second: Iterable<T>) {}
/**
* Defines the iterator for this class
*
* @return {*} {Iterator<T, any, any>}
* @memberof UnionIterator
*/
*[Symbol.iterator](): Iterator<T, any, any> {
for (const e of this.first) {
yield e;
}
for (const e of this.second) {
/* istanbul ignore else */
if (!iuContains(this.first, e)) {
yield e;
}
}
}
}
/**
* Iterates thru the elements of two iterables by disarding the duplicated
* ones. Default comparison is done using the standard '===' comparison operator
*
* @export
* @template T
* @param {Iterable<T>} first the iterable containing the first set of elements
* @param {Iterable<T>} second the iterable containing the second set of elements, the ones
* already in first will be discarded.
* @param {*} [comparer] The function used to compared elements. Currently not supported.
* @return {*} {Iterable<T>}
*/
export function iuUnion<T>(
first: Iterable<T>,
second: Iterable<T>,
comparer?: any
): Iterable<T> {
if (first == null || second == null) {
throw new Error('ArgumentNullException');
}
return new UnionIterator<T>(first, second);
}
class ExceptIterator<T> extends BaseDieIterator<T> {
constructor(private first: Iterable<T>, private second: Iterable<T>) {
super(first, second);
}
returnCondition(): boolean {
return !this.baseSetHas(this.nextResult.value);
}
beforeReturn(): void {
this.baseSet.add(this.nextResult.value);
}
}
/**
* Returns the set difference of two iterables.
*
* @param first - base iterable.
* @param second - the iterable to substract.
*/
export function iuExcept<T>(
first: Iterable<T>,
second: Iterable<T>
): Iterable<T> {
if (first == null || second == null) {
throw new Error('ArgumentNullException');
}
return {
[Symbol.iterator]() {
return new ExceptIterator<T>(first, second);
},
};
}
export function iuOrderBy<T>(
iterable: Iterable<T>,
criteria?: (e: T) => any
): IOrderedIterable<T>;
export function iuOrderBy<T, K>(
iterable: Iterable<T>,
criteria?: (e: T) => K,
comparer?: IComparer<K>
): IOrderedIterable<T>;
export function iuOrderBy<T>(
iterable: Iterable<T>,
criteria?: (e: T) => any,
comparer?: IComparer<any>
): IOrderedIterable<T> {
return new IterableForSorting(iterable, criteria, comparer);
}
export function iuOrderByDescending<T>(
iterable: Iterable<T>,
criteria?: (e: T) => any
): IOrderedIterable<T>;
export function iuOrderByDescending<T, K>(
iterable: Iterable<T>,
criteria?: (e: T) => K,
comparer?: IComparer<K>
): IOrderedIterable<T>;
export function iuOrderByDescending<T>(
iterable: Iterable<T>,
criteria?: (e: T) => any,
comparer?: IComparer<any>
): IOrderedIterable<T> {
return new IterableForSorting(
iterable,
criteria,
new DescendingComparer(comparer)
);
}
class DefaultOrderByComparer implements IComparer<unknown> {
Compare(e1: unknown, e2: unknown): number {
if (typeof e1 == 'number' && typeof e2 == 'number') {
return e1 - e2;
} else if (e1 instanceof Date && e2 instanceof Date) {
return e1.getTime() - e2.getTime();
} else if (typeof e1 == 'string' && typeof e2 == 'string') {
return e1.localeCompare(e2);
} else if (typeof e1 === 'boolean' && typeof e2 === 'boolean') {
return +e1 - +e2;
} else {
// fail with equal
return 0;
}
}
}
class DescendingComparer<T> implements IComparer<T> {
constructor(private comparer: IComparer<T>) {
if (comparer == null) {
this.comparer = new DefaultOrderByComparer();
}
}
Compare(x: T, y: T): number {
return this.comparer.Compare(y, x); // Just reverse elements.
}
}
class IterableForSorting<T> implements IOrderedIterable<T> {
private criterias: ((e: T) => unknown)[] = [];
private comparers: IComparer<unknown>[] = [];
constructor(
private iterable: Iterable<T>,
criteria: (e: T) => unknown,
comparer?: IComparer<unknown>
) {
this.criterias.push(criteria);
this.AddComparer(comparer);
}
CreateOrderedIterable<K>(
keySelector: (e: T) => K,
comparer: IComparer<K>,
descending: boolean
): IOrderedIterable<T> {
Debugger.Throw('Method not implemented.');
return null;
}
[Symbol.iterator](): Iterator<T, any, undefined> {
// until we find a better approach we will be converting
// the collection to an array
const collection = [...this.iterable];
collection.sort((o1, o2) => {
for (let i = 0; i < this.criterias.length; i++) {
const e1 = this.criterias[i](o1);
const e2 = this.criterias[i](o2);
const result = this.comparers[i].Compare(e1, e2);
if (result !== 0) {
return result;
}
}
return 0;
});
return collection[Symbol.iterator]();
}
ThenBy(criteria: (e: T) => unknown, comparer?: IComparer<unknown>): void {
this.criterias.push(criteria);
this.AddComparer(comparer);
}
private AddComparer(comparer?: IComparer<unknown>): void {
if (comparer == null) {
this.comparers.push(new DefaultOrderByComparer());
} else {
this.comparers.push(comparer);
}
}
}
export function iuThenBy<T>(
iterable: Iterable<T>,
criteria?: (e: T) => any
): IOrderedIterable<T>;
export function iuThenBy<T, K>(
iterable: Iterable<T>,
criteria?: (e: T) => K,
comparer?: IComparer<K>
): IOrderedIterable<T>;
export function iuThenBy<T>(
iterable: Iterable<T>,
criteria?: (e: T) => any,
comparer?: IComparer<any>
): IOrderedIterable<T> {
(iterable as IterableForSorting<T>).ThenBy(criteria, comparer);
return iterable as IOrderedIterable<T>;
}
export function iuThenByDescending<T>(
iterable: Iterable<T>,
criteria?: (e: T) => any
): IOrderedIterable<T>;
export function iuThenByDescending<T, K>(
iterable: Iterable<T>,
criteria?: (e: T) => K,
comparer?: IComparer<K>
): IOrderedIterable<T>;
export function iuThenByDescending<T>(
iterable: Iterable<T>,
criteria?: (e: T) => any,
comparer?: IComparer<any>
): IOrderedIterable<T> {
(iterable as IterableForSorting<T>).ThenBy(
criteria,
new DescendingComparer(comparer)
);
return iterable as IOrderedIterable<T>;
}
export interface IGrouping<T, K> extends Iterable<T> {
Key: K;
}
class GroupByGrouping<T, K> extends SimpleList<T> implements IGrouping<T, K> {
public Key: K;
}
export function iuGroupBy<T, K>(
iterable: Iterable<T>,
keySelector: (e: T) => K
): Iterable<IGrouping<T, K>>;
export function iuGroupBy<T, K, V>(
iterable: Iterable<T>,
keySelector: (e: T) => K,
valueSelector: (e: T) => V
): Iterable<IGrouping<V, K>>;
export function iuGroupBy<T, K, V>(
iterable: Iterable<T>,
keySelector: (e: T) => K,
valueSelector?: (e: T) => V
): any {
const groups = new Map<string, GroupByGrouping<T | V, K>>();
for (const value of iterable) {
const rawKey = keySelector(value);
const key = (rawKey ?? '').toString();
let group: GroupByGrouping<T | V, K> = null;
if (groups.has(key)) {
group = groups.get(key);
} else {
group = new GroupByGrouping<T, K>();
groups.set(key, group);
group.Key = rawKey;
}
group.add(valueSelector ? valueSelector(value) : value);
}
return groups.values();
}
/**
* Gets a single element from the given iterable. If no predicate then the only element in iterable is returned,
* if more than one element then null is returned. If predicate has value then the only element matching the
* predicate is returned, if more than one matches or none then null is returned.
*
* @param iterable The {@link Iterable<T>} from where to extract the single element
* @param predicate a the predicate to apply to get the single element. If not predicate then the
* iterable value must contain exactly one element.
* @returns
*/
export function iuSingleOrDefault<T>(
iterable: Iterable<T>,
predicate?: (e: T) => boolean
) {
// no predicate, a single element iterable.
if (typeof predicate == 'undefined') {
const iterator = iterable[Symbol.iterator]();
const next = iterator.next();
if (!next.done) {
const result: T = next.value;
if (iterator.next().done) {
// checks for one element only
return result;
}
}
} else {
let matchingElement: T = null;
for (const e of iterable) {
const isMatch: boolean = predicate(e);
if (isMatch) {
if (matchingElement == null) {
matchingElement = e;
} else {
// more than one match returns null
throw new InvalidOperationException(
'more than one element in singleorDefault'
);
}
}
}
if (matchingElement != null) {
return matchingElement;
}
}
return null;
}
class FlattenIteratorWrapper<T, K, V> implements Iterator<V> {
private currentIterator: Iterator<V>;
constructor(
private mainIterator: Iterator<T>,
private func: (e: T) => Iterable<K>,
private resultSelector: (e: T, f: K) => V
) {}
next(value?: any): IteratorResult<V, any> {
if (this.currentIterator) {
const result = this.currentIterator.next();
if (!result.done) {
return result;
}
}
const nextInMain = this.mainIterator.next();
if (!nextInMain.done) {
this.currentIterator = iuSelect(
(innerSingleResult) =>
this.resultSelector(nextInMain.value, innerSingleResult),
this.func(nextInMain.value)
)[Symbol.iterator]();
// controversial recurisive call:
return this.next();
} else {
return { value: undefined, done: true };
}
}
}
export function iuSelectMany<T, K, V>(
func: (e: T) => Iterable<K>,
resultSelector: (e: T, f: K) => V,
iterable: Iterable<T>
): Iterable<V>;
export function iuSelectMany<T, K>(
func: (e: T) => Iterable<K>,
iterable: Iterable<T>
): Iterable<K>;
export function iuSelectMany<T, K, V>(
p1: unknown,
p2: unknown,
p3?: unknown
): unknown {
if (typeof p3 !== 'undefined') {
const iterable = p3 as Iterable<T>;
const func = p1 as (e: T) => Iterable<K>;
const resultSelector = p2 as (e: T, f: K) => V;
return {
[Symbol.iterator]() {
return new FlattenIteratorWrapper(
iterable[Symbol.iterator](),
func,
resultSelector
);
},
};
} else {
const iterable = p2 as Iterable<T>;
const func = p1 as (e: T) => Iterable<K>;
return {
[Symbol.iterator]() {
return new FlattenIteratorWrapper(
iterable[Symbol.iterator](),
func,
(e, f) => f
);
},
};
}
}
class RangeIterator implements Iterator<number> {
constructor(private current: number, private count: number) {}
next(value?: any): IteratorResult<number, any> {
if (this.count > 0) {
this.count--;
return { value: this.current++, done: false };
} else {
return { value: undefined, done: true };
}
}
}
export function iuRange(start: number, count: number): Iterable<number> {
return {
[Symbol.iterator]() {
return new RangeIterator(start, count);
},
};
}
const emptyIterable = {
[Symbol.iterator]() {
return { next: () => ({ done: true, value: undefined }) };
},
};
export function iuEmpty<T>(): Iterable<T> {
return emptyIterable;
}
export function iuAsEnumerable<T>(iterable: Iterable<T>): Iterable<T> {
return iterable;
}
export function iuCast<T>(iterable: Iterable<unknown>): Iterable<T> {
// The following code needs more work to avoid wrong conversions
// In typescript we will not get cast exceptions
return iuSelect((x) => x as T, iterable);
}
export function wrapArrayWithList<T>(arr: T[]): IList<T> {
const result = new SimpleList<T>();
result.internalArray = arr;
return result;
}
export function iuMax<T>(iterable: Iterable<T>): T;
export function iuMax<T, K>(
iterable: Iterable<T>,
valueSelector: (item: T) => K
): K;
export function iuMax<T, K>(
iterable: Iterable<T>,
valueSelector?: (item: T) => K
): K {
let max: K = null;
for (const item of iterable) {
const value = valueSelector ? valueSelector(item) : (item as unknown as K);
if (max === null) {
max = value;
}
if (value > max) {
max = value;
}
}
return max;
}
export function iuMin<T>(
iterable: Iterable<T>,
valueSelector?: (item: T) => number
) {
let min = Number.MAX_VALUE;
for (const item of iterable) {
const value = valueSelector
? valueSelector(item)
: (item as unknown as number);
if (value < min) {
min = value;
}
}
return min;
}
export function iuSum<T>(
iterable: Iterable<T>,
valueSelector: (item: T) => number
) {
let result = 0;
for (const item of iterable) {
const value = valueSelector(item);
result += value;
}
return result;
}
export function iuOfType<K>(
iterable: Iterable<unknown>,
type: any
): Iterable<K> {
// notices that runtime verification of interface types checking is still pending
return iuWhere(
(obj) => obj instanceof type,
iterable
) as unknown as Iterable<K>;
}
export function iuGetUntypedIterator<T>(iterable: Iterable<T>): any {
Debugger.Throw('Not implemented');
}
function* joinGenerator<TInner, TOuter, TKey, TResult>(
iterable: Iterable<TInner>,
iterable2: Iterable<TOuter>,
innerSelector: (inner: TInner) => TKey,
outerSelector: (outer: TOuter) => TKey,
resultSelector: (inner: TInner, outer: TOuter) => TResult
) {
for (const x of iterable) {
const x_key = innerSelector(x);
for (const y of iterable2) {
const y_key = outerSelector(y);
const compare = getCompareFunction(x_key);
if (compare(x_key, y_key)) {
yield resultSelector(x, y);
}
}
}
}
export function iuJoin<TInner, TOuter, TKey, TResult>(
iterable: Iterable<TInner>,
iterable2: Iterable<TOuter>,
innerSelector: (inner: TInner) => TKey,
outerSelector: (outer: TOuter) => TKey,
resultSelector: (inner: TInner, outer: TOuter) => TResult
): Iterable<TResult> {
return {
[Symbol.iterator]() {
return joinGenerator(
iterable,
iterable2,
innerSelector,
outerSelector,
resultSelector
);
},
};
}
/**
* Apply an operation to each element of an Iterable
*
* @export
* @template T
* @param {Iterable<T>} iterable iterable to process
* @param {(e: T, i? : number) => void} func opeartion to apply
*/
export function iuForEach<T>(
iterable: Iterable<T>,
func: (e: T, i?: number) => void
): void {
for (const element of iterable) {
func(element);
}
}
/**
* Adds the contents of an iterable to the given collection
*
* @export
* @template T
* @param {ObjectModelCollection<T>} collection to modified
* @param {Iterable<T>} newElements to add
*/
export function iuAddRange<T>(
collection: ObjectModelCollection<T>,
newElements: Iterable<T>
) {
for (const obj of newElements) {
collection.add(obj);
}
}