IHashContainer.ts

//================================================================ 
/**
 * @packageDocumentation
 * @module std.internal  
 */
//================================================================
import { IAssociativeContainer } from "./IAssociativeContainer";

import { IContainer } from "../../../base/container/IContainer";
import { Hasher } from "../../functional/Hasher";
import { BinaryPredicator } from "../../functional/BinaryPredicator";

import { hash } from "../../../functional/hash";
import { equal_to } from "../../../functional/comparators";

/**
 * Common interface for hash containers
 * 
 * @author Jeongho Nam - https://github.com/samchon
 */
export interface IHashContainer<Key, T extends Elem, 
        SourceT extends IHashContainer<Key, T, SourceT, IteratorT, ReverseIteratorT, Elem>, 
        IteratorT extends IContainer.Iterator<T, SourceT, IteratorT, ReverseIteratorT, Elem>,
        ReverseIteratorT extends IContainer.ReverseIterator<T, SourceT, IteratorT, ReverseIteratorT, Elem>,
        Elem>
    extends IAssociativeContainer<Key, T, SourceT, IteratorT, ReverseIteratorT, Elem>
{
    /* ---------------------------------------------------------
        PREDICATORS
    --------------------------------------------------------- */
    /**
     * Get hash function.
     * 
     * @return The hash function.
     */
    hash_function(): Hasher<Key>;

    /**
     * Get key equality predicator.
     * 
     * @return The key equality predicator.
     */
    key_eq(): BinaryPredicator<Key>;

    /* ---------------------------------------------------------
        GETTERS
    --------------------------------------------------------- */
    /**
     * Compute bucket index for the *key*.
     * 
     * @param key Target key.
     * @return Index number.
     */
    bucket(key: Key): number;

    /**
     * Get number of buckets.
     */
    bucket_count(): number;

    /**
     * Get size of a specific bucket.
     * 
     * @param index Specific position.
     * @return Size of the specific bucket.
     */
    bucket_size(index: number): number;

    /**
     * Compute load factor.
     * 
     * @return `this.size() / this.bucket_count()`
     */
    load_factor(): number;

    /**
     * Get maximum load factor that allowable.
     * 
     * @return The maximum load factor.
     */
    max_load_factor(): number;

    /* ---------------------------------------------------------
        SETTERS
    --------------------------------------------------------- */
    /**
     * Set maximum load factor.
     * 
     * @param z The new value to change.
     */
    max_load_factor(z: number): void;

    /**
     * Reserve buckets enable to store *n* elements.
     * 
     * @param n The capacity to reserve.
     */
    reserve(n: number): void;
    
    /**
     * Change of bucktes.
     * 
     * @param n The number to change.
     */
    rehash(n: number): void;
}

export namespace IHashContainer
{
    /**
     * @internal
     */
    export function construct<Key, T extends Elem, 
            SourceT extends IHashContainer<Key, T, SourceT, IteratorT, ReverseIteratorT, Elem>, 
            IteratorT extends IContainer.Iterator<T, SourceT, IteratorT, ReverseIteratorT, Elem>,
            ReverseIteratorT extends IContainer.ReverseIterator<T, SourceT, IteratorT, ReverseIteratorT, Elem>,
            Elem>
        (
            source: SourceT, 
            Source: Factory<SourceT>, 
            bucketFactory: (hasher: Hasher<Key>, predicator: BinaryPredicator<Key>) => void, 
            ...args: any[]
        )
    {
        // DECLARE MEMBERS
        let post_process: (() => void) | null = null;
        let hash_function: Hasher<Key> = hash;
        let key_eq: BinaryPredicator<Key> = equal_to;

        //----
        // INITIALIZE MEMBERS AND POST-PROCESS
        //----
        // BRANCH - METHOD OVERLOADINGS
        if (args.length === 1 && args[0] instanceof Source)
        {
            // PARAMETERS
            const container: SourceT = args[0];
            hash_function = container.hash_function();
            key_eq = container.key_eq();

            // COPY CONSTRUCTOR
            post_process = () =>
            {
                const first = container.begin();
                const last = container.end();

                source.assign(first, last);
            };
        }
        else
        {
            const tuple = IAssociativeContainer.construct(source, ...args);

            post_process = tuple.ramda;
            if (tuple.tail.length >= 1)    hash_function = tuple.tail[0];
            if (tuple.tail.length >= 2) key_eq = tuple.tail[1];
        }

        //----
        // DO PROCESS
        //----
        // CONSTRUCT BUCKET
        bucketFactory(hash_function, key_eq);

        // ACT POST-PROCESS
        if (post_process !== null)
            post_process();
    }

    /**
     * @internal
     */
    interface Factory<T, Arguments extends any[] = any[]>
    {
        new(...args: Arguments): T;
        prototype: T;
    }
}