static void link_head(grpc_mdelem_list *list, grpc_linked_mdelem *storage) {
assert_valid_list(list);
GPR_ASSERT(storage->md);
storage->prev = NULL;
storage->next = list->head;
if (list->head != NULL) {
list->head->prev = storage;
} else {
list->tail = storage;
}
list->head = storage;
assert_valid_list(list);
}
static void link_tail(grpc_mdelem_list *list, grpc_linked_mdelem *storage) {
assert_valid_list(list);
GPR_ASSERT(storage->md);
storage->prev = list->tail;
storage->next = NULL;
storage->reserved = NULL;
if (list->tail != NULL) {
list->tail->next = storage;
} else {
list->head = storage;
}
list->tail = storage;
assert_valid_list(list);
}
void list_decref(ListData* data)
{
assert_valid_list(data);
ca_assert(data->refCount > 0);
data->refCount--;
if (data->refCount == 0)
free_list(data);
}
void grpc_metadata_batch_filter(grpc_metadata_batch *batch,
grpc_mdelem *(*filter)(void *user_data,
grpc_mdelem *elem),
void *user_data) {
grpc_linked_mdelem *l;
grpc_linked_mdelem *next;
GPR_TIMER_BEGIN("grpc_metadata_batch_filter", 0);
assert_valid_list(&batch->list);
for (l = batch->list.head; l; l = next) {
grpc_mdelem *orig = l->md;
grpc_mdelem *filt = filter(user_data, orig);
next = l->next;
if (filt == NULL) {
if (l->prev) {
l->prev->next = l->next;
}
if (l->next) {
l->next->prev = l->prev;
}
if (batch->list.head == l) {
batch->list.head = l->next;
}
if (batch->list.tail == l) {
batch->list.tail = l->prev;
}
assert_valid_list(&batch->list);
GRPC_MDELEM_UNREF(l->md);
} else if (filt != orig) {
GRPC_MDELEM_UNREF(orig);
l->md = filt;
}
}
assert_valid_list(&batch->list);
GPR_TIMER_END("grpc_metadata_batch_filter", 0);
}
ListData* list_duplicate(ListData* source)
{
if (source == NULL)
return NULL;
INCREMENT_STAT(ListHardCopy);
assert_valid_list(source);
ListData* result = allocate_empty_list(source->capacity);
result->count = source->count;
for (int i=0; i < source->count; i++) {
INCREMENT_STAT(Copy_ListDuplicate);
copy(&source->items[i], &result->items[i]);
}
return result;
}
ListData* list_increase_capacity(ListData* original, int new_capacity)
{
if (original == NULL)
return allocate_empty_list(new_capacity);
assert_valid_list(original);
ListData* result = allocate_empty_list(new_capacity);
bool createCopy = original->refCount > 1;
result->count = original->count;
for (int i=0; i < result->count; i++) {
caValue* left = &original->items[i];
caValue* right = &result->items[i];
if (createCopy)
copy(left, right);
else
swap(left, right);
}
list_decref(original);
return result;
}
void grpc_metadata_batch_assert_ok(grpc_metadata_batch *batch) {
assert_valid_list(&batch->list);
}
void list_incref(ListData* data)
{
assert_valid_list(data);
data->refCount++;
}
