# Spec SorterSpec
Sorts all elements using a custom compare function.

Extends | Pool
All Extended | Pool
All Subcl's | SorterConfig, SorterConfigSize
Defined in | <seqan/pipe.h>
Signature | `template <typename TValue, typename TConfig> struct Pool<TValue, SorterSpec<TConfig > >;`

## Template Parameters

`TConfig` | Configuration Spec. Defines compare function, size type, and file type.
`TValue` | The value type, that is the type of the stream elements.

## Interface Function Overview

### Interface Functions Inherited From Pool

- `assign`
- `atEnd`
- `beginRead`
- `beginWrite`
- `clear`
- `endRead`
- `endWrite`
- `front`
- `length`
- `pop`
- `push`
- `resize`

## Detailed Description

The Pool's input/output type is `TValue` and the size type is determined by the `TConfig`.

If there exists an explicit function mapping input elements to their destined positions in the output stream, MapperSpec should be preferred.

### Example

    #include <functional>
    #include <iostream>

    #include <seqan/basic.h>
    #include <seqan/sequence.h>
    #include <seqan/pipe.h>

    using namespace seqan;

    // Custom 3-way comparator functor.  Return a value </==/> 0 (less than, equal
    // to, greater than).
    struct MyIntLessCmp :
        std::binary_function<int, int, int>
    {
        int operator()(int const & lhs, int const & rhs) const
        {
            return lhs - rhs;
        }

    };

    int main()
    {
        typedef MyIntLessCmp                     TLess;
        typedef SorterSpec<SorterConfig<TLess> > TSorterSpec;
        typedef Pool<int, TSorterSpec>           TSorterPool;

        // Fill the sorter pool.
        TSorterPool sorterPool;
        resize(sorterPool, 3);
        beginWrite(sorterPool);
        push(sorterPool, 3);
        push(sorterPool, 10);
        push(sorterPool, -1);
        endWrite(sorterPool);

        // Fetch the resorted elements from the pool and print to stdout.
        std::cout << "Sorted elements:\n";
        beginRead(sorterPool);
        for (; !eof(sorterPool); pop(sorterPool))
            std::cout << front(sorterPool) << "\n";
        endRead(sorterPool);

        return 0;
    }

Demo: demos/dox/pipe/pool_sorter.cpp

    Sorted elements:
    -1
    3
    10

#### Dox Sources

    /*!
     * @class SorterSpec
     *
     * @extends Pool
     *
     * @headerfile <seqan/pipe.h>
     *
     * @brief Sorts all elements using a custom compare function.
     *
     * @signature template <typename TValue, typename TConfig> struct Pool<TValue,
     *            SorterSpec<TConfig > >;
     *
     * @tparam TConfig Configuration Spec. Defines compare function, size type, and
     *                 file type.
     * @tparam TValue The value type, that is the type of the stream elements.
     *
     * The Pool's input/output type is <tt>TValue</tt> and the size type is
     * determined by the <tt>TConfig</tt>.
     *
     * If there exists an explicit function mapping input elements to their destined
     * positions in the output stream, @link MapperSpec @endlink should be
     * preferred.
     *
     * @section Example
     *
     * @include demos/dox/pipe/pool_sorter.cpp
     *
     * @code{.console}
     * Sorted elements:
     * -1
     * 3
     * 10
     * @endcode
     */