Added CMC prefix to all macros and removed FMOD
This commit is contained in:
Leonardo committed
1 parent
4fe4e96811
commit
2ca2210a77
21 files changed
+5691
-5699
No files matched your search
+13
-13
@@ -20,20 +20,20 @@ size_t inthash(int t)
|
||||
return a;
|
||||
}
|
||||
|
||||
COLLECTION_GENERATE(LIST, l, list, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(STACK, s, stack, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(QUEUE, q, queue, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(DEQUE, d, deque, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(HEAP, h, heap, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(TREESET, ts, tset, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(TREEMAP, tm, tmap, /* FMOD */, int, int)
|
||||
COLLECTION_GENERATE(HASHSET, hs, hset, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(HASHMAP, hm, hmap, /* FMOD */, int, int)
|
||||
CMC_COLLECTION_GENERATE(LIST, l, list, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(STACK, s, stack, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(QUEUE, q, queue, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(DEQUE, d, deque, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(HEAP, h, heap, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(TREESET, ts, tset, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(TREEMAP, tm, tmap, int, int)
|
||||
CMC_COLLECTION_GENERATE(HASHSET, hs, hset, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(HASHMAP, hm, hmap, int, int)
|
||||
|
||||
COLLECTION_GENERATE(INTERVALHEAP, ih, iheap, /* FMOD */, , int)
|
||||
COLLECTION_GENERATE(MULTIMAP, mm, mmap, /* FMOD */, int, int)
|
||||
COLLECTION_GENERATE(MULTISET, ms, mset, , , int)
|
||||
CMC_COLLECTION_GENERATE(INTERVALHEAP, ih, iheap, , int)
|
||||
CMC_COLLECTION_GENERATE(MULTIMAP, mm, mmap, int, int)
|
||||
CMC_COLLECTION_GENERATE(MULTISET, ms, mset, , int)
|
||||
|
||||
int main(void)
|
||||
{
|
||||
|
||||
+41
-41
@@ -20,20 +20,20 @@ size_t inthash(int t)
|
||||
return a;
|
||||
}
|
||||
|
||||
COLLECTION_GENERATE(LIST, l, list, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(STACK, s, stack, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(QUEUE, q, queue, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(DEQUE, d, deque, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(HEAP, h, heap, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(TREESET, ts, tset, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(TREEMAP, tm, tmap, /* FMOD */, int, int)
|
||||
COLLECTION_GENERATE(HASHSET, hs, hset, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(HASHMAP, hm, hmap, /* FMOD */, int, int)
|
||||
CMC_COLLECTION_GENERATE(LIST, l, list, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(STACK, s, stack, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(QUEUE, q, queue, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(DEQUE, d, deque, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(HEAP, h, heap, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(TREESET, ts, tset, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(TREEMAP, tm, tmap, int, int)
|
||||
CMC_COLLECTION_GENERATE(HASHSET, hs, hset, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(HASHMAP, hm, hmap, int, int)
|
||||
|
||||
COLLECTION_GENERATE(INTERVALHEAP, ih, iheap, /* FMOD */, , int)
|
||||
COLLECTION_GENERATE(MULTIMAP, mm, mmap, /* FMOD */, int, int)
|
||||
COLLECTION_GENERATE(MULTISET, ms, mset, , , int)
|
||||
CMC_COLLECTION_GENERATE(INTERVALHEAP, ih, iheap, , int)
|
||||
CMC_COLLECTION_GENERATE(MULTIMAP, mm, mmap, int, int)
|
||||
CMC_COLLECTION_GENERATE(MULTISET, ms, mset, , int)
|
||||
|
||||
int main(void)
|
||||
{
|
||||
@@ -84,62 +84,62 @@ int main(void)
|
||||
|
||||
int sums[16] = {0};
|
||||
|
||||
FOR_EACH(d, deque, d, {
|
||||
CMC_FOR_EACH(d, deque, d, {
|
||||
sums[0] += d_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH(hm, hmap, hm, {
|
||||
CMC_FOR_EACH(hm, hmap, hm, {
|
||||
sums[1] += hm_iter_key(&iter);
|
||||
sums[2] += hm_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH(hs, hset, hs, {
|
||||
CMC_FOR_EACH(hs, hset, hs, {
|
||||
sums[3] += hs_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH(h, heap, h, {
|
||||
CMC_FOR_EACH(h, heap, h, {
|
||||
sums[4] += h_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH(ll, linked, ll, {
|
||||
CMC_FOR_EACH(ll, linked, ll, {
|
||||
sums[5] += ll_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH(l, list, l, {
|
||||
CMC_FOR_EACH(l, list, l, {
|
||||
sums[6] += l_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH(q, queue, q, {
|
||||
CMC_FOR_EACH(q, queue, q, {
|
||||
sums[7] += q_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH(s, stack, s, {
|
||||
CMC_FOR_EACH(s, stack, s, {
|
||||
sums[8] += s_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH(tm, tmap, tm, {
|
||||
CMC_FOR_EACH(tm, tmap, tm, {
|
||||
sums[9] += tm_iter_key(&iter);
|
||||
sums[10] += tm_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH(ts, tset, ts, {
|
||||
CMC_FOR_EACH(ts, tset, ts, {
|
||||
sums[11] += ts_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH(ih, iheap, ih, {
|
||||
CMC_FOR_EACH(ih, iheap, ih, {
|
||||
sums[12] += ih_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH(mm, mmap, mm, {
|
||||
CMC_FOR_EACH(mm, mmap, mm, {
|
||||
sums[13] += mm_iter_key(&iter);
|
||||
sums[14] += mm_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH(ms, mset, ms, {
|
||||
CMC_FOR_EACH(ms, mset, ms, {
|
||||
sums[15] += ms_iter_value(&iter);
|
||||
});
|
||||
|
||||
printf("\n-------------------- FOR_EACH --------------------\n");
|
||||
printf("\n-------------------- CMC_FOR_EACH --------------------\n");
|
||||
if (sums[0] == 50005000)
|
||||
printf("%12s PASSED\n", "DEQUE");
|
||||
else
|
||||
@@ -197,62 +197,62 @@ int main(void)
|
||||
|
||||
memset(sums, 0, sizeof sums);
|
||||
|
||||
FOR_EACH_REV(d, deque, d, {
|
||||
CMC_FOR_EACH_REV(d, deque, d, {
|
||||
sums[0] += d_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH_REV(hm, hmap, hm, {
|
||||
CMC_FOR_EACH_REV(hm, hmap, hm, {
|
||||
sums[1] += hm_iter_key(&iter);
|
||||
sums[2] += hm_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH_REV(hs, hset, hs, {
|
||||
CMC_FOR_EACH_REV(hs, hset, hs, {
|
||||
sums[3] += hs_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH_REV(h, heap, h, {
|
||||
CMC_FOR_EACH_REV(h, heap, h, {
|
||||
sums[4] += h_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH_REV(ll, linked, ll, {
|
||||
CMC_FOR_EACH_REV(ll, linked, ll, {
|
||||
sums[5] += ll_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH_REV(l, list, l, {
|
||||
CMC_FOR_EACH_REV(l, list, l, {
|
||||
sums[6] += l_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH_REV(q, queue, q, {
|
||||
CMC_FOR_EACH_REV(q, queue, q, {
|
||||
sums[7] += q_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH_REV(s, stack, s, {
|
||||
CMC_FOR_EACH_REV(s, stack, s, {
|
||||
sums[8] += s_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH_REV(tm, tmap, tm, {
|
||||
CMC_FOR_EACH_REV(tm, tmap, tm, {
|
||||
sums[9] += tm_iter_key(&iter);
|
||||
sums[10] += tm_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH_REV(ts, tset, ts, {
|
||||
CMC_FOR_EACH_REV(ts, tset, ts, {
|
||||
sums[11] += ts_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH_REV(ih, iheap, ih, {
|
||||
CMC_FOR_EACH_REV(ih, iheap, ih, {
|
||||
sums[12] += ih_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH_REV(mm, mmap, mm, {
|
||||
CMC_FOR_EACH_REV(mm, mmap, mm, {
|
||||
sums[13] += mm_iter_key(&iter);
|
||||
sums[14] += mm_iter_value(&iter);
|
||||
});
|
||||
|
||||
FOR_EACH_REV(ms, mset, ms, {
|
||||
CMC_FOR_EACH_REV(ms, mset, ms, {
|
||||
sums[15] += ms_iter_value(&iter);
|
||||
});
|
||||
|
||||
printf("-------------------- FOR_EACH_REV --------------------\n");
|
||||
printf("-------------------- CMC_FOR_EACH_REV --------------------\n");
|
||||
if (sums[0] == 50005000)
|
||||
printf("%12s PASSED\n", "DEQUE");
|
||||
else
|
||||
|
||||
+13
-13
@@ -18,20 +18,20 @@ size_t inthash(int t)
|
||||
return a;
|
||||
}
|
||||
|
||||
COLLECTION_GENERATE(LIST, l, list, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(STACK, s, stack, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(QUEUE, q, queue, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(DEQUE, d, deque, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(HEAP, h, heap, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(TREESET, ts, tset, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(TREEMAP, tm, tmap, /* FMOD */, int, double)
|
||||
COLLECTION_GENERATE(HASHSET, hs, hset, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE(HASHMAP, hm, hmap, /* FMOD */, int, double)
|
||||
CMC_COLLECTION_GENERATE(LIST, l, list, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(STACK, s, stack, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(QUEUE, q, queue, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(DEQUE, d, deque, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(HEAP, h, heap, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(TREESET, ts, tset, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(TREEMAP, tm, tmap, int, double)
|
||||
CMC_COLLECTION_GENERATE(HASHSET, hs, hset, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(HASHMAP, hm, hmap, int, double)
|
||||
|
||||
COLLECTION_GENERATE(INTERVALHEAP, ih, iheap, /* FMOD */, , int)
|
||||
COLLECTION_GENERATE(MULTIMAP, mm, mmap, /* FMOD */, int, double)
|
||||
COLLECTION_GENERATE(MULTISET, ms, mset, , , int)
|
||||
CMC_COLLECTION_GENERATE(INTERVALHEAP, ih, iheap, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(MULTIMAP, mm, mmap, int, double)
|
||||
CMC_COLLECTION_GENERATE(MULTISET, ms, mset, /* K */, int)
|
||||
|
||||
#define ITERATOR_TEST(NAME, PFX, sname, initfunc, insertbody, sumbody, validation1, validation2) \
|
||||
void NAME##_iterator_test(void) \
|
||||
|
||||
+13
-13
@@ -1,16 +1,16 @@
|
||||
#include "sep.h"
|
||||
|
||||
COLLECTION_GENERATE_SOURCE(LIST, l, list, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_SOURCE(STACK, s, stack, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_SOURCE(QUEUE, q, queue, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_SOURCE(DEQUE, d, deque, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_SOURCE(LINKEDLIST, ll, linked, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_SOURCE(HEAP, h, heap, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_SOURCE(TREESET, ts, tset, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_SOURCE(TREEMAP, tm, tmap, /* FMOD */, int, int)
|
||||
COLLECTION_GENERATE_SOURCE(HASHSET, hs, hset, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_SOURCE(HASHMAP, hm, hmap, /* FMOD */, int, int)
|
||||
CMC_COLLECTION_GENERATE_SOURCE(LIST, l, list, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_SOURCE(STACK, s, stack, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_SOURCE(QUEUE, q, queue, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_SOURCE(DEQUE, d, deque, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_SOURCE(LINKEDLIST, ll, linked, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_SOURCE(HEAP, h, heap, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_SOURCE(TREESET, ts, tset, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_SOURCE(TREEMAP, tm, tmap, int, int)
|
||||
CMC_COLLECTION_GENERATE_SOURCE(HASHSET, hs, hset, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_SOURCE(HASHMAP, hm, hmap, int, int)
|
||||
|
||||
COLLECTION_GENERATE_SOURCE(INTERVALHEAP, ih, iheap, /* FMOD */, , int)
|
||||
COLLECTION_GENERATE_SOURCE(MULTIMAP, mm, mmap, /* FMOD */, int, int)
|
||||
COLLECTION_GENERATE_SOURCE(MULTISET, ms, mset, , , int)
|
||||
CMC_COLLECTION_GENERATE_SOURCE(INTERVALHEAP, ih, iheap, , int)
|
||||
CMC_COLLECTION_GENERATE_SOURCE(MULTIMAP, mm, mmap, int, int)
|
||||
CMC_COLLECTION_GENERATE_SOURCE(MULTISET, ms, mset, , int)
|
||||
+13
-13
@@ -1,16 +1,16 @@
|
||||
#include "../../src/macro_collections.h"
|
||||
|
||||
COLLECTION_GENERATE_HEADER(LIST, l, list, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_HEADER(STACK, s, stack, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_HEADER(QUEUE, q, queue, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_HEADER(DEQUE, d, deque, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_HEADER(LINKEDLIST, ll, linked, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_HEADER(HEAP, h, heap, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_HEADER(TREESET, ts, tset, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_HEADER(TREEMAP, tm, tmap, /* FMOD */, int, int)
|
||||
COLLECTION_GENERATE_HEADER(HASHSET, hs, hset, /* FMOD */, /* K */, int)
|
||||
COLLECTION_GENERATE_HEADER(HASHMAP, hm, hmap, /* FMOD */, int, int)
|
||||
CMC_COLLECTION_GENERATE_HEADER(LIST, l, list, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_HEADER(STACK, s, stack, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_HEADER(QUEUE, q, queue, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_HEADER(DEQUE, d, deque, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_HEADER(LINKEDLIST, ll, linked, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_HEADER(HEAP, h, heap, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_HEADER(TREESET, ts, tset, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_HEADER(TREEMAP, tm, tmap, int, int)
|
||||
CMC_COLLECTION_GENERATE_HEADER(HASHSET, hs, hset, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE_HEADER(HASHMAP, hm, hmap, int, int)
|
||||
|
||||
COLLECTION_GENERATE_HEADER(INTERVALHEAP, ih, iheap, /* FMOD */, , int)
|
||||
COLLECTION_GENERATE_HEADER(MULTIMAP, mm, mmap, /* FMOD */, int, int)
|
||||
COLLECTION_GENERATE_HEADER(MULTISET, ms, mset, , , int)
|
||||
CMC_COLLECTION_GENERATE_HEADER(INTERVALHEAP, ih, iheap, , int)
|
||||
CMC_COLLECTION_GENERATE_HEADER(MULTIMAP, mm, mmap, int, int)
|
||||
CMC_COLLECTION_GENERATE_HEADER(MULTISET, ms, mset, , int)
|
||||
+127
-128
@@ -26,143 +26,142 @@ typedef union union_u {
|
||||
|
||||
typedef int (*func_t)(int, double, char *);
|
||||
|
||||
COLLECTION_GENERATE(LIST, l0, list0, static, /* K */, struct_t *)
|
||||
COLLECTION_GENERATE(STACK, s0, stack0, static, /* K */, struct_t *)
|
||||
COLLECTION_GENERATE(QUEUE, q0, queue0, static, /* K */, struct_t *)
|
||||
COLLECTION_GENERATE(DEQUE, d0, deque0, static, /* K */, struct_t *)
|
||||
COLLECTION_GENERATE(LINKEDLIST, ll0, linked0, static, /* K */, struct_t *)
|
||||
COLLECTION_GENERATE(HEAP, h0, heap0, static, /* K */, struct_t *)
|
||||
COLLECTION_GENERATE(TREESET, ts0, tset0, static, /* K */, struct_t *)
|
||||
COLLECTION_GENERATE(TREEMAP, tm0, tmap0, static, struct_t *, struct_t *)
|
||||
COLLECTION_GENERATE(HASHSET, hs0, hset0, static, /* K */, struct_t *)
|
||||
COLLECTION_GENERATE(HASHMAP, hm0, hmap0, static, struct_t *, struct_t *)
|
||||
COLLECTION_GENERATE(INTERVALHEAP, ih0, iheap0, static, struct_t *, struct_t *)
|
||||
COLLECTION_GENERATE(MULTIMAP, mm0, mmap0, static, struct_t *, struct_t *)
|
||||
COLLECTION_GENERATE(MULTISET, ms0, mset0, static, struct_t *, struct_t *)
|
||||
CMC_COLLECTION_GENERATE(LIST, l0, list0, /* K */, struct_t *)
|
||||
CMC_COLLECTION_GENERATE(STACK, s0, stack0, /* K */, struct_t *)
|
||||
CMC_COLLECTION_GENERATE(QUEUE, q0, queue0, /* K */, struct_t *)
|
||||
CMC_COLLECTION_GENERATE(DEQUE, d0, deque0, /* K */, struct_t *)
|
||||
CMC_COLLECTION_GENERATE(LINKEDLIST, ll0, linked0, /* K */, struct_t *)
|
||||
CMC_COLLECTION_GENERATE(HEAP, h0, heap0, /* K */, struct_t *)
|
||||
CMC_COLLECTION_GENERATE(TREESET, ts0, tset0, /* K */, struct_t *)
|
||||
CMC_COLLECTION_GENERATE(TREEMAP, tm0, tmap0, struct_t *, struct_t *)
|
||||
CMC_COLLECTION_GENERATE(HASHSET, hs0, hset0, /* K */, struct_t *)
|
||||
CMC_COLLECTION_GENERATE(HASHMAP, hm0, hmap0, struct_t *, struct_t *)
|
||||
CMC_COLLECTION_GENERATE(INTERVALHEAP, ih0, iheap0, struct_t *, struct_t *)
|
||||
CMC_COLLECTION_GENERATE(MULTIMAP, mm0, mmap0, struct_t *, struct_t *)
|
||||
CMC_COLLECTION_GENERATE(MULTISET, ms0, mset0, struct_t *, struct_t *)
|
||||
|
||||
COLLECTION_GENERATE(LIST, l1, list1, static, /* K */, struct_t)
|
||||
COLLECTION_GENERATE(STACK, s1, stack1, static, /* K */, struct_t)
|
||||
COLLECTION_GENERATE(QUEUE, q1, queue1, static, /* K */, struct_t)
|
||||
COLLECTION_GENERATE(DEQUE, d1, deque1, static, /* K */, struct_t)
|
||||
COLLECTION_GENERATE(LINKEDLIST, ll1, linked1, static, /* K */, struct_t)
|
||||
COLLECTION_GENERATE(HEAP, h1, heap1, static, /* K */, struct_t)
|
||||
COLLECTION_GENERATE(TREESET, ts1, tset1, static, /* K */, struct_t)
|
||||
COLLECTION_GENERATE(TREEMAP, tm1, tmap1, static, struct_t, struct_t)
|
||||
COLLECTION_GENERATE(HASHSET, hs1, hset1, static, /* K */, struct_t)
|
||||
COLLECTION_GENERATE(HASHMAP, hm1, hmap1, static, struct_t, struct_t)
|
||||
COLLECTION_GENERATE(INTERVALHEAP, ih1, iheap1, static, struct_t, struct_t)
|
||||
COLLECTION_GENERATE(MULTIMAP, mm1, mmap1, static, struct_t, struct_t)
|
||||
COLLECTION_GENERATE(MULTISET, ms1, mset1, static, struct_t, struct_t)
|
||||
CMC_COLLECTION_GENERATE(LIST, l1, list1, /* K */, struct_t)
|
||||
CMC_COLLECTION_GENERATE(STACK, s1, stack1, /* K */, struct_t)
|
||||
CMC_COLLECTION_GENERATE(QUEUE, q1, queue1, /* K */, struct_t)
|
||||
CMC_COLLECTION_GENERATE(DEQUE, d1, deque1, /* K */, struct_t)
|
||||
CMC_COLLECTION_GENERATE(LINKEDLIST, ll1, linked1, /* K */, struct_t)
|
||||
CMC_COLLECTION_GENERATE(HEAP, h1, heap1, /* K */, struct_t)
|
||||
CMC_COLLECTION_GENERATE(TREESET, ts1, tset1, /* K */, struct_t)
|
||||
CMC_COLLECTION_GENERATE(TREEMAP, tm1, tmap1, struct_t, struct_t)
|
||||
CMC_COLLECTION_GENERATE(HASHSET, hs1, hset1, /* K */, struct_t)
|
||||
CMC_COLLECTION_GENERATE(HASHMAP, hm1, hmap1, struct_t, struct_t)
|
||||
CMC_COLLECTION_GENERATE(INTERVALHEAP, ih1, iheap1, struct_t, struct_t)
|
||||
CMC_COLLECTION_GENERATE(MULTIMAP, mm1, mmap1, struct_t, struct_t)
|
||||
CMC_COLLECTION_GENERATE(MULTISET, ms1, mset1, struct_t, struct_t)
|
||||
|
||||
COLLECTION_GENERATE(LIST, l2, list2, static, /* K */, int)
|
||||
COLLECTION_GENERATE(STACK, s2, stack2, static, /* K */, int)
|
||||
COLLECTION_GENERATE(QUEUE, q2, queue2, static, /* K */, int)
|
||||
COLLECTION_GENERATE(DEQUE, d2, deque2, static, /* K */, int)
|
||||
COLLECTION_GENERATE(LINKEDLIST, ll2, linked2, static, /* K */, int)
|
||||
COLLECTION_GENERATE(HEAP, h2, heap2, static, /* K */, int)
|
||||
COLLECTION_GENERATE(TREESET, ts2, tset2, static, /* K */, int)
|
||||
COLLECTION_GENERATE(TREEMAP, tm2, tmap2, static, int, int)
|
||||
COLLECTION_GENERATE(HASHSET, hs2, hset2, static, /* K */, int)
|
||||
COLLECTION_GENERATE(HASHMAP, hm2, hmap2, static, int, int)
|
||||
COLLECTION_GENERATE(INTERVALHEAP, ih2, iheap2, static, /* K */, int)
|
||||
COLLECTION_GENERATE(MULTIMAP, mm2, mmap2, static, int, int)
|
||||
COLLECTION_GENERATE(MULTISET, ms2, mset2, static, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(LIST, l2, list2, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(STACK, s2, stack2, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(QUEUE, q2, queue2, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(DEQUE, d2, deque2, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(LINKEDLIST, ll2, linked2, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(HEAP, h2, heap2, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(TREESET, ts2, tset2, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(TREEMAP, tm2, tmap2, int, int)
|
||||
CMC_COLLECTION_GENERATE(HASHSET, hs2, hset2, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(HASHMAP, hm2, hmap2, int, int)
|
||||
CMC_COLLECTION_GENERATE(INTERVALHEAP, ih2, iheap2, /* K */, int)
|
||||
CMC_COLLECTION_GENERATE(MULTIMAP, mm2, mmap2, int, int)
|
||||
CMC_COLLECTION_GENERATE(MULTISET, ms2, mset2, /* K */, int)
|
||||
|
||||
COLLECTION_GENERATE(LIST, l3, list3, static, /* K */, int *)
|
||||
COLLECTION_GENERATE(STACK, s3, stack3, static, /* K */, int *)
|
||||
COLLECTION_GENERATE(QUEUE, q3, queue3, static, /* K */, int *)
|
||||
COLLECTION_GENERATE(DEQUE, d3, deque3, static, /* K */, int *)
|
||||
COLLECTION_GENERATE(LINKEDLIST, ll3, linked3, static, /* K */, int *)
|
||||
COLLECTION_GENERATE(HEAP, h3, heap3, static, /* K */, int *)
|
||||
COLLECTION_GENERATE(TREESET, ts3, tset3, static, /* K */, int *)
|
||||
COLLECTION_GENERATE(TREEMAP, tm3, tmap3, static, int *, int *)
|
||||
COLLECTION_GENERATE(HASHSET, hs3, hset3, static, /* K */, int *)
|
||||
COLLECTION_GENERATE(HASHMAP, hm3, hmap3, static, int *, int *)
|
||||
COLLECTION_GENERATE(INTERVALHEAP, ih3, iheap3, static, /* K */, int *)
|
||||
COLLECTION_GENERATE(MULTIMAP, mm3, mmap3, static, int *, int *)
|
||||
COLLECTION_GENERATE(MULTISET, ms3, mset3, static, /* K */, int *)
|
||||
CMC_COLLECTION_GENERATE(LIST, l3, list3, /* K */, int *)
|
||||
CMC_COLLECTION_GENERATE(STACK, s3, stack3, /* K */, int *)
|
||||
CMC_COLLECTION_GENERATE(QUEUE, q3, queue3, /* K */, int *)
|
||||
CMC_COLLECTION_GENERATE(DEQUE, d3, deque3, /* K */, int *)
|
||||
CMC_COLLECTION_GENERATE(LINKEDLIST, ll3, linked3, /* K */, int *)
|
||||
CMC_COLLECTION_GENERATE(HEAP, h3, heap3, /* K */, int *)
|
||||
CMC_COLLECTION_GENERATE(TREESET, ts3, tset3, /* K */, int *)
|
||||
CMC_COLLECTION_GENERATE(TREEMAP, tm3, tmap3, int *, int *)
|
||||
CMC_COLLECTION_GENERATE(HASHSET, hs3, hset3, /* K */, int *)
|
||||
CMC_COLLECTION_GENERATE(HASHMAP, hm3, hmap3, int *, int *)
|
||||
CMC_COLLECTION_GENERATE(INTERVALHEAP, ih3, iheap3, /* K */, int *)
|
||||
CMC_COLLECTION_GENERATE(MULTIMAP, mm3, mmap3, int *, int *)
|
||||
CMC_COLLECTION_GENERATE(MULTISET, ms3, mset3, /* K */, int *)
|
||||
|
||||
COLLECTION_GENERATE(LIST, l4, list4, static, /* K */, enum_t *)
|
||||
COLLECTION_GENERATE(STACK, s4, stack4, static, /* K */, enum_t *)
|
||||
COLLECTION_GENERATE(QUEUE, q4, queue4, static, /* K */, enum_t *)
|
||||
COLLECTION_GENERATE(DEQUE, d4, deque4, static, /* K */, enum_t *)
|
||||
COLLECTION_GENERATE(LINKEDLIST, ll4, linked4, static, /* K */, enum_t *)
|
||||
COLLECTION_GENERATE(HEAP, h4, heap4, static, /* K */, enum_t *)
|
||||
COLLECTION_GENERATE(TREESET, ts4, tset4, static, /* K */, enum_t *)
|
||||
COLLECTION_GENERATE(TREEMAP, tm4, tmap4, static, enum_t *, enum_t *)
|
||||
COLLECTION_GENERATE(HASHSET, hs4, hset4, static, /* K */, enum_t *)
|
||||
COLLECTION_GENERATE(HASHMAP, hm4, hmap4, static, enum_t *, enum_t *)
|
||||
COLLECTION_GENERATE(INTERVALHEAP, ih4, iheap4, static, /* K */, enum_t *)
|
||||
COLLECTION_GENERATE(MULTIMAP, mm4, mmap4, static, enum_t *, enum_t *)
|
||||
COLLECTION_GENERATE(MULTISET, ms4, mset4, static, /* K */, enum_t *)
|
||||
CMC_COLLECTION_GENERATE(LIST, l4, list4, /* K */, enum_t *)
|
||||
CMC_COLLECTION_GENERATE(STACK, s4, stack4, /* K */, enum_t *)
|
||||
CMC_COLLECTION_GENERATE(QUEUE, q4, queue4, /* K */, enum_t *)
|
||||
CMC_COLLECTION_GENERATE(DEQUE, d4, deque4, /* K */, enum_t *)
|
||||
CMC_COLLECTION_GENERATE(LINKEDLIST, ll4, linked4, /* K */, enum_t *)
|
||||
CMC_COLLECTION_GENERATE(HEAP, h4, heap4, /* K */, enum_t *)
|
||||
CMC_COLLECTION_GENERATE(TREESET, ts4, tset4, /* K */, enum_t *)
|
||||
CMC_COLLECTION_GENERATE(TREEMAP, tm4, tmap4, enum_t *, enum_t *)
|
||||
CMC_COLLECTION_GENERATE(HASHSET, hs4, hset4, /* K */, enum_t *)
|
||||
CMC_COLLECTION_GENERATE(HASHMAP, hm4, hmap4, enum_t *, enum_t *)
|
||||
CMC_COLLECTION_GENERATE(INTERVALHEAP, ih4, iheap4, /* K */, enum_t *)
|
||||
CMC_COLLECTION_GENERATE(MULTIMAP, mm4, mmap4, enum_t *, enum_t *)
|
||||
CMC_COLLECTION_GENERATE(MULTISET, ms4, mset4, /* K */, enum_t *)
|
||||
|
||||
COLLECTION_GENERATE(LIST, l5, list5, static, /* K */, enum_t)
|
||||
COLLECTION_GENERATE(STACK, s5, stack5, static, /* K */, enum_t)
|
||||
COLLECTION_GENERATE(QUEUE, q5, queue5, static, /* K */, enum_t)
|
||||
COLLECTION_GENERATE(DEQUE, d5, deque5, static, /* K */, enum_t)
|
||||
COLLECTION_GENERATE(LINKEDLIST, ll5, linked5, static, /* K */, enum_t)
|
||||
COLLECTION_GENERATE(HEAP, h5, heap5, static, /* K */, enum_t)
|
||||
COLLECTION_GENERATE(TREESET, ts5, tset5, static, /* K */, enum_t)
|
||||
COLLECTION_GENERATE(TREEMAP, tm5, tmap5, static, enum_t, enum_t)
|
||||
COLLECTION_GENERATE(HASHSET, hs5, hset5, static, /* K */, enum_t)
|
||||
COLLECTION_GENERATE(HASHMAP, hm5, hmap5, static, enum_t, enum_t)
|
||||
COLLECTION_GENERATE(INTERVALHEAP, ih5, iheap5, static, /* K */, enum_t)
|
||||
COLLECTION_GENERATE(MULTIMAP, mm5, mmap5, static, enum_t, enum_t)
|
||||
COLLECTION_GENERATE(MULTISET, ms5, mset5, static, /* K */, enum_t)
|
||||
CMC_COLLECTION_GENERATE(LIST, l5, list5, /* K */, enum_t)
|
||||
CMC_COLLECTION_GENERATE(STACK, s5, stack5, /* K */, enum_t)
|
||||
CMC_COLLECTION_GENERATE(QUEUE, q5, queue5, /* K */, enum_t)
|
||||
CMC_COLLECTION_GENERATE(DEQUE, d5, deque5, /* K */, enum_t)
|
||||
CMC_COLLECTION_GENERATE(LINKEDLIST, ll5, linked5, /* K */, enum_t)
|
||||
CMC_COLLECTION_GENERATE(HEAP, h5, heap5, /* K */, enum_t)
|
||||
CMC_COLLECTION_GENERATE(TREESET, ts5, tset5, /* K */, enum_t)
|
||||
CMC_COLLECTION_GENERATE(TREEMAP, tm5, tmap5, enum_t, enum_t)
|
||||
CMC_COLLECTION_GENERATE(HASHSET, hs5, hset5, /* K */, enum_t)
|
||||
CMC_COLLECTION_GENERATE(HASHMAP, hm5, hmap5, enum_t, enum_t)
|
||||
CMC_COLLECTION_GENERATE(INTERVALHEAP, ih5, iheap5, /* K */, enum_t)
|
||||
CMC_COLLECTION_GENERATE(MULTIMAP, mm5, mmap5, enum_t, enum_t)
|
||||
CMC_COLLECTION_GENERATE(MULTISET, ms5, mset5, /* K */, enum_t)
|
||||
|
||||
COLLECTION_GENERATE(LIST, l6, list6, static, /* K */, union_t *)
|
||||
COLLECTION_GENERATE(STACK, s6, stack6, static, /* K */, union_t *)
|
||||
COLLECTION_GENERATE(QUEUE, q6, queue6, static, /* K */, union_t *)
|
||||
COLLECTION_GENERATE(DEQUE, d6, deque6, static, /* K */, union_t *)
|
||||
COLLECTION_GENERATE(LINKEDLIST, ll6, linked6, static, /* K */, union_t *)
|
||||
COLLECTION_GENERATE(HEAP, h6, heap6, static, /* K */, union_t *)
|
||||
COLLECTION_GENERATE(TREESET, ts6, tset6, static, /* K */, union_t *)
|
||||
COLLECTION_GENERATE(TREEMAP, tm6, tmap6, static, union_t *, union_t *)
|
||||
COLLECTION_GENERATE(HASHSET, hs6, hset6, static, /* K */, union_t *)
|
||||
COLLECTION_GENERATE(HASHMAP, hm6, hmap6, static, union_t *, union_t *)
|
||||
COLLECTION_GENERATE(INTERVALHEAP, ih6, iheap6, static, /* K */, union_t *)
|
||||
COLLECTION_GENERATE(MULTIMAP, mm6, mmap6, static, union_t *, union_t *)
|
||||
COLLECTION_GENERATE(MULTISET, ms6, mset6, static, /* K */, union_t *)
|
||||
CMC_COLLECTION_GENERATE(LIST, l6, list6, /* K */, union_t *)
|
||||
CMC_COLLECTION_GENERATE(STACK, s6, stack6, /* K */, union_t *)
|
||||
CMC_COLLECTION_GENERATE(QUEUE, q6, queue6, /* K */, union_t *)
|
||||
CMC_COLLECTION_GENERATE(DEQUE, d6, deque6, /* K */, union_t *)
|
||||
CMC_COLLECTION_GENERATE(LINKEDLIST, ll6, linked6, /* K */, union_t *)
|
||||
CMC_COLLECTION_GENERATE(HEAP, h6, heap6, /* K */, union_t *)
|
||||
CMC_COLLECTION_GENERATE(TREESET, ts6, tset6, /* K */, union_t *)
|
||||
CMC_COLLECTION_GENERATE(TREEMAP, tm6, tmap6, union_t *, union_t *)
|
||||
CMC_COLLECTION_GENERATE(HASHSET, hs6, hset6, /* K */, union_t *)
|
||||
CMC_COLLECTION_GENERATE(HASHMAP, hm6, hmap6, union_t *, union_t *)
|
||||
CMC_COLLECTION_GENERATE(INTERVALHEAP, ih6, iheap6, /* K */, union_t *)
|
||||
CMC_COLLECTION_GENERATE(MULTIMAP, mm6, mmap6, union_t *, union_t *)
|
||||
CMC_COLLECTION_GENERATE(MULTISET, ms6, mset6, /* K */, union_t *)
|
||||
|
||||
CMC_COLLECTION_GENERATE(LIST, l7, list7, /* K */, union_t)
|
||||
CMC_COLLECTION_GENERATE(STACK, s7, stack7, /* K */, union_t)
|
||||
CMC_COLLECTION_GENERATE(QUEUE, q7, queue7, /* K */, union_t)
|
||||
CMC_COLLECTION_GENERATE(DEQUE, d7, deque7, /* K */, union_t)
|
||||
CMC_COLLECTION_GENERATE(LINKEDLIST, ll7, linked7, /* K */, union_t)
|
||||
CMC_COLLECTION_GENERATE(HEAP, h7, heap7, /* K */, union_t)
|
||||
CMC_COLLECTION_GENERATE(TREESET, ts7, tset7, /* K */, union_t)
|
||||
CMC_COLLECTION_GENERATE(TREEMAP, tm7, tmap7, union_t, union_t)
|
||||
CMC_COLLECTION_GENERATE(HASHSET, hs7, hset7, /* K */, union_t)
|
||||
CMC_COLLECTION_GENERATE(HASHMAP, hm7, hmap7, union_t, union_t)
|
||||
CMC_COLLECTION_GENERATE(INTERVALHEAP, ih7, iheap7, /* K */, union_t)
|
||||
CMC_COLLECTION_GENERATE(MULTIMAP, mm7, mmap7, union_t, union_t)
|
||||
CMC_COLLECTION_GENERATE(MULTISET, ms7, mset7, /* K */, union_t)
|
||||
|
||||
COLLECTION_GENERATE(LIST, l7, list7, static, /* K */, union_t)
|
||||
COLLECTION_GENERATE(STACK, s7, stack7, static, /* K */, union_t)
|
||||
COLLECTION_GENERATE(QUEUE, q7, queue7, static, /* K */, union_t)
|
||||
COLLECTION_GENERATE(DEQUE, d7, deque7, static, /* K */, union_t)
|
||||
COLLECTION_GENERATE(LINKEDLIST, ll7, linked7, static, /* K */, union_t)
|
||||
COLLECTION_GENERATE(HEAP, h7, heap7, static, /* K */, union_t)
|
||||
COLLECTION_GENERATE(TREESET, ts7, tset7, static, /* K */, union_t)
|
||||
COLLECTION_GENERATE(TREEMAP, tm7, tmap7, static, union_t, union_t)
|
||||
COLLECTION_GENERATE(HASHSET, hs7, hset7, static, /* K */, union_t)
|
||||
COLLECTION_GENERATE(HASHMAP, hm7, hmap7, static, union_t, union_t)
|
||||
COLLECTION_GENERATE(INTERVALHEAP, ih7, iheap7, static, /* K */, union_t)
|
||||
COLLECTION_GENERATE(MULTIMAP, mm7, mmap7, static, union_t, union_t)
|
||||
COLLECTION_GENERATE(MULTISET, ms7, mset7, static, /* K */, union_t)
|
||||
CMC_COLLECTION_GENERATE(LIST, l8, list8, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(STACK, s8, stack8, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(QUEUE, q8, queue8, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(DEQUE, d8, deque8, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(LINKEDLIST, ll8, linked8, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(HEAP, h8, heap8, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(TREESET, ts8, tset8, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(TREEMAP, tm8, tmap8, func_t, func_t)
|
||||
CMC_COLLECTION_GENERATE(HASHSET, hs8, hset8, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(HASHMAP, hm8, hmap8, func_t, func_t)
|
||||
CMC_COLLECTION_GENERATE(INTERVALHEAP, ih8, iheap8, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(MULTIMAP, mm8, mmap8, func_t, func_t)
|
||||
CMC_COLLECTION_GENERATE(MULTISET, ms8, mset8, /* K */, func_t)
|
||||
|
||||
COLLECTION_GENERATE(LIST, l8, list8, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(STACK, s8, stack8, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(QUEUE, q8, queue8, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(DEQUE, d8, deque8, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(LINKEDLIST, ll8, linked8, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(HEAP, h8, heap8, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(TREESET, ts8, tset8, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(TREEMAP, tm8, tmap8, static, func_t, func_t)
|
||||
COLLECTION_GENERATE(HASHSET, hs8, hset8, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(HASHMAP, hm8, hmap8, static, func_t, func_t)
|
||||
COLLECTION_GENERATE(INTERVALHEAP, ih8, iheap8, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(MULTIMAP, mm8, mmap8, static, func_t, func_t)
|
||||
COLLECTION_GENERATE(MULTISET, ms8, mset8, static, /* K */, func_t)
|
||||
|
||||
COLLECTION_GENERATE(LIST, l9, list9, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(STACK, s9, stack9, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(QUEUE, q9, queue9, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(DEQUE, d9, deque9, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(LINKEDLIST, ll9, linked9, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(HEAP, h9, heap9, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(TREESET, ts9, tset9, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(TREEMAP, tm9, tmap9, static, func_t, func_t)
|
||||
COLLECTION_GENERATE(HASHSET, hs9, hset9, static, /* K */, func_t)
|
||||
COLLECTION_GENERATE(HASHMAP, hm9, hmap9, static, func_t, func_t)
|
||||
CMC_COLLECTION_GENERATE(LIST, l9, list9, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(STACK, s9, stack9, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(QUEUE, q9, queue9, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(DEQUE, d9, deque9, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(LINKEDLIST, ll9, linked9, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(HEAP, h9, heap9, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(TREESET, ts9, tset9, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(TREEMAP, tm9, tmap9, func_t, func_t)
|
||||
CMC_COLLECTION_GENERATE(HASHSET, hs9, hset9, /* K */, func_t)
|
||||
CMC_COLLECTION_GENERATE(HASHMAP, hm9, hmap9, func_t, func_t)
|
||||
|
||||
int main(void)
|
||||
{
|
||||
|
||||
Reference in new issue
Block a user