Spaces:
Sleeping
Sleeping
File size: 2,858 Bytes
be5030f |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
import { Data } from '../data';
import { DataType, Dictionary } from '../type';
import { AbstractVector, Vector } from '../vector';
import { Clonable, Sliceable, Applicative } from '../vector';
/** @ignore */
declare type ChunkedDict<T extends DataType> = T extends Dictionary ? Vector<T['dictionary']> : null | never;
/** @ignore */
declare type ChunkedKeys<T extends DataType> = T extends Dictionary ? Vector<T['indices']> | Chunked<T['indices']> : null | never;
/** @ignore */
export declare type SearchContinuation<T extends Chunked> = (column: T, chunkIndex: number, valueIndex: number) => any;
/** @ignore */
export declare class Chunked<T extends DataType = any> extends AbstractVector<T> implements Clonable<Chunked<T>>, Sliceable<Chunked<T>>, Applicative<T, Chunked<T>> {
/** @nocollapse */
static flatten<T extends DataType>(...vectors: (Vector<T> | Vector<T>[])[]): Vector<T>[];
/** @nocollapse */
static concat<T extends DataType>(...vectors: (Vector<T> | Vector<T>[])[]): Chunked<T>;
protected _type: T;
protected _length: number;
protected _chunks: Vector<T>[];
protected _numChildren: number;
protected _children?: Chunked[];
protected _nullCount: number;
protected _chunkOffsets: Uint32Array;
constructor(type: T, chunks?: Vector<T>[], offsets?: Uint32Array);
readonly type: T;
readonly length: number;
readonly chunks: Vector<T>[];
readonly typeId: T['TType'];
readonly VectorName: string;
readonly data: Data<T>;
readonly ArrayType: any;
readonly numChildren: number;
readonly stride: number;
readonly byteLength: number;
readonly nullCount: number;
protected _indices?: ChunkedKeys<T>;
readonly indices: ChunkedKeys<T> | null;
readonly dictionary: ChunkedDict<T> | null;
[Symbol.iterator](): IterableIterator<T['TValue'] | null>;
clone(chunks?: Vector<T>[]): Chunked<T>;
concat(...others: Vector<T>[]): Chunked<T>;
slice(begin?: number, end?: number): Chunked<T>;
getChildAt<R extends DataType = any>(index: number): Chunked<R> | null;
search(index: number): [number, number] | null;
search<N extends SearchContinuation<Chunked<T>>>(index: number, then?: N): ReturnType<N>;
isValid(index: number): boolean;
get(index: number): T['TValue'] | null;
set(index: number, value: T['TValue'] | null): void;
indexOf(element: T['TValue'], offset?: number): number;
toArray(): T['TArray'];
protected getInternal({ _chunks }: Chunked<T>, i: number, j: number): T["TValue"] | null;
protected isValidInternal({ _chunks }: Chunked<T>, i: number, j: number): boolean;
protected indexOfInternal({ _chunks }: Chunked<T>, chunkIndex: number, fromIndex: number, element: T['TValue']): number;
protected _sliceInternal(self: Chunked<T>, begin: number, end: number): Chunked<T>;
}
export {};
|