org.osgl.util.algo

Class ArraySortBase<T>

java.lang.Object

org.osgl.util.algo.ArraySortBase<T>

All Implemented Interfaces:

Lang.Func4<T[],Integer,Integer,Comparator<T>,T[]>, Algorithm, ArrayAlgorithm, ArraySort<T>

Direct Known Subclasses:

ArrayInsertionSort, ArrayMergeSort, ArraySimpleInsertionSort

public abstract class ArraySortBase<T>
extends Object
implements ArraySort<T>

Created with IntelliJ IDEA. User: luog Date: 12/11/13 Time: 11:09 PM To change this template use File | Settings | File Templates.

Nested Class Summary

Nested classes/interfaces inherited from interface org.osgl.util.algo.ArrayAlgorithm

ArrayAlgorithm.Util

Constructor Summary

Constructors

Constructor and Description
ArraySortBase()

Method Summary

Modifier and Type	Method and Description
T[]	apply(T[] ts, Integer from, Integer to, Comparator<T> comp) Run the function with parameters specified.
T[]	sort(T[] ts, int from, int to, Comparator<T> comp)
protected abstract T[]	sort0(T[] ts, int from, int to, Comparator<T> comp, T[] newTs)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ArraySortBase

public ArraySortBase()

Method Detail

apply

public final T[] apply(T[] ts,
                       Integer from,
                       Integer to,
                       Comparator<T> comp)
                throws NotAppliedException,
                       Lang.Break

Description copied from interface: Lang.Func4

Run the function with parameters specified.

In case implementing a partial function, it can throw out an NotAppliedException if the function is not defined for the given parameter(s)

Specified by:

apply in interface Lang.Func4<T[],Integer,Integer,Comparator<T>,T[]>

Parameters:

ts - the first argument

from - the second argument

to - the third argument

comp - the fourth argument

Returns:

whatever value of type R

Throws:

NotAppliedException - if the function doesn’t apply to the parameter(s)

Lang.Break - to short cut collecting operations (fold/reduce) on an container

sort0

protected abstract T[] sort0(T[] ts,
                             int from,
                             int to,
                             Comparator<T> comp,
                             T[] newTs)

sort

public final T[] sort(T[] ts,
                      int from,
                      int to,
                      Comparator<T> comp)

Specified by:

sort in interface ArraySort<T>