range

std/slice.h

• Member Types
• Member Variables
• Member Functions
  • Constructor
  • Utility
  • Iterators
  • Accessors
  • Slicing
  • Modifiers
• Non-Member Functions
  • 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 the value of the first element: start.

value_type back() Returns the value of the last element: finish-1.

value_type get(int i) Returns the value of the ith element: start+i.

value_type operator[](int i) Returns the value of the ith element: start+i.

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()

If this container is filled with iterators, it returns the index of each iterator.

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

returns a slice or copy of the elements within the range [start,end).

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

returns a slice or copy of the elements after start.

slice<range<iterator> > sub()
range<value_type> subcpy()

returns a slice or copy 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<typename container::iterator> sample(container &c)
fill<typename container::const_iterator> sample(const 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

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.

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}