Debian Codegraph @

rts/c/event_list.h

raw
1 // Start of event_list.h
2
3 typedef int (*event_report_fn)(struct str_builder*, void*);
4
5 // A collection of key-value associations. Used to associate extra data with
6 // events.
7 struct kvs {
8 // A buffer that contains all value data. Must be freed when the struct kvs is
9 // no longer used.
10 char *buf;
11
12 // Size of buf in bytes.
13 size_t buf_size;
14
15 // Number of bytes used in buf.
16 size_t buf_used;
17
18 // Number of associations stored.
19 size_t n;
20
21 // Capacity of vals.
22 size_t vals_capacity;
23
24 // An array of keys.
25 const char* *keys;
26
27 // Indexes into 'buf' that contains the values as zero-terminated strings.
28 size_t *vals;
29 };
30
31 static const size_t KVS_INIT_BUF_SIZE = 128;
32 static const size_t KVS_INIT_NUMKEYS = 8;
33
34 void kvs_init(struct kvs* kvs) {
35 kvs->buf = malloc(KVS_INIT_BUF_SIZE);
36 kvs->buf_size = KVS_INIT_BUF_SIZE;
37 kvs->buf_used = 0;
38 kvs->vals_capacity = KVS_INIT_NUMKEYS;
39 kvs->keys = calloc(kvs->vals_capacity, sizeof(const char*));
40 kvs->vals = calloc(kvs->vals_capacity, sizeof(size_t));
41 kvs->n = 0;
42 }
43
44 struct kvs* kvs_new(void) {
45 struct kvs *kvs = malloc(sizeof(struct kvs));
46 kvs_init(kvs);
47 return kvs;
48 }
49
50 void kvs_printf(struct kvs* kvs, const char* key, const char* fmt, ...) {
51 va_list vl;
52 va_start(vl, fmt);
53
54 size_t needed = 1 + (size_t)vsnprintf(NULL, 0, fmt, vl);
55
56 while (kvs->buf_used+needed > kvs->buf_size) {
57 kvs->buf_size *= 2;
58 kvs->buf = realloc(kvs->buf, kvs->buf_size * sizeof(const char*));
59 }
60
61 if (kvs->n == kvs->vals_capacity) {
62 kvs->vals_capacity *= 2;
63 kvs->vals = realloc(kvs->vals, kvs->vals_capacity * sizeof(size_t));
64 kvs->keys = realloc(kvs->keys, kvs->vals_capacity * sizeof(char*));
65 }
66
67 kvs->keys[kvs->n] = key;
68 kvs->vals[kvs->n] = kvs->buf_used;
69 kvs->buf_used += needed;
70
71 va_start(vl, fmt); // Must re-init.
72 vsnprintf(&kvs->buf[kvs->vals[kvs->n]], needed, fmt, vl);
73
74 kvs->n++;
75 }
76
77 void kvs_free(struct kvs* kvs) {
78 free(kvs->vals);
79 free(kvs->keys);
80 free(kvs->buf);
81 }
82
83 // Assumes all of the values are valid JSON objects.
84 void kvs_json(const struct kvs* kvs, struct str_builder *sb) {
85 str_builder_char(sb, '{');
86 for (size_t i = 0; i < kvs->n; i++) {
87 if (i != 0) {
88 str_builder_str(sb, ",");
89 }
90 str_builder_json_str(sb, kvs->keys[i]);
91 str_builder_str(sb, ":");
92 str_builder_str(sb, &kvs->buf[kvs->vals[i]]);
93 }
94 str_builder_char(sb, '}');
95 }
96
97 void kvs_log(const struct kvs* kvs, const char* prefix, FILE* f) {
98 for (size_t i = 0; i < kvs->n; i++) {
99 fprintf(f, "%s%s: %s\n",
100 prefix,
101 kvs->keys[i],
102 &kvs->buf[kvs->vals[i]]);
103 }
104 }
105
106 struct event {
107 void* data;
108 event_report_fn f;
109 const char* name;
110 const char *provenance;
111 // Key-value information that is also to be printed.
112 struct kvs *kvs;
113 };
114
115 struct event_list {
116 struct event *events;
117 int num_events;
118 int capacity;
119 };
120
121 static void event_list_init(struct event_list *l) {
122 l->capacity = 100;
123 l->num_events = 0;
124 l->events = calloc(l->capacity, sizeof(struct event));
125 }
126
127 static void event_list_free(struct event_list *l) {
128 free(l->events);
129 }
130
131 static void add_event_to_list(struct event_list *l,
132 const char* name,
133 const char* provenance,
134 struct kvs *kvs,
135 void* data,
136 event_report_fn f) {
137 if (l->num_events == l->capacity) {
138 l->capacity *= 2;
139 l->events = realloc(l->events, l->capacity * sizeof(struct event));
140 }
141 l->events[l->num_events].name = name;
142 l->events[l->num_events].provenance =
143 provenance ? provenance : "unknown";
144 l->events[l->num_events].kvs = kvs;
145 l->events[l->num_events].data = data;
146 l->events[l->num_events].f = f;
147 l->num_events++;
148 }
149
150 static int report_events_in_list(struct event_list *l,
151 struct str_builder* sb) {
152 int ret = 0;
153 for (int i = 0; i < l->num_events; i++) {
154 if (i != 0) {
155 str_builder_str(sb, ",");
156 }
157 str_builder_str(sb, "{\"name\":");
158 str_builder_json_str(sb, l->events[i].name);
159 str_builder_str(sb, ",\"provenance\":");
160 str_builder_json_str(sb, l->events[i].provenance);
161 if (l->events[i].f(sb, l->events[i].data) != 0) {
162 ret = 1;
163 break;
164 }
165
166 str_builder_str(sb, ",\"details\":");
167 if (l->events[i].kvs) {
168 kvs_json(l->events[i].kvs, sb);
169 kvs_free(l->events[i].kvs);
170 } else {
171 str_builder_str(sb, "{}");
172 }
173
174 str_builder(sb, "}");
175 }
176 event_list_free(l);
177 event_list_init(l);
178 return ret;
179 }
180
181 // End of event_list.h