range

std/slice.h

• Member Types
• Member Variables
• Member Functions
  • Constructor
  • Utility
  • Iterators
  • Accessors
  • Slicing
  • Modifiers
• Non-Member Variables
  • Comparison
• Examples

---

template <class value_type> struct range

Stores a range of values in [start,finish) traversed via addition operators.

Member Types

• typedef value_type type so that generic wrappers can access this containers value_type
• typedef const_iterator iterator so that algorithms dependent upon iterator work.
• range::const_iterator

Member Variables

• value_type start represents the starting value of the range.
• value_type finish represents the ending value of the range.

Member Functions

Constructor

range()

The default constructor.

range(value_type start, value_type finish)

Set start and finish directly.

range(const range<value_type2> &a)

Copy another range of any type into this one with implicit type casts.

range(const_iterator start, const_iterator finish)

Copy another range using it's iterator bounds (this is used by the sub() functions).

Utility

Basic functions necessary for algorithm execution.

int size()

returns the number of values in this range: finish-start.

Iterators

const_iterator begin()

returns an iterator to the first element.

const_iterator end()

returns an iterator to one after the last element.

const_iterator rbegin()

returns an iterator to the last element.

const_iterator rend()

returns an iterator to one before the first element.

const_iterator at(int i)

returns an iterator to the ith element.

Accessors

value_type front()

returns value.

value_type back()

returns value.

value_type get(int i)

returns value.

value_type operator[](int i)

returns value.

Slicing

slice<range<value_type> > deref()

wraps this range with a slice. This is particularly useful if an algorithm gives you a container filled with iterators. You can convert it into a slice with a single call to this function.

range<int> idx()

This is orthogonal to deref(). If this container is filled with iterators, it returns the index of each iterator.

slice<range<iterator> > sub(int start, int end)

returns a slice of this container of the elements within the range [start,end).

slice<range<iterator> > sub(int start)

returns a slice of this container of the elements after start.

slice<range<iterator> > sub()

returns a slice of all the elements in this container.

static slice<range<const_iterator> > sub(const_iterator start, const_iterator end)

returns a slice of all the elements within the range [start,end) of a range container.

range<value_type> subcpy(int start, int end)

see above. This returns a copy instead of a slice.

range<value_type> subcpy(int start)

see above. This returns a copy instead of a slice.

range<value_type> subcpy()

see above. This returns a copy instead of a slice.

range<typename container::iterator> sample(container &c)

uses the values of the range container as indices into c. Returns another range container with the indexed value from c.

Modifiers

void swap(range<value_type> &root)

swaps the contents of this range container with another.

range<value_type> &operator=(const range<value_type> &root)

sets the contents of this range container equal the contents of another.

Non-Member Functions

Comparison

range/range

bool operator==(range<value_type1> s1, range<value_type2> s2)
bool operator!=(range<value_type1> s1, range<value_type2> s2)
bool operator<(range<value_type1> s1, range<value_type2> s2)
bool operator>(range<value_type1> s1, range<value_type2> s2)
bool operator<=(range<value_type1> s1, range<value_type2> s2)
bool operator>=(range<value_type1> s1, range<value_type2> s2)

Compares two range containers by comparing start followed by finish.

range/slice

bool operator==(range<value_type1> s1, core::slice<container2> s2)
bool operator!=(range<value_type1> s1, core::slice<container2> s2)
bool operator<(range<value_type1> s1, core::slice<container2> s2)
bool operator>(range<value_type1> s1, core::slice<container2> s2)
bool operator<=(range<value_type1> s1, core::slice<container2> s2)
bool operator>=(range<value_type1> s1, core::slice<container2> s2)
bool operator==(core::slice<container1> s1, range<value_type2> s2)
bool operator!=(core::slice<container1> s1, range<value_type2> s2)
bool operator<(core::slice<container1> s1, range<value_type2> s2)
bool operator>(core::slice<container1> s1, range<value_type2> s2)
bool operator<=(core::slice<container1> s1, range<value_type2> s2)
bool operator>=(core::slice<container1> s1, range<value_type2> s2)

Compares a range container to a generic slice by calling compare().

Examples

#include <std/ascii_stream.h>
#include <std/slice.h>

using namespace core;

int main()
{
    range<int> f(3, 8);
    cout << f << endl;
    return 0;
}

{3, 4, 5, 6, 7}