sorting snippets

// Marijn Evers / s1036416 / Computing Science
// Willem van de Krol / s1035713 / Computing Science
#include <cassert>
#include <vector>

using namespace std;

typedef int El; // TODO remove

struct Slice {
    int from;   // 0 <= from
    int length; // 0 <= length
};

int size(const vector<El>& data)
{
    return static_cast<int>(data.size());
}

Slice mk_slice(int from, int length)
{
    assert(0 <= from && 0 <= length);
    return { from, length };
}

Slice mk_slice(const vector<El>& data)
{
    return { 0, size(data) };
}

bool valid_slice(Slice s)
{
    return 0 <= s.from && 0 <= s.length;
}

bool valid_slice(const vector<El>& data, Slice s)
{
    return valid_slice(s) && s.from + s.length <= size(data);
}

int first(Slice s)
{
    return s.from;
}

int last(Slice s)
{
    return s.from + s.length - 1;
}

int max_value_at(const vector<El>& data, Slice s)
{
    assert(valid_slice(data, s) && s.length > 0);

    int max = first(s);
    for (int i = first(s)+1; i <= last(s); i++)
        if (data[i] > data[max])
            max = i;
    return max;
}

bool is_sorted(const vector<El>& data, Slice s)
{
    assert(valid_slice(data, s));

    for (int i = first(s); i < last(s); i++)
        if (data[i] > data[i+1])
            return false;
    return true;
}

void swap(vector<El>& data, int i, int j)
{
    const El TEMP = data[i];
    data[i] = data[j];
    data[j] = TEMP;
}

void insert(vector<El>& data, Slice s)
{
    assert(s.length > 0 && is_sorted(data, mk_slice(s.from, s.length-1)));

    int i = last(s) - 1;
    while (i >= first(s) && data[i] > data[i+1]) {
        swap(data, i, i+1);
        i--;
    }
}

int main()
{
    return 0;
}