OrderedAlphabetConcept - SeqAn API Documentation

# Concept OrderedAlphabetConcept
Totally strict ordered alphabet.

Extends | AlphabetConcept, ComparableConcept
All Extended | AlphabetConcept, AssignableConcept, ComparableConcept, CopyConstructibleConcept, DefaultConstructibleConcept, EqualityComparableConcept, LessThanComparableConcept
All Subcl's | FiniteOrderedAlphabetConcept
Defined in | <seqan/basic.h>
Signature | `concept OrderedAlphabetConcept;`

## Member Function Overview

- `bool OrderedAlphabetConcept::operator<(other);`
  Less-than operator.

### Member Functions Inherited From AssignableConcept

- `operator=`

### Member Functions Inherited From ComparableConcept

- `operator>`

### Member Functions Inherited From EqualityComparableConcept

- `operator!=`
- `operator==`

### Member Functions Inherited From LessThanComparableConcept

- `operator<`

## Interface Function Overview

- `T infimumValueImpl(valuePointerTag);`
  Implements minValue.
- `T maxValue<T>();`
  Supremum for a given type.
- `T minValue<T>();`
  Infimum for a given type.
- `T supremumValueImpl(valuePointerTag);`
  Implements maxValue.

### Interface Functions Inherited From AssignableConcept

- `assign`
- `move`
- `set`

### Interface Functions Inherited From ComparableConcept

- `operator<=`
- `operator>=`

## Interface Metafunction Overview

- `MaxValue<T>::VALUE`
  Supremum for a given type.
- `MinValue<T>::VALUE`
  Infimum for a given type.

### Interface Metafunctions Inherited From AlphabetConcept

- `BitsPerValue`

## Member Functions Detail

### `bool OrderedAlphabetConcept::operator<(other);`

Less-than operator.

#### Parameters

`other` | Object of the same type to compare to this.

#### Returns

`bool` | True in case of this object being smaller than `other`

#### Data Races

If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

## Interface Functions Detail

### `T infimumValueImpl(valuePointerTag);`

Deprecated.

Will be removed in favour of MinValue.

Implements minValue.

#### Parameters

`valuePointerTag` | A pointer that is used as a tag to specify the value type. The pointer needs not to point to a valid object, so it is possible to use a null pointer here.

#### Returns

`T` | A value `inf` that holds: `inf <= i` for all values `i`.

This function implements minValue. It is recommended to use minValue rather than `infimumValueImpl`.

#### Status

#### Data Races

If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

#### See Also

- minValue

### `T maxValue<T>();`

Deprecated.

Will be removed in favour of MaxValue.

Supremum for a given type.

#### Template Parameters

`T` | The type to get the max value of.

#### Returns

`T` | A value `inf` that holds: `inf >= i` for all values `i` of type `T`.

The function is implemented in supremumValueImpl. Do not specialize `maxValue`, specialize supremumValueImpl instead!

#### Status

#### Data Races

If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

#### See Also

- MaxValue
- minValue
- supremumValueImpl

### `T minValue<T>();`

Deprecated.

Will be removed in favour of MinValue.

Infimum for a given type.

#### Template Parameters

`T` | An ordered type.

#### Returns

`T` | A value `inf` that holds: `inf <= i` for all values `i` of type `T`.

The function is implemented in infimumValueImpl. Do not specialize `minValue`, specialize infimumValueImpl instead!

#### Status

#### Data Races

If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

#### See Also

- MinValue
- infimumValueImpl
- maxValue

### `T supremumValueImpl(valuePointerTag);`

Deprecated.

Will be removed in favour of MaxValue.

Implements maxValue.

#### Parameters

`valuePointerTag` | A pointer that is used as a tag to specify the value type. The pointer needs not to point to a valid object, so it is possible to use a null pointer here.

#### Returns

`T` | A value `inf` that holds: `inf >= i` for all values `i`.

This function implements OrderedAlphabetConcept#maxValue. It is recommended to use OrderedAlphabetConcept#maxValue rather than `supremumValueImpl`.

#### Status

#### Data Races

If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

#### See Also

- maxValue

## Interface Metafunctions Detail

### `MaxValue<T>::VALUE`

Supremum for a given type.

#### Template Parameters

`T` | An ordered type.

#### Returns

`VALUE` | The largest value that `T` can represent.

### `MinValue<T>::VALUE`

Infimum for a given type.

#### Template Parameters

`T` | An ordered type.

#### Returns

`VALUE` | The smallest value that `T` can represent.

#### Dox Sources

    /*!
     * @concept OrderedAlphabetConcept
     *
     * @headerfile <seqan/basic.h>
     *
     * @extends AlphabetConcept
     * @extends ComparableConcept
     *
     * @brief Totally strict ordered alphabet.
     *
     * @signature concept OrderedAlphabetConcept;
     *
     * @mfn OrderedAlphabetConcept#MaxValue
     *
     * @headerfile <seqan/basic.h>
     *
     * @brief Supremum for a given type.
     *
     * @signature MaxValue<T>::VALUE
     *
     * @tparam T An ordered type.
     *
     * @return VALUE The largest value that <tt>T</tt> can represent.
     *
     * @see OrderedAlphabetConcept#maxValue
     *
     * @mfn OrderedAlphabetConcept#MinValue
     *
     * @headerfile <seqan/basic.h>
     *
     * @brief Infimum for a given type.
     *
     * @signature MinValue<T>::VALUE
     *
     * @tparam T An ordered type.
     *
     * @return VALUE The smallest value that <tt>T</tt> can represent.
     *
     * @see OrderedAlphabetConcept#minValue
     *
     * @fn OrderedAlphabetConcept::operator<
     *
     * @brief Less-than operator.
     *
     * @signature bool OrderedAlphabetConcept::operator<(other);
     *
     * @param[in] other Object of the same type to compare to this.
     *
     * @return bool True in case of this object being smaller than <tt>other</tt>
     *
     * @fn OrderedAlphabetConcept#supremumValueImpl
     *
     * @brief Implements maxValue.
     *
     * @deprecated Will be removed in favour of MaxValue.
     *
     * @signature T supremumValueImpl(valuePointerTag);
     *
     * @param[in] valuePointerTag A pointer that is used as a tag to specify the
     *                            value type. The pointer needs not to point to a
     *                            valid object, so it is possible to use a null
     *                            pointer here.
     *
     * @return T A value <tt>inf</tt> that holds: <tt>inf &gt;= i</tt> for all
     *           values <tt>i</tt>.
     *
     * This function implements OrderedAlphabetConcept#maxValue. It is recommended
     * to use OrderedAlphabetConcept#maxValue rather than
     * <tt>supremumValueImpl</tt>.
     *
     * @section Status
     *
     * @see OrderedAlphabetConcept#maxValue
     *
     * @fn OrderedAlphabetConcept#maxValue
     *
     * @brief Supremum for a given type.
     *
     * @deprecated Will be removed in favour of MaxValue.
     *
     * @signature T maxValue<T>();
     *
     * @tparam T The type to get the max value of.
     *
     * @return T A value <tt>inf</tt> that holds: <tt>inf >= i</tt> for all values
     *           <tt>i</tt> of type <tt>T</tt>.
     *
     * The function is implemented in supremumValueImpl. Do not specialize
     * <tt>maxValue</tt>, specialize supremumValueImpl instead!
     *
     * @section Status
     *
     * @see OrderedAlphabetConcept#supremumValueImpl
     * @see OrderedAlphabetConcept#minValue
     * @see OrderedAlphabetConcept#MaxValue
     *
     * @fn OrderedAlphabetConcept#infimumValueImpl
     *
     * @brief Implements minValue.
     *
     * @deprecated Will be removed in favour of MinValue.
     *
     * @signature T infimumValueImpl(valuePointerTag);
     *
     * @param[in] valuePointerTag A pointer that is used as a tag to specify the
     *                            value type. The pointer needs not to point to a
     *                            valid object, so it is possible to use a null
     *                            pointer here.
     *
     * @return T A value <tt>inf</tt> that holds: <tt>inf &lt;= i</tt> for all
     *           values <tt>i</tt>.
     *
     * This function implements minValue. It is recommended to use minValue rather
     * than <tt>infimumValueImpl</tt>.
     *
     * @section Status
     *
     * @see OrderedAlphabetConcept#minValue
     *
     * @fn OrderedAlphabetConcept#minValue
     *
     * @brief Infimum for a given type.
     *
     * @deprecated Will be removed in favour of MinValue.
     *
     * @signature T minValue<T>();
     *
     * @tparam T An ordered type.
     *
     * @return T A value <tt>inf</tt> that holds: <tt>inf &lt;= i</tt> for all
     *           values <tt>i</tt> of type <tt>T</tt>.
     *
     * The function is implemented in infimumValueImpl. Do not specialize
     * <tt>minValue</tt>, specialize infimumValueImpl instead!
     *
     * @section Status
     *
     * @see OrderedAlphabetConcept#infimumValueImpl
     * @see OrderedAlphabetConcept#maxValue
     * @see OrderedAlphabetConcept#MinValue
     */