factory.ts

//================================================================ 
/**
 * @packageDocumentation
 * @module std  
 */
//================================================================
import { IBidirectionalContainer } from "../ranges/container/IBidirectionalContainer";
import { IReversableIterator } from "./IReversableIterator";
import { IReverseIterator } from "./IReverseIterator";

import { IPointer } from "../functional/IPointer";
import { IForwardContainer } from "../ranges/container/IForwardContainer";
import { IInsert } from "../internal/container/partial/IInsert";
import { IPushFront } from "../internal/container/partial/IPushFront";
import { IPushBack } from "../internal/container/partial/IPushBack";

import { InsertIterator } from "./InsertIterator";
import { FrontInsertIterator } from "./FrontInsertIterator";
import { BackInsertIterator } from "./BackInsertIterator";
import { IForwardIterator } from "./IForwardIterator";
import { Vector } from "../container/Vector";

/* ---------------------------------------------------------
    ITERATORS
--------------------------------------------------------- */
// BEGIN & END
//----
/**
 * Iterator to the first element.
 * 
 * @param container Target container.
 * @return Iterator to the first element.
 */
export function begin<Container extends Array<any> | IForwardContainer<any>>
    (container: Container): IForwardContainer.IteratorType<Container>;

export function begin<T>(container: Array<T> | Vector<T>): Vector.Iterator<T>
{
    if (container instanceof Array)
        container = Vector.wrap(container);
    return container.begin();
}

/**
 * Iterator to the end.
 * 
 * @param container Target container.
 * @return Iterator to the end.
 */
export function end<Container extends Array<any> | IForwardContainer<any>>
    (container: Container): IForwardContainer.IteratorType<Container>;

export function end<T>(container: Array<T> | Vector<T>): Vector.Iterator<T>
{
    if (container instanceof Array)
        container = Vector.wrap(container);
    return container.end();
}

/**
 * Get reverse iterator to the first element in reverse.
 * 
 * @param container Target container.
 * @return The reverse iterator to the first.
 */
export function rbegin<Container extends Array<any> | IBidirectionalContainer<any, any>>
    (container: Container): IBidirectionalContainer.ReverseIteratorType<Container>;

export function rbegin<T>(container: Array<T> | Vector<T>): Vector.ReverseIterator<T>
{
    if (container instanceof Array)
        container = Vector.wrap(container);
    return container.rbegin();
}

/**
 * Get reverse iterator to the reverse end.
 * 
 * @param container Target container.
 * @return The reverse iterator to the end.
 */
export function rend<Container extends Array<any> | IBidirectionalContainer<any, any>>
    (container: Container): IBidirectionalContainer.ReverseIteratorType<Container>;

export function rend<T>(container: Array<T> | Vector<T>): Vector.ReverseIterator<T>
{
    if (container instanceof Array)
        container = Vector.wrap(container);
    return container.rend();
}

/**
 * Construct reverse iterator.
 * 
 * @param it Target iterator that reversable.
 * @return The reverse iterator object.
 */
export function make_reverse_iterator<
        IteratorT extends IReversableIterator<IPointer.ValueType<IteratorT>, IteratorT, ReverseT>, 
        ReverseT extends IReverseIterator<IPointer.ValueType<IteratorT>, IteratorT, ReverseT>>
    (it: IteratorT): ReverseT
{
    return it.reverse();
}

/* ---------------------------------------------------------
    INSERTERS
--------------------------------------------------------- */
/**
 * Construct insert iterator.
 * 
 * @param container Target container.
 * @param it Iterator to the first insertion position.
 * @return The {@link InsertIterator insert iterator} object.
 */
export function inserter<
        Container extends IInsert<Iterator>,
        Iterator extends IForwardIterator<IPointer.ValueType<Iterator>, Iterator>>
    (container: Container, it: Iterator): InsertIterator<Container, Iterator>
{    
    return new InsertIterator(container, it);
}

/**
 * Construct front insert iterator.
 * 
 * @param source Target container.
 * @return The {@link FrontInsertIterator front insert iterator} object.
 */
export function front_inserter<Source extends IPushFront<FrontInsertIterator.ValueType<Source>>>
    (source: Source): FrontInsertIterator<Source>
{
    return new FrontInsertIterator(source);
}

/**
 * Construct back insert iterator.
 * 
 * @param source Target container.
 * @return The {@link back insert iterator} object.
 */
export function back_inserter<Source extends Array<any> | IPushBack<any>>
    (source: Source): BackInsertIterator<BackInsertIterator.SourceType<Source>>;

export function back_inserter<T>(source: Array<T> | Vector<T>): BackInsertIterator<Vector<T>>
{
    if (source instanceof Array)
        source = Vector.wrap(source);
    return new BackInsertIterator(source);
}