std.range.interfaces

interface InputRange(E);

These interfaces are intended to provide virtual function-based wrappers around input ranges with element type E. This is useful where a well-defined binary interface is required, such as when a DLL function or virtual function needs to accept a generic range as a parameter. Note that isInputRange and friends check for conformance to structural interfaces not for implementation of these interface types.

Limitations These interfaces are not capable of forwarding ref access to elements.

Infiniteness of the wrapped range is not propagated.

Length is not propagated in the case of non-random access ranges.

See Also:

inputRangeObject

Examples:

import std.algorithm.iteration : map;
import std.range : iota;

void useRange(InputRange!int range) {
    // Function body.
}

// Create a range type.
auto squares = map!"a * a"(iota(10));

// Wrap it in an interface.
auto squaresWrapped = inputRangeObject(squares);

// Use it.
useRange(squaresWrapped);

@property E front();

E moveFront();

Calls std.range.primitives.moveFront on the wrapped range, if possible. Otherwise, throws an UnsupportedRangeMethod exception.

void popFront();

@property bool empty();

int opApply(scope int delegate(E));

int opApply(scope int delegate(size_t, E));

foreach iteration uses opApply, since one delegate call per loop iteration is faster than three virtual function calls.

interface ForwardRange(E): InputRange!E;

Interface for a forward range of type E.

@property ForwardRange!E save();

interface BidirectionalRange(E): ForwardRange!E;

Interface for a bidirectional range of type E.

@property BidirectionalRange!E save();

@property E back();

E moveBack();

Calls std.range.primitives.moveBack on the wrapped range, if possible. Otherwise, throws an UnsupportedRangeMethod exception

void popBack();

interface RandomAccessFinite(E): BidirectionalRange!E;

Interface for a finite random access range of type E.

@property RandomAccessFinite!E save();

E opIndex(size_t);

E moveAt(size_t);

@property size_t length();

alias opDollar = length;

RandomAccessFinite!E opSlice(size_t, size_t);

interface RandomAccessInfinite(E): ForwardRange!E;

Interface for an infinite random access range of type E.

enum bool empty;

E moveAt(size_t);

Calls std.range.primitives.moveAt on the wrapped range, if possible. Otherwise, throws an UnsupportedRangeMethod exception.

@property RandomAccessInfinite!E save();

E opIndex(size_t);

interface InputAssignable(E): InputRange!E;

Adds assignable elements to InputRange.

@property void front(E newVal);

interface ForwardAssignable(E): InputAssignable!E, ForwardRange!E;

Adds assignable elements to ForwardRange.

@property ForwardAssignable!E save();

interface BidirectionalAssignable(E): ForwardAssignable!E, BidirectionalRange!E;

Adds assignable elements to BidirectionalRange.

@property BidirectionalAssignable!E save();

@property void back(E newVal);

interface RandomFiniteAssignable(E): RandomAccessFinite!E, BidirectionalAssignable!E;

Adds assignable elements to RandomAccessFinite.

@property RandomFiniteAssignable!E save();

void opIndexAssign(E val, size_t index);

interface OutputRange(E);

Interface for an output range of type E. Usage is similar to the InputRange interface and descendants.

void put(E);

class OutputRangeObject(R, E...): staticMap!(OutputRange, E);

Implements the OutputRange interface for all types E and wraps the put method for each type E in a virtual function.

this(R range);

template MostDerivedInputRange(R) if (isInputRange!(Unqual!R))

Returns the interface type that best matches R.

template InputRangeObject(R) if (isInputRange!(Unqual!R))

Implements the most derived interface that R works with and wraps all relevant range primitives in virtual functions. If R is already derived from the InputRange interface, aliases itself away.

InputRangeObject!R inputRangeObject(R)(R range)
if (isInputRange!R);

Convenience function for creating an InputRangeObject of the proper type. See InputRange for an example.

template outputRangeObject(E...)

Convenience function for creating an OutputRangeObject with a base range of type R that accepts types E.

Examples:

import std.array;
auto app = appender!(uint[])();
auto appWrapped = outputRangeObject!(uint, uint[])(app);
static assert(is(typeof(appWrapped) : OutputRange!(uint[])));
static assert(is(typeof(appWrapped) : OutputRange!(uint)));

OutputRangeObject!(R, E) outputRangeObject(R)(R range);

class UnsupportedRangeMethod: object.Exception;

Thrown when an interface method is not supported by the wrapped range