Units and Versions

Integer Indexes, Amounts, Offsets and Ranges

Representation and Construction

Include each concrete unit type through its own public header, such as <erbsland/ArgumentIndex.hpp> or <erbsland/ArgumentCount.hpp>. ArgumentUnit.hpp declares only the shared argument-unit tag.

Positional unit tags identify the coordinate system without configuring storage. Indexes and amounts use unsigned 64-bit values; offsets use signed 64-bit values. The largest unsigned value is reserved for noIndex() or infinite(). maximum() is always the largest finite value.

Numeric constructors are consteval: ByteIndex{12} and ByteIndex(12) both validate their input at compile time. Native integer types other than bool are accepted, but floating-point inputs, negative indexes or amounts, and numeric sentinel values are rejected. Negative offsets are valid, including the signed minimum. Default construction produces zero; copying typed values remains available at runtime.

For runtime integers, fromInteger(value) saturates into the finite domain and fromIntegerOrThrow(value) throws OverflowError outside that domain. Use noIndex() and infinite() explicitly to create special states. fromSizeT() and fromSizeTOrThrow() follow the same rules. Extraction through toSizeTOrThrow() checks representability only: it does not reject a sentinel that fits.

Movement and Distances

Move indexes by matching amounts with advance() and retreat(), or by signed offsets with move(). Their copy variants are advanced(), retreated(), and moved(). Regular movement saturates and preserves an absent index; OrThrow variants require exact finite movement. wouldAdvanceSaturate(), wouldRetreatSaturate(), and wouldMoveSaturate() detect failure of that exact operation. canAdvance(step, bounds), canRetreat(step, bounds), and canMove(offset, bounds) additionally require the result to lie within the supplied length. The starting index may be outside those bounds.

distanceFromZero() and absoluteDistanceTo() return non-negative amounts, using infinity for absent indexes. offsetFromZero() and offsetTo() return signed offsets, saturating when necessary; their OrThrow variants reject absent indexes and unrepresentable differences. mirroredWithin(length) returns length - index - 1 only for positions inside a finite length, otherwise no-index.

An amount’s remainingFrom(index) returns the length or count from an inclusive index to that amount’s exclusive end. Positions at or beyond the end return zero, as does noIndex(). An infinite amount returns infinity for every valid index and zero for noIndex(). For example, ByteCount{12}.remainingFrom(ByteIndex{5}) returns ByteCount{7}. The method accepts only the matching index family.

Index::last(length) returns the final included index of a finite, nonempty sequence measured from zero. For example, ByteIndex::last(ByteCount{8}) returns ByteIndex{7}. Zero and infinite lengths return noIndex() because they have no last element. Unlike Index::end(length).decremented(), the empty case does not saturate to index zero.

Ranges

A range stores an inclusive beginIndex() and a length; endIndex() is exclusive. Construction accepts either (begin, length) or (begin, end), including compact slicing such as text.slice({begin, end}). fromBeginEnd() provides the same endpoint semantics:

Ordered finite endpoints produce their difference.
Reversed finite endpoints produce an empty range at the beginning.
An absent beginning produces noRange().
A valid beginning and absent endpoint produce an open-ended range.

fromBeginEndOrThrow() rejects reversed endpoints and an absent beginning with OutOfRangeError; it accepts an open endpoint.

fromBegin(begin) stores the beginning directly and sets an infinite length. An absent beginning produces an absent, invalid range that retains its infinite length. The factory performs no checks or conversions.

isNoRange() tests an absent beginning. isEmpty() tests zero length independently of validity. isValid() requires a valid beginning and, for finite lengths, an exclusive endpoint at most Index::maximum(). An empty range at the maximum is valid; a finite one-element range beginning there is invalid. Open-ended ranges remain valid and include the maximum index. endIndex() returns no-index for invalid or open-ended ranges. lastIndex() returns the final included index, accounting for the range’s beginning. For example, ByteRange{ByteIndex{4}, ByteCount{3}}.lastIndex() returns ByteIndex{6}. Empty, infinite, and invalid ranges return noIndex().

Invalid ranges contain nothing, produce noRange() when clamped or translated, and return LoopResult::Error from forEach(). Open-ended iteration visits representable indexes through the maximum without wrapping. Saturating movement preserves length and keeps a valid range valid by limiting its beginning to maximum() - length() for finite ranges. Throwing movement variants reject invalid input or required saturation.

toAbsolute(origin) adds an origin; relativeTo(origin) subtracts it. Both preserve length exactly and return noRange() for invalid input, overflow, or subtraction below zero. intersection(other) returns the common range, an empty range at the later beginning if disjoint or touching, or noRange() if either operand is invalid. Open endpoints are treated as unbounded. contains(otherRange) requires both ranges to be valid. An empty range is contained at either boundary; a finite range never contains an open-ended range.

remainingFrom(index) returns the suffix beginning at an absolute index in the range’s coordinate system. An index before or at the beginning returns the original range; one at or beyond a finite end returns an empty range at that end. Open-ended ranges retain their infinite length. An absent index or invalid range returns noRange(). For example, ByteRange{ByteIndex{4}, ByteCount{8}}.remainingFrom(ByteIndex{7}) represents [7, 12).

Scalar Arithmetic

Integer unit lengths and offsets support scalar multiplication, division and modulo while preserving their unit type. Lengths require unsigned scalar operands. Offsets require signed scalar operands. Scalar operands may be native integer types or SaturatingInteger values.

Unit values are not multiplied, divided or modulo-applied with other unit values. Indexes also keep their stricter domain model and can only be moved with matching lengths and offsets. Unchecked Operations and Iteration ———————————-

Use T{rawValue, T::Unchecked{}} when the native value is already proven representable. The constructor stores the raw representation directly, including the reserved sentinel representation. It does not validate narrowing or signed-to-unsigned conversion before construction. Keep runtime factories at boundaries where negative values, overflow, or numeric sentinels remain possible.

Indexes provide uncheckedAdvance(), uncheckedRetreat(), uncheckedMove(), uncheckedIncrement(), and uncheckedDecrement(), plus the copy variants ending in Advanced, Retreated, Moved, Incremented, and Decremented. Amounts provide uncheckedAdd(), uncheckedSubtract(), their copy variants uncheckedAdded() and uncheckedSubtracted(), and uncheckedIncrement() and uncheckedDecrement(). These operations require finite operands and an exactly representable finite result. Use them inside loops whose enclosing buffer or range checks already establish those bounds.

amount.forEach(function) visits indexes from zero up to the exclusive amount bound. An infinite amount returns LoopResult::Error without invoking the callback. range.forEach(function) visits the range’s indexes after validating the range once. Both capture their original bounds, use raw increments internally, and accept callbacks returning void or LoopStatus. Continue proceeds, Stop returns LoopResult::Stopped, and Error returns LoopResult::Error. An empty valid iteration returns LoopResult::Success without calling the function. Exceptions from callbacks propagate to the caller.

Scalar Limits

Finite length multiplication saturates at the largest finite length. Infinite lengths remain infinite for scalar multiplication, division and modulo. Division and modulo by zero terminate, matching the saturating integer helpers.

Integer Amounts

IntegerAmount stores a signed saturating count with a unit tag and a scale. Construction accepts signed counts; unsigned construction is deleted. Comparison, addition, and subtraction require the exact same amount type. Signed scalar multiplication, division, and remainder preserve the amount type; division and remainder by zero terminate. Arithmetic saturates, including negation of the minimum value to the maximum. Increment and decrement change the count by one and saturate at the bounds.

Compatible conversion requires a shared unit tag and a supported scale ratio. converted<T>() saturates on overflow and truncates division toward zero. wouldConvertSaturate<T>() and convertedOrThrow<T>() check overflow, without rejecting discarded remainders. toRawValue() returns the native count; toValue() returns its saturating integer wrapper. The Interface section below gives the remaining helpers for extraction, clamping, absolute values, and factories. See Working with Typed Time Amounts for practical construction, conversion, and arithmetic with the time aliases.

Version

Introduction

Version stores a four-part version as major, minor, revision, and build number. The default value is 0.0.0.0. You can construct versions from raw part values or from typed part values in any order:

auto api = el::Version{1, 2, 0};
auto selected = el::Version{el::Major{13}, el::Revision{2}}

Parsing

fromString() accepts one to four decimal parts separated by dots. Each part must contain digits only, have no leading zeros unless it is zero, and fit in an unsigned 16-bit value. Whitespace, signs, and trailing characters are invalid. The requiredPrecision argument sets the least significant part that must be present; omitted parts become zero. Invalid text returns std::nullopt. Use fromStringOrThrow() to receive an err::ParseError instead.

Precision

compare() accepts a VersionPart as precision. The selected part is the last compared part. For example, minor precision compares major and minor, while revision and build are ignored.

Numeric Representation

toNumber() packs the four 16-bit parts into a uint64_t as major << 48 | minor << 32 | revision << 16 | build. This keeps numeric ordering identical to full version ordering.

Version Part

VersionPart identifies the part of a Version. It is also used as comparison precision: the selected part is included, and less-significant parts are ignored.

Version Range

VersionRange stores optional inclusive minimum and maximum version bounds. Missing bounds are open-ended, so a default range contains every version.

Containment uses the same precision rules as Version::compare. If both bounds are present and the minimum is greater than the maximum at the selected precision, the range is empty.

Common Ranges

Use all() for an open range, atLeast() for a lower-bounded range, atMost() for an upper-bounded range, between() for inclusive minimum and maximum bounds, and exact() for a single version.

Version Components

VersionComponent<VersionPart> represents an independent unsigned 16-bit version field. Use the distinct aliases Major, Minor, Revision, and BuildNumber. Each accepts the full range 0–65535 and has no index or infinity state.

Compile-time integer construction and runtime fromInteger() / fromIntegerOrThrow() follow the unit construction rules, with 65535 as the finite maximum. Components support comparison, hashing, formatting, saturating increment and decrement, and unsigned scalar addition and subtraction. addedOrThrow() and subtractedOrThrow() reject results outside the component range; matching mutating variants are also available.

The raw numeric Version constructor validates constants at compile time. For runtime values, construct typed components with the appropriate runtime factories and pass those to Version. Parsing and packed 64-bit representation retain their existing format.

Interface

using erbsland::unit::ArgumentCount = IntegerUnitCount<ArgumentUnit>: A non-negative number of arguments.

using erbsland::unit::ArgumentIndex = IntegerUnitIndex<ArgumentUnit>: A zero-based argument index.

struct ArgumentUnit : public erbsland::unit::IntegerUnit 

The integer unit for argument types.

using erbsland::unit::BuildNumber = VersionComponent<VersionPart::Build>: The buildnumber component of a version.

using erbsland::unit::ByteCount = IntegerUnitCount<ByteUnit>: A non-negative count of bytes.

using erbsland::unit::ByteIndex = IntegerUnitIndex<ByteUnit>: A byte-based index.

using erbsland::unit::ByteOffset = IntegerUnitOffset<ByteUnit>: A byte-based offset.

using erbsland::unit::ByteRange = IntegerUnitRange<ByteUnit>: A byte-based range.

struct ByteUnit : public erbsland::unit::IntegerUnit 

The integer unit for byte-based types.

struct CodeContinuousRange

A continuous source code range with an exclusive end location.

Public Members

CodeLocation begin: The inclusive begin location.

CodeLocation end: The exclusive end location.

class CodeLocation

A source code location with optional line, column and code-point position.

Public Functions

constexpr CodeLocation() noexcept = default: Create an undefined code location.

inline constexpr CodeLocation(LineIndex line, ColumnIndex column = ColumnIndex::noIndex(), CpIndex position = CpIndex::noIndex()) noexcept: Create a code location from its optional components.

inline constexpr LineIndex line() const noexcept: Get the zero-based line index.

inline constexpr CodeLocation &setLine(LineIndex line) noexcept: Set the zero-based line index.

inline constexpr ColumnIndex column() const noexcept: Get the zero-based column index.

inline constexpr CodeLocation &setColumn(ColumnIndex column) noexcept: Set the zero-based column index.

inline constexpr CpIndex position() const noexcept: Get the zero-based absolute code-point position.

inline constexpr CodeLocation &setPosition(CpIndex position) noexcept: Set the zero-based absolute code-point position.

bool operator==(const CodeLocation&) const noexcept = default: Compare two locations.

bool isUndefined() const noexcept: Test if no location component is defined.

void nextLine() noexcept: Advance to the first character of the next line.

void nextColumn() noexcept: Advance to the next character in the current line.

text::String toString() const noexcept: Format the known location in one-based, human-readable form.

using erbsland::unit::ColumnCount = IntegerUnitCount<ColumnUnit>: A source code column count.

using erbsland::unit::ColumnIndex = IntegerUnitIndex<ColumnUnit>: A zero-based source code column index.

using erbsland::unit::ColumnOffset = IntegerUnitOffset<ColumnUnit>: A signed source code column offset.

using erbsland::unit::ColumnRange = IntegerUnitRange<ColumnUnit>: A range of source code columns.

struct ColumnUnit : public erbsland::unit::IntegerUnit 

The integer unit for source code column types.

using erbsland::unit::CpCount = IntegerUnitCount<CpUnit>: A non-negative count of Unicode code points.

using erbsland::unit::CpIndex = IntegerUnitIndex<CpUnit>: A Unicode code-point-based index.

using erbsland::unit::CpOffset = IntegerUnitOffset<CpUnit>: A Unicode code-point-based offset.

using erbsland::unit::CpRange = IntegerUnitRange<CpUnit>: A Unicode code-point-based range.

struct CpUnit : public erbsland::unit::IntegerUnit 

The integer unit Unicode code-point-based types.

class ExitCode

Represents an exit code for a program.

Public Types

using Value = int32_t: The raw exit-code value type.

Public Functions

inline explicit constexpr ExitCode(const Value exitCode): Create an exit code from a given generic integer value.

inline bool isSuccess() const noexcept: Test if the exit-code is zero.

inline bool isFailure() const noexcept: Test if the exit-code is not zero.

inline bool isZero() const noexcept: Test if the exit-code is zero.

inline bool isOne() const noexcept: Test if the exit-code is one.

inline bool isMinimum() const noexcept: Test if the exit-code is at its minimum value.

inline bool isMaximum() const noexcept: Test if the exit-code is at its maximum value.

inline bool isValidPosix() const noexcept: Test if the exit code is in valid POSIX range.

inline bool isRecommendedPosix() const noexcept: Test if the exit code is in the recommended POSIX range.

inline Value toRawValue() const noexcept: Access the raw underlying value.

inline ExitCode toRecommendedPosix() const noexcept: Convert the exit code to the recommended POSIX range.

Public Static Functions

static inline constexpr ExitCode success() noexcept: Get a zero exit-code, indicating success.

static inline constexpr ExitCode failure() noexcept: Get a one exit-code, indicating a generic failure.

static inline constexpr ExitCode zero() noexcept: Get a zero exit-code.

static inline constexpr ExitCode one() noexcept: Get a one exit-code.

static inline constexpr ExitCode minimum() noexcept: Get the minimum possible exit code.

static inline constexpr ExitCode maximum() noexcept: get the maximum possible exit code.

template<typename tUnit, typename tRatio, typename tValue> class IntegerAmount

A signed integer amount in a ratio-scaled unit.

This type is intended for values such as seconds, milliseconds, meters, or kilometers where signed arithmetic, ratio conversion, and saturating integer behavior are desired.

See: Units and Versions

Template Parameters:

tUnit – The unit tag that prevents accidental mixing with unrelated amounts.
tRatio – The ratio of this amount to its base unit.
tValue – The signed saturating integer type used to store the amount.

Public Types

using Unit = tUnit : The unit tag.

using Ratio = tRatio : The ratio to the base unit.

using Value = tValue : The saturating integer value type.

using NativeValue = math::NativeIntegerOfT<Value>: The native signed integer type wrapped by Value.

Public Functions

constexpr IntegerAmount() noexcept = default: Create a zero amount.

inline explicit constexpr IntegerAmount(Value value) noexcept: Create an amount from a saturating integer value.

inline explicit constexpr IntegerAmount(NativeValue value) noexcept: Create an amount from a native signed integer value.

template<impl::SignedIntegerAmountOperand tOther> inline explicit constexpr IntegerAmount(tOther value) noexcept: Create an amount from another signed integer operand, saturating if needed.

inline constexpr std::strong_ordering operator<=>(const IntegerAmount &other) const noexcept: Compare this amount with another amount of the exact same type.

inline IntegerAmount operator+(IntegerAmount other) const noexcept: Add another amount, saturating on overflow.

inline IntegerAmount &operator+=(IntegerAmount other) noexcept: Add another amount in place, saturating on overflow.

inline IntegerAmount operator-(IntegerAmount other) const noexcept: Subtract another amount, saturating on underflow.

inline IntegerAmount &operator-=(IntegerAmount other) noexcept: Subtract another amount in place, saturating on underflow.

inline IntegerAmount operator-() const noexcept: Return the negated amount, saturating the minimum value to the maximum value.

inline IntegerAmount &operator++() noexcept: Increment this amount by one, saturating at maximum().

inline IntegerAmount operator++(int) noexcept: Increment this amount by one and return the previous value.

inline IntegerAmount &operator--() noexcept: Decrement this amount by one, saturating at minimum().

inline IntegerAmount operator--(int) noexcept: Decrement this amount by one and return the previous value.

template<impl::SignedIntegerAmountOperand tFactor> inline IntegerAmount operator*(tFactor factor) const noexcept: Multiply this amount by a signed integer factor.

template<impl::SignedIntegerAmountOperand tFactor> inline IntegerAmount &operator*=(tFactor factor) noexcept: Multiply this amount in place by a signed integer factor.

template<impl::SignedIntegerAmountOperand tDivisor> inline IntegerAmount operator/(tDivisor divisor) const noexcept: Divide this amount by a signed integer divisor.

template<impl::SignedIntegerAmountOperand tDivisor> inline IntegerAmount &operator/=(tDivisor divisor) noexcept: Divide this amount in place by a signed integer divisor.

template<impl::SignedIntegerAmountOperand tModulus> inline IntegerAmount operator%(tModulus modulus) const noexcept: Modulo this amount by a signed integer factor.

template<impl::SignedIntegerAmountOperand tModulus> inline IntegerAmount &operator%=(tModulus modulus) noexcept: Modulo an amount by another amount.

inline constexpr bool isZero() const noexcept: Test if this amount is zero.

inline constexpr bool isOne() const noexcept: Test if this amount is one.

inline constexpr bool isMinusOne() const noexcept: Test if this amount is minus one.

inline constexpr bool isPositive() const noexcept: Test if this amount is positive.

inline constexpr bool isNegative() const noexcept: Test if this amount is negative.

inline constexpr bool isMinimum() const noexcept: Test if this amount has the minimum representable value.

inline constexpr bool isMaximum() const noexcept: Test if this amount has the maximum representable value.

inline constexpr bool wouldAddSaturate(const IntegerAmount &other) const noexcept: Test if adding would saturate.

inline constexpr bool wouldSubtractSaturate(const IntegerAmount &other) const noexcept: Test if subtracting would saturate.

template<impl::SignedIntegerAmountOperand tFactor> inline constexpr bool wouldMultiplySaturate(const tFactor &other) const noexcept: Test if multiplying would saturate.

inline constexpr NativeValue toRawValue() const noexcept: Access the raw native signed integer value.

inline constexpr Value toValue() const noexcept: Access the saturating integer value.

inline constexpr std::strong_ordering compare(const IntegerAmount &other) const noexcept: Compare this amount with another amount of the exact same type.

inline IntegerAmount<Unit, std::ratio<1>, Value> toBaseUnit() const noexcept: Convert this amount to the base unit for its unit tag.

inline IntegerAmount<Unit, std::ratio<1>, Value> toBaseUnitOrThrow() const

Convert this amount to the base unit for its unit tag.

Throws:: err::OverflowError – if the conversion would saturate.

template<typename tTarget> inline bool wouldConvertSaturate() const noexcept: Test if conversion to another ratio with the same unit tag would saturate.

template<typename tTarget> inline tTarget converted() const noexcept: Convert this amount to another ratio with the same unit tag.

template<typename tTarget> inline tTarget convertedOrThrow() const

Convert this amount to another ratio with the same unit tag.

Throws:: err::OverflowError – if the conversion would saturate.

template<typename tTarget> inline tTarget convert() const noexcept: Compatibility alias for converted.

template<typename tTarget> inline tTarget convertOrThrow() const

Compatibility alias for convertedOrThrow.

Throws:: err::OverflowError – if the conversion would saturate.

template<typename tTarget> inline tTarget extract() noexcept: Extract a larger whole unit and keep the signed remainder in this amount.

inline IntegerAmount negated() const noexcept: Return the negated amount, saturating the minimum value to the maximum value.

inline void negate() noexcept: Negate this amount in place, saturating the minimum value to the maximum value.

inline IntegerAmount clamped(IntegerAmount first, IntegerAmount last) const noexcept: Return this amount clamped to the given inclusive range.

inline void clamp(IntegerAmount first, IntegerAmount last) noexcept: Clamp this amount to the given inclusive range.

inline IntegerAmount toAbsolute() const noexcept: Return the absolute value of this amount.

Public Static Functions

static inline constexpr IntegerAmount zero() noexcept: Return the zero amount.

static inline constexpr IntegerAmount one() noexcept: Return the amount one.

static inline constexpr IntegerAmount minusOne() noexcept: Return the amount minus one.

static inline constexpr IntegerAmount minimum() noexcept: Return the smallest representable amount.

static inline constexpr IntegerAmount maximum() noexcept: Return the largest representable amount.

static inline constexpr std::intmax_t ratioNumerator() noexcept: Return the ratio numerator.

static inline constexpr std::intmax_t ratioDenominator() noexcept: Return the ratio denominator.

static inline constexpr bool isBaseUnit() noexcept: Test if this amount is measured in the base unit.

Public Static Attributes

static constexpr auto cIsIntegerAmount = true: Marker used by concepts to identify integer amount types.

Friends

template<impl::SignedIntegerAmountOperand tFactor> inline friend IntegerAmount operator*(tFactor factor, IntegerAmount amount) noexcept: Multiply a signed integer factor by an amount.

struct IntegerUnit

The tag base for positional integer units.

Subclassed by erbsland::cterm::BlockUnit, erbsland::unit::ArgumentUnit, erbsland::unit::ByteUnit, erbsland::unit::ColumnUnit, erbsland::unit::CpUnit, erbsland::unit::ItemUnit, erbsland::unit::LineUnit, erbsland::unit::U16Unit

template<impl::ValidIntegerUnit tIntegerUnit> class IntegerUnitCount

A non-negative count with an integer unit.

See: Units and Versions

Template Parameters:

tIntegerUnit – The integer unit for this count.

Public Types

using Value = uint64_t: The raw unsigned integer type.

using Unit = tIntegerUnit : The unit type.

Public Functions

constexpr IntegerUnitCount() noexcept = default: Create a zero length.

template<math::NativeInteger T> inline explicit consteval IntegerUnitCount(T value)

Construct a finite value from a compile-time integer.

Parameters:: value – An integer within the finite domain; invalid values fail compilation.

inline constexpr IntegerUnitCount(const Value value, Unchecked) noexcept

Construct directly from a raw representation without conversion or range checks.

The caller must ensure the input fits Value before conversion and represents the intended finite or special state.

Parameters:: value – The raw unsigned integer value.

inline constexpr IntegerUnitCount operator+(const IntegerUnitCount other) const noexcept: Add another length and return the saturated result.

inline constexpr IntegerUnitCount &operator+=(const IntegerUnitCount other) noexcept: Add another length to this length with saturation.

inline constexpr IntegerUnitCount operator-(const IntegerUnitCount other) const noexcept: Subtract another length and return the saturated result.

inline constexpr IntegerUnitCount &operator-=(const IntegerUnitCount other) noexcept: Subtract another length from this length with saturation.

template<math::AnyIntegerType T> inline constexpr IntegerUnitCount operator*(T scalar) const noexcept: Multiply this length by an unsigned scalar and return the saturated result.

template<math::AnyIntegerType T> inline constexpr IntegerUnitCount &operator*=(T scalar) noexcept: Multiply this length by an unsigned scalar with saturation.

template<math::AnyIntegerType T> inline constexpr IntegerUnitCount operator/(T scalar) const noexcept: Divide this length by an unsigned scalar.

template<math::AnyIntegerType T> inline constexpr IntegerUnitCount &operator/=(T scalar) noexcept: Divide this length by an unsigned scalar.

template<math::AnyIntegerType T> inline constexpr IntegerUnitCount operator%(T scalar) const noexcept: Calculate the modulo of this length and an unsigned scalar.

template<math::AnyIntegerType T> inline constexpr IntegerUnitCount &operator%=(T scalar) noexcept: Apply modulo with an unsigned scalar.

inline constexpr IntegerUnitCount &operator++() noexcept: Increment this length by one with saturation.

inline constexpr IntegerUnitCount operator++(int) noexcept: Increment this length by one with saturation and return the previous value.

inline constexpr IntegerUnitCount &operator--() noexcept: Decrement this length by one with saturation.

inline constexpr IntegerUnitCount operator--(int) noexcept: Decrement this length by one with saturation and return the previous value.

inline constexpr bool isZero() const noexcept: Test if this length is zero.

inline constexpr bool isOne() const noexcept: Test if this length is one.

inline constexpr bool isMinimum() const noexcept: Test if this length has the minimum value.

inline constexpr bool isMaximum() const noexcept: Test if this length has the largest finite value.

inline constexpr bool isInfinite() const noexcept: Test if this length has the infinite value.

inline constexpr bool isFinite() const noexcept: Test if this length has a finite value.

inline constexpr Value toRawValue() const noexcept: Access the raw value of this length.

inline constexpr auto remainingFrom(const IntegerUnitIndex<tIntegerUnit> index) const noexcept -> IntegerUnitCount 

Return the amount remaining from an index measured from zero.

An absent index or a position at or beyond the end returns zero, including noIndex() for infinite amounts.

Parameters:: index – The inclusive beginning of the remaining amount.
Returns:: The remaining amount, or infinite for a valid index within an infinite amount.

inline constexpr IntegerUnitCount &add(const IntegerUnitCount other) noexcept

Add another length, saturating at the largest finite length or infinite length.

If either operand is infinite, the result is infinite.

inline constexpr IntegerUnitCount added(const IntegerUnitCount other) const noexcept

Create a new length by adding another length to it.

If either operand is infinite, the result is infinite.

inline constexpr IntegerUnitCount &addOrThrow(const IntegerUnitCount other)

Add another length.

Throws:: OverflowError – if either operand is infinite or the finite result exceeds maximum().

inline constexpr IntegerUnitCount addedOrThrow(const IntegerUnitCount other) const

Create a new length by adding another length to it.

Throws:: OverflowError – if either operand is infinite or the finite result exceeds maximum().

inline constexpr IntegerUnitCount &subtract(const IntegerUnitCount other) noexcept

Subtract another length, saturating at zero.

If this length is infinite, it remains infinite. Subtracting infinite from a finite length produces zero.

inline constexpr IntegerUnitCount subtracted(const IntegerUnitCount other) const noexcept

Create a new length by subtracting another length from it.

If this length is infinite, the result is infinite. Subtracting infinite from a finite length produces zero.

inline constexpr IntegerUnitCount &subtractOrThrow(const IntegerUnitCount other)

Subtract another length.

Throws:: OverflowError – if either operand is infinite or the finite result would be below zero.

inline constexpr IntegerUnitCount subtractedOrThrow(const IntegerUnitCount other) const

Create a new length by subtracting another length from it.

Throws:: OverflowError – if either operand is infinite or the finite result would be below zero.

template<math::AnyIntegerType T> inline constexpr IntegerUnitCount &multiply(T scalar) noexcept: Multiply this length by an unsigned scalar with saturation.

template<math::AnyIntegerType T> inline constexpr IntegerUnitCount multiplied(T scalar) const noexcept

Create a new length by multiplying this length with an unsigned scalar.