slist_t * slist_insert(slist_t * l, void * elt)
{
if (l->head == 0)
{
l->head = slist_node_new(elt, 0);
}
else
{
slist_node_t * p = l->head;
slist_node_t * prev = 0;
while (p && l->cmp(elt, p->elt) >= 0)
{
prev = p;
p = p->next;
}
if (prev == 0) /// Head insertion
{
l->head = slist_node_new(elt, p);
}
else /// Insertion
{
prev->next = slist_node_new(elt, p);
}
}
return l;
}
/* all jobs must have successors except the end job, and all jobs must have predeccessors except the start job */
int check_dependencies(struct rcps_problem *p) {
int result = RCPS_CHECK_OK;
int end_count = 0;
int i, k;
struct rcps_job *start_job;
struct slist *visited;
struct slist *has_predecessor = slist_new(job_compare);
for (i = 0; i < p->job_count; ++i) {
struct rcps_job *j = p->jobs[ i ];
//printf("check_dependencies: job %s successors: %i\n", j->name, j->successor_count);
if (j->successor_count == 0) {
++end_count;
} else {
for (k = 0; k < j->successor_count; ++k) {
//printf("check_dependencies: job %s successor[%i] = %s\n", j->name, k, j->successors[k]->name);
slist_add(has_predecessor, slist_node_new(j->successors[k]));
}
}
}
if (end_count > 1) {
result += RCPS_CHECK_MULTIPLE_END_JOBS;
} else if (end_count == 0) {
result += RCPS_CHECK_END_JOB_MISSING;
}
if (result == RCPS_CHECK_OK) {
start_job = 0;
for (i = 0; i < p->job_count; ++i) {
if (!slist_find(has_predecessor, p->jobs[i])) {
start_job = p->jobs[i];
}
}
if (start_job) {
/* All other jobs should be successors of the start job */
//printf("check_dependencies: check circular\n");
visited = slist_new(job_compare);
result += check_circulardependencies(start_job, visited);
slist_free(visited, NULL);
} else {
result += RCPS_CHECK_START_JOB_MISSING;
}
}
slist_free(has_predecessor, NULL);
//printf("check_dependencies: result=%i\n", result);
return result;
}
slist_t * slist_dup(slist_t const * l)
{
slist_t * new_l = slist_new(l->free, l->dup, l->cmp);
if (new_l == 0)
return 0;
if (l->head)
{
slist_node_t ** new_p = &new_l->head;
slist_node_t const * p = l->head;
while (p)
{
*new_p = slist_node_new(l->dup(p->elt), 0);
p = p->next;
new_p = &((*new_p)->next);
}
}
return new_l;
}
void add_individual(struct rcps_individual *ind, struct rcps_population *pop) {
struct slist_node *n;
struct rcps_individual *i;
n = slist_node_new(ind);
slist_add(pop->individuals, n);
++pop->size;
// what is this? (da)
while (slist_count(pop->individuals) > pop->size) {
n = slist_last(pop->individuals);
if (!n) {
// XXX what the f**k is that?
fprintf(stderr, "uhu, no one there?\n");
}
slist_unlink(pop->individuals, n);
i = (struct rcps_individual*)slist_node_getdata(n);
slist_node_free(n, NULL);
free(i->genome.schedule);
free(i->genome.modes);
free(i->genome.alternatives);
free(i);
}
}
int check_circulardependencies(struct rcps_job *job, struct slist *visited) {
int result = RCPS_CHECK_OK;
int i;
struct slist_node *n;
//printf("check_circulardependencies: %s visited: %i\n", job->name, slist_count(visited));
if ( slist_find(visited, job)) {
result = RCPS_CHECK_CIRCULAR_DEPENDENCY;
//printf("check_circulardependencies: %s already visited\n", job->name);
} else {
n = slist_node_new(job);
slist_add(visited, n);
for (i = 0; i < job->successor_count; ++i) {
result = check_circulardependencies( job->successors[ i ], visited );
if ( result != RCPS_CHECK_OK ) {
break;
}
}
// remove this job from the visited to avoid false positive
slist_unlink(visited, n);
slist_node_free(n, NULL);
}
return result;
}
