#ifndef ITERTOOLS_SAMPLE_CLASSES_HPP

#define ITERTOOLS_SAMPLE_CLASSES_HPP

#include <iostream>

#include <utility>

#include <cstddef>

namespace itertest {

class MoveOnly {

private:

int i; // not an aggregate

public:

MoveOnly(int v)

: i{v}

{ }

MoveOnly(const MoveOnly&) = delete;

MoveOnly& operator=(const MoveOnly&) = delete;

MoveOnly(MoveOnly&& other) noexcept

: i{other.i}

{ }

MoveOnly& operator=(MoveOnly&& other) noexcept {

this->i = other.i;

return *this;

}

// for std::next_permutation compatibility

friend bool operator<(const MoveOnly& lhs, const MoveOnly& rhs) {

return lhs.i < rhs.i;

}

friend std::ostream& operator<<(

std::ostream& out, const MoveOnly& self) {

return out << self.i;

}

};

class DerefByValue {

private:

static constexpr std::size_t N = 3;

int array[N] = {0, 1, 2};

public:

DerefByValue() = default;

class Iterator {

private:

int *current;

public:

Iterator() = default;

Iterator(int *p)

: current{p}

{ }

bool operator!=(const Iterator& other) const {

return this->current != other.current;

}

// for testing, iterator derefences to an int instead of

// an int&

int operator*() const {

return *this->current;

}

Iterator& operator++() {

++this->current;

return *this;

}

};

Iterator begin() {

return {this->array};

}

Iterator end() {

return {this->array + N};

}

};

class DerefByValueFancy {

private:

static constexpr std::size_t N = 3;

int array[N] = {0, 1, 2};

public:

DerefByValueFancy() = default;

int *begin() {

return this->array;

}

int *end() {

return this->array + N;

}

};

}

#endif // #ifndef ITERTOOLS_SAMPLE_CLASSES_HPP