make.cpp

// Returns the maximum level the tasks of the specified vector have.
unsigned short level_max (vector<item> & task) {
    unsigned short level = 1;
    for (unsigned int j(task.size());j-- > 0;) {
        if (task[j].level > level)
            level = task[j].level;
    }
    return level;
}

bool sort_levels (item & a, item & b) {
    return a.level < b.level;
}

bool sort_nice (item & a, item & b) {
    return a.nice() > b.nice();
}

// Returns index of the first, the first that has depends != "none", or the last element with specified level.
unsigned int level_range (vector<item> & task, const unsigned short level, string type) {
        if (type == "begin") {
            for (unsigned int j(0); j < task.size(); j++) {
                if (task[j].level == level)
                    return j;
                }
            }
        if (type == "begin_depends") {
            for (unsigned int j(0); j < task.size(); j++) {
                if (task[j].level == level && task[j].depends != "none")
                    return j;
                }
            }
        if (type == "end") {
            for (unsigned int j(task.size()); j-- > 0;) {
                if (task[j].level == level)
                    return j;
                }
            }
}


// Another implementation of pushing dependent task to the task it depends on created for debug.
void rotate_to_dep(vector<item> & task, int num) {
    for (int j(num); j >= number(task, task[num].depends); j--) {
        if (task[number(task, task[j].depends)-1].level == task[j].level)
            swap(task[j],task[j-1]);
    }
}

void sort_nice_depends (vector<item> & task, const unsigned short level) {
    unsigned int begin = level_range(task, level, "begin");
    unsigned int end = level_range(task, level, "end");
    unsigned int begin_depends = level_range(task, level, "begin_depends");
    // Move all the "dependent" tasks to the bottom of the level.
    for (unsigned int j(begin); j <= end; j++) {
        if (task[j].depends != "none") {
            rotate(&task[j], &task[j+1], &task[end+1]);
        }
    }
    // Sort "independent" tasks by their nice() level in descending order.
    sort (&task[begin], &task[begin_depends], sort_nice);
    // Sort "dependent" tasks by their nice() level in descending order.
    sort (&task[begin_depends], &task[end+1], sort_nice);
    // Move "dependent" tasks below the tasks they depend on.
    for (int j(begin_depends); j <= end; j++) {
        if (task[number(task, task[j].depends)-1].level == task[j].level)
            rotate (&task[j], &task[j-1], &task[number(task, task[j].depends)-1]);
            //rotate_to_dep(task, j);

    }
}

// Outputs function for tasks with level > 1.
void output (vector<item> sorted, const unsigned short level, string depends) {


}

// Outputs function for tasks with level 1.
void output (vector<item> sorted) {


}

// Puts it all together.
void make (vector<item> & task) {
    // First, sort all the tasks by their level form lower to higher.
    sort (task.begin(), task.end(), sort_levels);

    vector <thread> sort_thread;
    for (unsigned short j(1); j <= level_max(task); j++) {
           sort_thread.push_back(thread(sort_nice_depends, ref(task), j));
           //sort_nice_depends(task, 1);
    }
    for (auto j(0); j < sort_thread.size(); j++) {
        if (sort_thread[j].joinable())
            sort_thread[j].join();
    }
}