/**
* Copyright 2017-2020 Plexus Interop Deutsche Bank AG
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { ExtendedMap } from './collections/ExtendedMap';
export class Arrays {
public static concatenateBuffers(...buffers: ArrayBuffer[]): ArrayBuffer {
const totalLength = buffers.reduce((acc, b) => acc + b.byteLength, 0);
const result = new Uint8Array(totalLength);
let offset = 0;
buffers.forEach(b => {
result.set(new Uint8Array(b), offset);
offset += b.byteLength;
});
return result.buffer;
}
public static toArrayBuffer(typedArray: Uint8Array): ArrayBuffer {
return new Uint8Array(typedArray).buffer;
}
}
export function arrayBufferToString(buf: ArrayBuffer): string {
let binaryString = '';
let bytes = new Uint8Array(buf);
const length = bytes.length;
for (let i = 0; i < length; i++) {
binaryString += String.fromCharCode(bytes[i]);
}
return binaryString;
}
export function stringToArrayBuffer(str: string): ArrayBuffer {
const buf = new ArrayBuffer(str.length);
const bufView = new Uint8Array(buf);
for (let i = 0, strLen = str.length; i < strLen; i++) {
bufView[i] = str.charCodeAt(i);
}
return buf;
}
export function concat<T>(x: T[], y: T[]): T[] {
return x.concat(y);
}
export function flatMap<T, R>(f: (el: T) => R[], array: T[]): R[] {
return array.map(f).reduce<R[]>(concat, []);
}
export function join<T, R, Y>(first: T[], second: R[], joinFn: (x: T, y: R) => Y, Ipredicate: (x: T, y: R) => boolean = () => true): Y[] {
const result: Y[] = [];
first.forEach(x => second.forEach(y => {
if (predicate(x, y)) {
result.push(joinFn(x, y));
}
}));
return result;
}
export function distinct<T>(array: T[], key: (x: T) => any): T[] {
const seen = new Set();
return array.filter(item => {
const k = key(item);
return seen.has(k) ? false : seen.add(k);
});
}
export function toMap<T, K, V>(array: T[], keyFn: (v: T) => K, vFn: (v: T) => V): ExtendedMap<K, V> {
const result = ExtendedMap.create<K, V>();
array.forEach(v => result.set(keyFn(v), vFn(v)));
return result;
} |