void add_new_food(Board* board) {
PointList* new_food;
do {
new_food = create_random_cell(board->xmax, board->ymax);
} while(list_contains(new_food, board->foods) || list_contains(new_food, board->snake));
new_food->next = board->foods;
board->foods = new_food;
}
int main() {
add_to_list(42);
std::cout << "contains(1) = " << list_contains(1)
<< ", contains(42) = " << list_contains(42)
<< std::endl;
return 0;
}
void test_list(void) {
int i, arr[MAX];
int k, s;
list *l = EMPTY_LIST;
generate(arr, MAX);
for (i = 0; i < MAX; i++) {
l = list_create(arr[i], 0);
assert(l != EMPTY_LIST);
assert(l->key == arr[i]);
assert(list_count(l) == 1);
assert(list_contains(l, arr[i]));
l = list_destroy(l);
assert(l == EMPTY_LIST);
}
for (i = 0; i < MAX; i++) {
l = list_insert(l, arr[i], arr[i]);
assert(list_contains(l, arr[i]));
}
assert(list_ordered(l));
for (i = 0; i < MAX; i++) {
l = list_remove_first(l, &k, &s);
assert(list_ordered(l));
}
l = list_destroy(l);
l = list_insert(l, 5, 0);
l = list_insert(l, 4, 1);
l = list_insert(l, 1, 2);
l = list_insert(l, 2, 6);
l = list_insert(l, 7, 4);
l = list_insert(l, 0, 5);
list_print(l);
l = list_insert(l, 20, 10);
l = list_insert(l, 25, -1);
l = list_insert(l, 30, 3);
list_print(l);
l = list_remove_first(l, &k, &s);
s = 15;
l = list_insert(l, k, s);
list_print(l);
printf("count: %d\n", list_count(l));
printf("last: %d\n", list_last(l)->key);
l = list_destroy(l);
}
void enlist_conn(conn *c, conn **list) {
LIBEVENT_THREAD *thr = c->thread;
assert(list == &thr->pending_io);
if ((c->list_state & LIST_STATE_PROCESSING) == 0) {
assert(!list_contains(thr->pending_io, c));
assert(c->next == NULL);
c->next = *list;
*list = c;
assert(list_contains(*list, c));
assert(!has_cycle(*list));
} else {
c->list_state |= LIST_STATE_REQ_PENDING_IO;
}
}
/* Tries to add the item (PROD, DOT) to LIST. If the item is added,
returns nonzero. Otherwise, the item was already in LIST, and zero
is returned. */
static int
list_add (struct list *list, int prod, int dot)
{
assert (list != NULL);
if (list_contains (list, prod, dot))
return 0;
if (list->n >= list->m)
{
if (list->m == 0)
list->m = 16;
else
list->m *= 2;
list->contents = xrealloc (list->contents,
sizeof *list->contents * list->m);
}
assert (list->n < list->m);
list->contents[list->n].prod = prod;
list->contents[list->n].dot = dot;
list->n++;
return 1;
}
int list_contains(list *l, int key) {
if (!l) return 0;
else {
if (l->key == key) return 1;
else return list_contains(l->tail, key);
}
}
void finder(const int value_to_find)
{
while (!list_contains(value_to_find)) {
sleep(1);
}
std::cout << "value found!" << std::endl;
}
size_t
blacklist_glob(Blacklist *blacklist, const char *pattern)
{
glob_t g;
size_t count = 0;
assert(blacklist != NULL);
assert(pattern != NULL);
memset(&g, 0, sizeof(glob_t));
DEBUGF("blacklist", "Adding pattern to blacklist: %s", pattern);
int rc = glob(pattern, GLOB_TILDE, NULL, &g);
if(!rc)
{
for(size_t i = 0; i < g.gl_pathc; ++i)
{
if(!list_contains(blacklist, g.gl_pathv[i]))
{
TRACEF("blacklist", "Appending file to blacklist: %s", g.gl_pathv[i]);
list_append(blacklist, utils_strdup(g.gl_pathv[i]));
}
}
count = g.gl_pathc;
}
globfree(&g);
return count;
}
int discovery_search_result(struct Upnp_Discovery *event) {
if (event->ErrCode != UPNP_E_SUCCESS) {
fprintf(stderr, "Error in discovering device\n");
exit(-1);
}
IXML_Document *desc = NULL;
int ret = UpnpDownloadXmlDoc(event->Location, &desc);
if (ret != UPNP_E_SUCCESS) {
fprintf(stderr, "Error in obtaining device description\n");
exit(-1);
}
const char *UUID = get_device_property(desc, "UDN");
if (!list_contains(&devices, UUID, chromecast_matches_UUID)) {
struct chromecast_device *device = malloc(sizeof(struct chromecast_device));
device->addr = ((struct sockaddr_in *)&event->DestAddr)->sin_addr;
device->device_name = create_string_copy(get_device_property(desc, "friendlyName"));
device->device_type = create_string_copy(get_device_property(desc, "deviceType"));
device->device_UUID = create_string_copy(UUID);
device->device_OS = create_string_copy(event->Os);
device->device_manufacturer = create_string_copy(get_device_property(desc, "manufacturer"));
device->device_model_name = create_string_copy(get_device_property(desc, "modelName"));
device->service_type = create_string_copy(get_device_property(desc, "serviceType"));
device->service_version = create_string_copy(event->ServiceVer);
device->service_id = create_string_copy(get_device_property(desc, "serviceId"));
list_add_sync(&devices, device);
print_device(device);
}
ixmlDocument_free(desc);
return 0;
}
int test(int M, int N)
{
Hinit;
list_t *lists[NO_LISTS];
build_lists(lists, NO_LISTS, N, M);
RUN_GC;
int hit_ratio = 0;
for (int i = 0; i < N; ++i)
{
uint64_t r = RANDOM;
if (list_contains(lists[r % NO_LISTS], r))
{
++hit_ratio;
}
}
Hexit;
free_lists(lists, NO_LISTS);
return hit_ratio;
}
bool
blacklist_matches(Blacklist *blacklist, const char *filename)
{
assert(blacklist != NULL);
assert(filename != NULL);
return list_contains(blacklist, (void *)filename);
}
lnode_t *list_prev(list_t *list, lnode_t *lnode)
{
assert (list_contains(list, lnode));
if (lnode->prev == list_nil(list))
return NULL;
return lnode->prev;
}
lnode_t *list_next(list_t *list, lnode_t *lnode)
{
assert (list_contains(list, lnode));
if (lnode->next == list_nil(list))
return NULL;
return lnode->next;
}
enum Status move_snake(Board* board, enum Direction dir) {
// Create a new beginning. Check boundaries.
PointList* beginning = next_move(board, dir);
if (beginning == NULL) {
return FAILURE;
}
// If we've gone backwards, don't do anything
if (board->snake->next && is_same_place(beginning, board->snake->next)) {
beginning->next = NULL;
free(beginning);
return SUCCESS;
}
// Check for collisions
if (list_contains(beginning, board->snake)) {
return FAILURE;
}
// Check for food
if (list_contains(beginning, board->foods)) {
// Attach the beginning to the rest of the snake;
beginning->next = board->snake;
board->snake = beginning;
remove_from_list(beginning, &(board->foods));
add_new_food(board);
return SUCCESS;
}
// Attach the beginning to the rest of the snake
beginning->next = board->snake;
board->snake = beginning;
// Cut off the end
PointList* end = board->snake;
while(end->next->next) {
end = end->next;
}
free(end->next);
end->next = NULL;
return SUCCESS;
}
void list_ins_before(list_t *list, lnode_t *node, lnode_t *succ)
{
lnode_t *pred = succ->prev;
assert (node != NULL);
assert (!list_contains(list, node));
assert (!lnode_is_in_a_list(node));
assert (succ == list_nil(list) || list_contains(list, succ));
assert (list->nodecount + 1 > list->nodecount);
node->next = succ;
node->prev = pred;
pred->next = node;
succ->prev = node;
list->nodecount++;
assert (list->nodecount <= list->maxcount);
}
static void copy_player_name(struct gr_core_player *p, void *args)
{
struct list *l = (struct list *) args;
if (list_contains(l, p->nickname))
return;
list_add(l, strdup(p->nickname));
}
void list_ins_after(list_t *list, lnode_t *node, lnode_t *pred)
{
lnode_t *succ = pred->next;
assert (node != NULL);
assert (!list_contains(list, node));
assert (!lnode_is_in_a_list(node));
assert (pred == list_nil(list) || list_contains(list, pred));
assert (list->nodecount + 1 > list->nodecount);
node->prev = pred;
node->next = succ;
succ->prev = node;
pred->next = node;
list->nodecount++;
assert (list->nodecount <= list->maxcount);
}
/**
* Fonction permettant d'afficher une case en fonction de son type.
* @param square Le type de case à afficher.
*/
static void print_square(Square * square) {
if (list_contains(g_player_view, &square)) {
set_background_color(square);
print_foreground(square);
} else {
ansi_set_bg_color(ANSI_GREY);
putchar(' ');
}
}
void
list_ins_before (list_t * list, lnode_t * newnode, lnode_t * thisnode)
{
lnode_t *that = thisnode->prev;
nassert (newnode != NULL);
nassert (!list_contains (list, newnode));
nassert (!lnode_is_in_a_list (newnode));
nassert (thisnode == list_nil (list) || list_contains (list, thisnode));
nassert (list->nodecount + 1 > list->nodecount);
newnode->next = thisnode;
newnode->prev = that;
that->next = newnode;
thisnode->prev = newnode;
list->nodecount++;
nassert (list->nodecount <= list->maxcount);
}
void
list_extract (list_t * dest, list_t * source, lnode_t * first, lnode_t * last)
{
listcount_t moved = 1;
nassert (first == NULL || list_contains (source, first));
nassert (last == NULL || list_contains (source, last));
if (first == NULL || last == NULL)
return;
/* adjust the destination list so that the slice is spliced out */
first->prev->next = last->next;
last->next->prev = first->prev;
/* graft the splice at the end of the dest list */
last->next = &dest->nilnode;
first->prev = dest->nilnode.prev;
dest->nilnode.prev->next = first;
dest->nilnode.prev = last;
while (first != last) {
first = first->next;
nassert (first != list_nil (source)); /* oops, last before first! */
moved++;
}
/* nassert no overflows */
nassert (source->nodecount - moved <= source->nodecount);
nassert (dest->nodecount + moved >= dest->nodecount);
/* nassert no weirdness */
nassert (moved <= source->nodecount);
source->nodecount -= moved;
dest->nodecount += moved;
/* nassert list sanity */
nassert (list_verify (source));
nassert (list_verify (dest));
}
//i.e. used in semaphore_up
void waitobject_wakeup_and_unlock_single(WaitObject* obj, Thread* wakeup,
uint flags)
{
assert_spinlock(&obj->lock);
assert(list_contains(&obj->wait_queue, wakeup));
list_remove(&obj->wait_queue, wakeup);
thread_wakeup_safe(wakeup, obj);
spinlock_unlock(&obj->lock);
}
static bool current_has_lock_on_disk (int d_id)
{
list_node_t *result;
osprd_info_t *d = &osprds[d_id];
spin_lock(&d->mutex);
result = list_contains(d->lock_holder_l, current->pid);
spin_unlock(&d->mutex);
return result ? true : false;
}
unsigned list_insert_list_uniq(const struct list *source, struct list *dest,
int (*compar)(const void *, const void *)) {
unsigned inserted = 0;
struct list_node *n = source->head;
while (n != NULL) {
if (!list_contains(dest, n->data, compar)) {
list_push(dest, n->data);
inserted++;
}
n = n->next;
}
return inserted;
}
FileWatch* add_file_watch_action(World* world, const char* filename, Value* action)
{
// Fetch the FileWatch entry.
FileWatch* watch = add_file_watch(world, filename);
// Check if this exact action already exists, if so do nothing.
if (list_contains(&watch->onChangeActions, action))
return watch;
// Add action
copy(action, list_append(&watch->onChangeActions));
return watch;
}
void
list_process (list_t * list, void *context, void (*function) (list_t * list, lnode_t * lnode, void *context))
{
lnode_t *node = list_first_priv (list), *next, *nil = list_nil (list);
while (node != nil) {
/* check for callback function deleting */
/* the next node from under us */
nassert (list_contains (list, node));
next = node->next;
function (list, node, context);
node = next;
}
}
/**
* Return the tentative choice for growing
*/
int greedyBFS_peek(list_graph* graph, partition* p, int node){
edge* head = graph->vertex[node].edge_list;
while (head){
if(graph->vertex[head->id].color < 2){
if(!list_contains(&(p->constraints), head->id))
return head->wgt;
}
head = head->next;
}
return -1;
}
lnode_t *list_delete(list_t *list, lnode_t *del)
{
lnode_t *next = del->next;
lnode_t *prev = del->prev;
assert (list_contains(list, del));
prev->next = next;
next->prev = prev;
list->nodecount--;
del->next = del->prev = NULL;
return del;
}
/**
* Expand a partition
*/
list* greedyBFS_grow(list_graph* graph, partition* p, int source, int dest){
//Prepare the queue
list* q = (list*) malloc ( sizeof(list));
list_init(q);
//Get the Adjacency list of the vertex
if (graph->vertex[dest].color == 2){
//Someone else already took our node
return NULL;
}
//Check for constraints
if(list_contains(&(p->constraints), dest)){
return NULL;
}
//Put the node in the partition
graph->vertex[dest].color = 2;
partition_add(p, dest, 0);
//Add the new constraints to the partition
partition_constraint_add(p, &(graph->vertex[dest].constraints));
//Check the adjacency list
edge* head = graph->vertex[dest].edge_list;
while(head != NULL){
if(graph->vertex[head->id].color < 2){
//Color Grey
graph->vertex[head->id].color = 1;
//Enqueue
list_insert(q, head->id);
}
head = head->next;
}
return q;
}
static int find_drive_id_for_waiter (pid_t p)
{
int i;
list_node_t *elem = NULL;
for(i = 0; i < NOSPRD; i++)
{
spin_lock(&(osprds[i].mutex));
elem = list_contains(osprds[i].lock_waiter_l, p);
spin_unlock(&(osprds[i].mutex));
if(elem && elem->visited == false)
{
elem->visited = true;
return i;
}
}
// If we get here, we've visited the node before
return -1;
}
/**
* Initial discovery to populate a list form a seed
*/
void greedyBFS_discovery(list_graph* graph, list* list, partition* p, int seed){
edge* head = graph->vertex[seed].edge_list;
//Check the adjacency list
while(head != NULL){
if(graph->vertex[head->id].color < 2){
if(!list_contains(&(p->constraints), head->id)){
//Color Grey
graph->vertex[head->id].color = 1;
//Enqueue
list_insert(list, head->id);
}
}
head = head->next;
}
}