@cryptotaxi247 / netdata-1 / commits / eec55449d

Add explicit callback types for readability. (#16820)

vkalintiris committed Jan 24, 2024 at 12:14 UTC eec55449d1f64eca6bfe9a075d2a619617ab7857

2 files changed +39 -33

libnetdata/dictionary/dictionary.c

+26 -26

@@ -115,17 +115,17 @@ struct dictionary_hooks {

115 REFCOUNT links;

116 usec_t last_master_deletion_us;

117

118 - void (*ins_callback)(const DICTIONARY_ITEM *item, void *value, void *data);

119 - void *ins_callback_data;

118 + dict_cb_insert_t insert_callback;

119 + void *insert_callback_data;

120

121 - bool (*conflict_callback)(const DICTIONARY_ITEM *item, void *old_value, void *new_value, void *data);

121 + dict_cb_conflict_t conflict_callback;

122 void *conflict_callback_data;

123

124 - void (*react_callback)(const DICTIONARY_ITEM *item, void *value, void *data);

124 + dict_cb_react_t react_callback;

125 void *react_callback_data;

126

127 - void (*del_callback)(const DICTIONARY_ITEM *item, void *value, void *data);

128 - void *del_callback_data;

127 + dict_cb_delete_t delete_callback;

128 + void *delelte_callback_data;

129 };

130

131 struct dictionary_stats dictionary_stats_category_other = {

@@ -305,16 +305,16 @@ static inline size_t dictionary_hooks_free(DICTIONARY *dict) {

305 return 0;

306 }

307

308 -void dictionary_register_insert_callback(DICTIONARY *dict, void (*ins_callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data) {

308 +void dictionary_register_insert_callback(DICTIONARY *dict, dict_cb_insert_t insert_callback, void *data) {

309 if(unlikely(is_view_dictionary(dict)))

310 fatal("DICTIONARY: called %s() on a view.", __FUNCTION__ );

311

312 dictionary_hooks_allocate(dict);

313 - dict->hooks->ins_callback = ins_callback;

314 - dict->hooks->ins_callback_data = data;

313 + dict->hooks->insert_callback = insert_callback;

314 + dict->hooks->insert_callback_data = data;

315 }

316

317 -void dictionary_register_conflict_callback(DICTIONARY *dict, bool (*conflict_callback)(const DICTIONARY_ITEM *item, void *old_value, void *new_value, void *data), void *data) {

317 +void dictionary_register_conflict_callback(DICTIONARY *dict, dict_cb_conflict_t conflict_callback, void *data) {

318 if(unlikely(is_view_dictionary(dict)))

319 fatal("DICTIONARY: called %s() on a view.", __FUNCTION__ );

320

@@ -326,7 +326,7 @@ void dictionary_register_conflict_callback(DICTIONARY *dict, bool (*conflict_cal

326 dict->hooks->conflict_callback_data = data;

327 }

328

329 -void dictionary_register_react_callback(DICTIONARY *dict, void (*react_callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data) {

329 +void dictionary_register_react_callback(DICTIONARY *dict, dict_cb_react_t react_callback, void *data) {

330 if(unlikely(is_view_dictionary(dict)))

331 fatal("DICTIONARY: called %s() on a view.", __FUNCTION__ );

332

@@ -335,13 +335,13 @@ void dictionary_register_react_callback(DICTIONARY *dict, void (*react_callback)

335 dict->hooks->react_callback_data = data;

336 }

337

338 -void dictionary_register_delete_callback(DICTIONARY *dict, void (*del_callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data) {

338 +void dictionary_register_delete_callback(DICTIONARY *dict, dict_cb_delete_t delete_callback, void *data) {

339 if(unlikely(is_view_dictionary(dict)))

340 fatal("DICTIONARY: called %s() on a view.", __FUNCTION__ );

341

342 dictionary_hooks_allocate(dict);

343 - dict->hooks->del_callback = del_callback;

344 - dict->hooks->del_callback_data = data;

343 + dict->hooks->delete_callback = delete_callback;

344 + dict->hooks->delelte_callback_data = data;

345 }

346

347 // ----------------------------------------------------------------------------

@@ -591,7 +591,7 @@ static inline REFCOUNT DICTIONARY_ITEM_REFCOUNT_GET_SOLE(DICTIONARY_ITEM *item)

591 // callbacks execution

592

593 static void dictionary_execute_insert_callback(DICTIONARY *dict, DICTIONARY_ITEM *item, void *constructor_data) {

594 - if(likely(!dict->hooks || !dict->hooks->ins_callback))

594 + if(likely(!dict->hooks || !dict->hooks->insert_callback))

595 return;

596

597 if(unlikely(is_view_dictionary(dict)))

@@ -604,7 +604,7 @@ static void dictionary_execute_insert_callback(DICTIONARY *dict, DICTIONARY_ITEM

604 dict->creation_line,

605 dict->creation_file);

606

607 - dict->hooks->ins_callback(item, item->shared->value, constructor_data?constructor_data:dict->hooks->ins_callback_data);

607 + dict->hooks->insert_callback(item, item->shared->value, constructor_data?constructor_data:dict->hooks->insert_callback_data);

608 DICTIONARY_STATS_CALLBACK_INSERTS_PLUS1(dict);

609 }

610

@@ -652,7 +652,7 @@ static void dictionary_execute_react_callback(DICTIONARY *dict, DICTIONARY_ITEM

652 }

653

654 static void dictionary_execute_delete_callback(DICTIONARY *dict, DICTIONARY_ITEM *item) {

655 - if(likely(!dict->hooks || !dict->hooks->del_callback))

655 + if(likely(!dict->hooks || !dict->hooks->delete_callback))

656 return;

657

658 // We may execute delete callback on items deleted from a view,

@@ -666,7 +666,7 @@ static void dictionary_execute_delete_callback(DICTIONARY *dict, DICTIONARY_ITEM

666 dict->creation_line,

667 dict->creation_file);

668

669 - dict->hooks->del_callback(item, item->shared->value, dict->hooks->del_callback_data);

669 + dict->hooks->delete_callback(item, item->shared->value, dict->hooks->delelte_callback_data);

670

671 DICTIONARY_STATS_CALLBACK_DELETES_PLUS1(dict);

672 }

@@ -2450,8 +2450,8 @@ void dictionary_foreach_done(DICTFE *dfe) {

2450 // The dictionary is locked for reading while this happens

2451 // do not use other dictionary calls while walking the dictionary - deadlock!

2452

2453 -int dictionary_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const DICTIONARY_ITEM *item, void *entry, void *data), void *data) {

2454 - if(unlikely(!dict || !callback)) return 0;

2453 +int dictionary_walkthrough_rw(DICTIONARY *dict, char rw, dict_walkthrough_callback_t walkthrough_callback, void *data) {

2454 + if(unlikely(!dict || !walkthrough_callback)) return 0;

2455

2456 if(unlikely(is_dictionary_destroyed(dict))) {

2457 internal_error(true, "DICTIONARY: attempted to dictionary_walkthrough_rw() on a destroyed dictionary");

@@ -2477,7 +2477,7 @@ int dictionary_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const D

2477 if(unlikely(rw == DICTIONARY_LOCK_REENTRANT))

2478 ll_recursive_unlock(dict, rw);

2479

2480 - int r = callback(item, item->shared->value, data);

2480 + int r = walkthrough_callback(item, item->shared->value, data);

2481

2482 if(unlikely(rw == DICTIONARY_LOCK_REENTRANT))

2483 ll_recursive_lock(dict, rw);

@@ -2513,8 +2513,8 @@ static int dictionary_sort_compar(const void *item1, const void *item2) {

2513 return strcmp(item_get_name((*(DICTIONARY_ITEM **)item1)), item_get_name((*(DICTIONARY_ITEM **)item2)));

2514 }

2515

2516 -int dictionary_sorted_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const DICTIONARY_ITEM *item, void *entry, void *data), void *data, dictionary_sorted_compar compar) {

2517 - if(unlikely(!dict || !callback)) return 0;

2516 +int dictionary_sorted_walkthrough_rw(DICTIONARY *dict, char rw, dict_walkthrough_callback_t walkthrough_callback, void *data, dict_item_comparator_t item_comparator) {

2517 + if(unlikely(!dict || !walkthrough_callback)) return 0;

2518

2519 if(unlikely(is_dictionary_destroyed(dict))) {

2520 internal_error(true, "DICTIONARY: attempted to dictionary_sorted_walkthrough_rw() on a destroyed dictionary");

@@ -2538,8 +2538,8 @@ int dictionary_sorted_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(

2538 if(unlikely(i != entries))

2539 entries = i;

2540

2541 - if(compar)

2542 - qsort(array, entries, sizeof(DICTIONARY_ITEM *), (qsort_compar)compar);

2541 + if(item_comparator)

2542 + qsort(array, entries, sizeof(DICTIONARY_ITEM *), (qsort_compar) item_comparator);

2543 else

2544 qsort(array, entries, sizeof(DICTIONARY_ITEM *), dictionary_sort_compar);

2545

@@ -2549,7 +2549,7 @@ int dictionary_sorted_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(

2549 item = array[i];

2550

2551 if(callit)

2552 - r = callback(item, item->shared->value, data);

2552 + r = walkthrough_callback(item, item->shared->value, data);

2553

2554 dict_item_release_and_check_if_it_is_deleted_and_can_be_removed_under_this_lock_mode(dict, item, rw);

2555 // item_release(dict, item);

libnetdata/dictionary/dictionary.h

+13 -7

@@ -130,22 +130,26 @@ DICTIONARY *dictionary_create_view(DICTIONARY *master);

130

131 // an insert callback to be called just after an item is added to the dictionary

132 // this callback is called while the dictionary is write locked!

133 -void dictionary_register_insert_callback(DICTIONARY *dict, void (*ins_callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data);

133 +typedef void (*dict_cb_insert_t)(const DICTIONARY_ITEM *item, void *value, void *data);

134 +void dictionary_register_insert_callback(DICTIONARY *dict, dict_cb_insert_t insert_callback, void *data);

135

136 // a delete callback to be called just before an item is deleted forever

137 // this callback is called while the dictionary is write locked!

137 -void dictionary_register_delete_callback(DICTIONARY *dict, void (*del_callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data);

138 +typedef void (*dict_cb_delete_t)(const DICTIONARY_ITEM *item, void *value, void *data);

139 +void dictionary_register_delete_callback(DICTIONARY *dict, dict_cb_delete_t delete_callback, void *data);

140

141 // a merge callback to be called when DICT_OPTION_DONT_OVERWRITE_VALUE

142 // and an item is already found in the dictionary - the dictionary does nothing else in this case

143 // the old_value will remain in the dictionary - the new_value is ignored

144 // The callback should return true if the value has been updated (it increases the dictionary version).

143 -void dictionary_register_conflict_callback(DICTIONARY *dict, bool (*conflict_callback)(const DICTIONARY_ITEM *item, void *old_value, void *new_value, void *data), void *data);

145 +typedef bool (*dict_cb_conflict_t)(const DICTIONARY_ITEM *item, void *old_value, void *new_value, void *data);

146 +void dictionary_register_conflict_callback(DICTIONARY *dict, dict_cb_conflict_t conflict_callback, void *data);

147

148 // a reaction callback to be called after every item insertion or conflict

149 // after the constructors have finished and the items are fully available for use

150 // and the dictionary is not write locked anymore

148 -void dictionary_register_react_callback(DICTIONARY *dict, void (*react_callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data);

151 +typedef void (*dict_cb_react_t)(const DICTIONARY_ITEM *item, void *value, void *data);

152 +void dictionary_register_react_callback(DICTIONARY *dict, dict_cb_react_t react_callback, void *data);

153

154 // Destroy a dictionary

155 // Returns the number of bytes freed

@@ -236,15 +240,17 @@ size_t dictionary_acquired_item_references(DICT_ITEM_CONST DICTIONARY_ITEM *item

240 // You cannot alter the dictionary from inside a dictionary_walkthrough_read() - deadlock!

241 // You can only delete the current item from inside a dictionary_walkthrough_write() - you can add as many as you want.

242 //

243 +typedef int (*dict_walkthrough_callback_t)(const DICTIONARY_ITEM *item, void *value, void *data);

244 +

245 #define dictionary_walkthrough_read(dict, callback, data) dictionary_walkthrough_rw(dict, 'r', callback, data)

246 #define dictionary_walkthrough_write(dict, callback, data) dictionary_walkthrough_rw(dict, 'w', callback, data)

241 -int dictionary_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data);

247 +int dictionary_walkthrough_rw(DICTIONARY *dict, char rw, dict_walkthrough_callback_t walkthrough_callback, void *data);

248

243 -typedef int (*dictionary_sorted_compar)(const DICTIONARY_ITEM **item1, const DICTIONARY_ITEM **item2);

249 +typedef int (*dict_item_comparator_t)(const DICTIONARY_ITEM **item1, const DICTIONARY_ITEM **item2);

250

251 #define dictionary_sorted_walkthrough_read(dict, callback, data) dictionary_sorted_walkthrough_rw(dict, 'r', callback, data, NULL)

252 #define dictionary_sorted_walkthrough_write(dict, callback, data) dictionary_sorted_walkthrough_rw(dict, 'w', callback, data, NULL)

247 -int dictionary_sorted_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const DICTIONARY_ITEM *item, void *entry, void *data), void *data, dictionary_sorted_compar compar);

253 +int dictionary_sorted_walkthrough_rw(DICTIONARY *dict, char rw, dict_walkthrough_callback_t walkthrough_callback, void *data, dict_item_comparator_t item_comparator_callback);

254

255 // ----------------------------------------------------------------------------

256 // Traverse with foreach