if (exporter->auto_export_mails && !exporter->mails_have_guids) {
/* GUIDs not supported, mail is requested by UIDs */
- seq_range_array_add(&exporter->requested_uids, 0, change->uid);
+ seq_range_array_add(&exporter->requested_uids, change->uid);
return;
}
if (*change->guid == '\0') {
if (exporter->auto_export_mails)
instances->requested = TRUE;
}
- seq_range_array_add(&instances->seqs, 0, seq);
+ seq_range_array_add(&instances->seqs, seq);
}
static int
const struct dsync_mail_change *change = value;
if (change->type == DSYNC_MAIL_CHANGE_TYPE_FLAG_CHANGE)
- seq_range_array_add(uids, 0, change->uid);
+ seq_range_array_add(uids, change->uid);
}
hash_table_iterate_deinit(&iter);
}
seq = uids[0].seq1;
if (!instances->searched) {
instances->searched = TRUE;
- seq_range_array_add(&sarg->value.seqset, 0, seq);
+ seq_range_array_add(&sarg->value.seqset, seq);
} else if (seq_range_exists(&exporter->expunged_seqs, seq)) {
/* we're on a second round, refetching expunged
messages */
}
uids = array_idx(&instances->seqs, 0);
seq = uids[0].seq1;
- seq_range_array_add(&sarg->value.seqset, 0, seq);
+ seq_range_array_add(&sarg->value.seqset, seq);
}
}
hash_table_iterate_deinit(&iter);
if (*request->guid == '\0') {
i_assert(request->uid > 0);
- seq_range_array_add(&exporter->requested_uids, 0, request->uid);
+ seq_range_array_add(&exporter->requested_uids, request->uid);
return;
}
}
/* the message was expunged. if the GUID has another instance,
try sending it later. */
- seq_range_array_add(&exporter->expunged_seqs, 0, mail->seq);
+ seq_range_array_add(&exporter->expunged_seqs, mail->seq);
}
/* if some instances of messages were expunged, retry fetching them
with other instances */
/* this message exists locally, but remote didn't send
expunge-change for it. if the message's
uid <= last-common-uid, it should be deleted */
- seq_range_array_add(&importer->maybe_expunge_uids, 0,
+ seq_range_array_add(&importer->maybe_expunge_uids,
importer->cur_mail->uid);
}
/* we don't know yet if we should expunge this
message or not. queue it until we do. */
i_assert(change->uid > importer->last_common_uid);
- seq_range_array_add(&importer->maybe_expunge_uids, 0,
- change->uid);
+ seq_range_array_add(&importer->maybe_expunge_uids, change->uid);
}
}
/* check early so there's less work for transaction
commit if something has to be cancelled */
if (mail_get_modseq(mail) > ctx.max_modseq) {
- seq_range_array_add(&modified_set, 0,
- mail->seq);
+ seq_range_array_add(&modified_set, mail->seq);
continue;
}
}
}
if ((ctx->return_options & SEARCH_RETURN_SAVE) != 0) {
seq_range_array_add(&ctx->cmd->client->search_saved_uidset,
- 0, mail->uid);
+ mail->uid);
}
if ((ctx->return_options & SEARCH_RETURN_RELEVANCY) != 0) {
const char *str;
rec->uid);
break;
}
- seq_range_array_add(&uids, 0, rec->uid);
+ seq_range_array_add(&uids, rec->uid);
}
/* do this in reverse so the memmove()s are smaller */
if ((rec->flags & u->add_flags) != u->add_flags ||
(rec->flags & u->remove_flags) != 0) {
/* keep this change */
- seq_range_array_add(&keeps, 0, seq);
+ seq_range_array_add(&keeps, seq);
}
}
i = mail_transaction_drop_range(t, updates[i], i, &keeps);
ret1 = mail_index_cancel_flag_updates(t, seq);
ret2 = mail_index_cancel_keyword_updates(t, seq);
if (ret1 || ret2)
- seq_range_array_add(t->conflict_seqs, 0, seq);
+ seq_range_array_add(t->conflict_seqs, seq);
}
}
mail_index_transaction_set_log_updates(t);
idx1 = range[i].seq1 - first_new_seq;
idx2 = range[i].seq2 - first_new_seq;
for (idx = idx1; idx <= idx2; idx++)
- seq_range_array_add(array, 0, old_to_newseq_map[idx]);
+ seq_range_array_add(array, old_to_newseq_map[idx]);
}
array_free(&old_seqs);
}
seq_range_array_remove(&u->add_seq, seq);
/* Don't bother updating remove_seq for new messages,
since their initial state is "no keyword" anyway */
- if (seq < t->first_new_seq)
- seq_range_array_add(&u->remove_seq, 16, seq);
+ if (seq < t->first_new_seq) {
+ seq_range_array_add_with_init(&u->remove_seq,
+ 16, seq);
+ }
}
}
if (add_keywords != NULL) {
for (i = 0; i < add_keywords->count; i++) {
u = array_idx_modifiable(&t->keyword_updates,
add_keywords->idx[i]);
- seq_range_array_add(&u->add_seq, 16, seq);
+ seq_range_array_add_with_init(&u->add_seq, 16, seq);
seq_range_array_remove(&u->remove_seq, seq);
}
}
src_count = src_size / sizeof(*src);
for (i = 0; i < src_count; i++)
- seq_range_array_add(dest, 0, src[i].uid);
+ seq_range_array_add(dest, src[i].uid);
}
static int
be avoided by always keeping a private copy of the map in the view,
but that's a waste of memory for as rare of a problem as this. */
if (changed)
- seq_range_array_add(&ctx->lost_flags, 0, new_rec->uid);
+ seq_range_array_add(&ctx->lost_flags, new_rec->uid);
return 0;
}
i++; j++;
} else if (old_rec->uid < new_rec->uid) {
/* message expunged */
- seq_range_array_add(&ctx->expunges, 0, old_rec->uid);
+ seq_range_array_add(&ctx->expunges, old_rec->uid);
i++;
} else {
/* new message appeared out of nowhere */
/* if there are old messages left, they're all expunged */
for (; i < old_count; i++) {
old_rec = MAIL_INDEX_MAP_IDX(old_map, i);
- seq_range_array_add(&ctx->expunges, 0, old_rec->uid);
+ seq_range_array_add(&ctx->expunges, old_rec->uid);
}
/* if there are new messages left, they're all new messages */
thdr.type = MAIL_TRANSACTION_APPEND | MAIL_TRANSACTION_EXTERNAL;
&data, &expunged);
if (data != NULL && !expunged) {
rec = data;
- seq_range_array_add(file_ids_r, 0, rec->file_id);
+ seq_range_array_add(file_ids_r, rec->file_id);
}
}
return 0;
&file_id) < 0)
continue;
- seq_range_array_add(file_ids_r, 0, file_id);
+ seq_range_array_add(file_ids_r, file_id);
}
if (errno != 0) {
mail_storage_set_critical(storage,
if (seq_range_exists(&checked_file_ids, rec->file_id))
continue;
- seq_range_array_add(&checked_file_ids, 0, rec->file_id);
+ seq_range_array_add(&checked_file_ids, rec->file_id);
if (++backwards_lookup_count > MAX_BACKWARDS_LOOKUPS) {
/* we've wasted enough time here */
&ext_refs);
if (ret <= 0)
break;
- seq_range_array_add(&expunged_map_uids, 0,
+ seq_range_array_add(&expunged_map_uids,
msgs[i].map_uid);
} else {
/* non-expunged message. write it to output file. */
str_truncate(path, dir_len);
str_append(path, d->d_name);
- seq_range_array_add(&ctx->primary_file_ids, 0, file_id);
+ seq_range_array_add(&ctx->primary_file_ids, file_id);
}
if (array_count(&ctx->primary_file_ids) > 0) {
const struct seq_range *range =
hash_table_insert(ctx->altmoves,
POINTER_CAST(cur_map_uid),
POINTER_CAST(MDBOX_MSG_ACTION_MOVE_TO_ALT));
- seq_range_array_add(&ctx->purge_file_ids, 0,
+ seq_range_array_add(&ctx->purge_file_ids,
cur_rec.file_id);
}
}
hash_table_insert(ctx->altmoves, POINTER_CAST(cur_map_uid),
POINTER_CAST(MDBOX_MSG_ACTION_MOVE_FROM_ALT));
- seq_range_array_add(&ctx->purge_file_ids, 0, cur_rec.file_id);
+ seq_range_array_add(&ctx->purge_file_ids, cur_rec.file_id);
}
ctx->have_altmoves = hash_table_count(ctx->altmoves) > 0;
return ret;
if (rebuild_rename_file(ctx, dir, &fname, &file_id) < 0)
return -1;
}
- seq_range_array_add(&ctx->seen_file_ids, 0, file_id);
+ seq_range_array_add(&ctx->seen_file_ids, file_id);
file = mdbox_file_init(ctx->storage, file_id);
if ((ret = dbox_file_open(file, &deleted)) > 0 && !deleted)
{
uint32_t map_uid;
- if (seq_range_array_add(&ctx->expunged_seqs, 0, seq)) {
+ if (seq_range_array_try_add(&ctx->expunged_seqs, seq)) {
/* already marked as expunged in this sync */
return 0;
}
return;
if (str_to_uint32(args[1], &dest_uid) == 0) {
- seq_range_array_add(&ctx->dest_saved_uids, 0, dest_uid);
+ seq_range_array_add(&ctx->dest_saved_uids, dest_uid);
*uid_r = dest_uid;
}
}
return;
if (str_to_uint32(args[2], &dest_uid) == 0) {
- seq_range_array_add(&ctx->dest_saved_uids, 0, dest_uid);
+ seq_range_array_add(&ctx->dest_saved_uids, dest_uid);
*uid_r = dest_uid;
}
}
if (range[count-1].seq2 == (uint32_t)-1) {
/* "*" used, make sure the last message is in the range
(e.g. with count+1:* we still want to include it) */
- seq_range_array_add(seqset, 0, messages_count);
+ seq_range_array_add(seqset, messages_count);
}
/* remove all nonexistent messages */
seq_range_array_remove_range(seqset, messages_count + 1,
if (search_build_subthread(child_iter, uids) < 0)
ret = -1;
}
- seq_range_array_add(uids, 0, node->uid);
+ seq_range_array_add(uids, node->uid);
}
if (mail_thread_iterate_deinit(&iter) < 0)
ret = -1;
iter = mail_thread_iterate_init(ctx->thread_ctx,
arg->value.thread_type, FALSE);
while ((node = mail_thread_iterate_next(iter, &child_iter)) != NULL) {
- seq_range_array_add(&thread_uids, 0, node->uid);
+ seq_range_array_add(&thread_uids, node->uid);
if (child_iter != NULL) {
if (search_build_subthread(child_iter,
&thread_uids) < 0)
array_foreach(changes, range) {
for (seq = range->seq1; seq <= range->seq2; seq++) {
mail_index_lookup_uid(ctx->ctx.box->view, seq, &uid);
- seq_range_array_add(&ctx->all_flag_update_uids, 0, uid);
+ seq_range_array_add(&ctx->all_flag_update_uids, uid);
}
}
}
}
ibox->recent_flags_prev_uid = uid;
- seq_range_array_add(&ibox->recent_flags, 64, uid);
+ seq_range_array_add_with_init(&ibox->recent_flags, 64, uid);
ibox->recent_flags_count++;
}
/* make sure the last message is in the range */
mailbox_get_seq_range(box, 1, (uint32_t)-1,
&seq1, &seq2);
- seq_range_array_add(&arg->value.seqset, 0, seq2);
+ seq_range_array_add(&arg->value.seqset, seq2);
}
}
}
}
for (seq = range[i].seq1; seq <= range[i].seq2; seq++) {
mail_index_lookup_uid(box->view, seq, &uid);
- seq_range_array_add(uids, 0, uid);
+ seq_range_array_add(uids, uid);
}
}
}
end = src + src_size / sizeof(*src);
for (; src != end; src++) {
if (src->uid >= min_uid)
- seq_range_array_add(expunged_uids, 0, src->uid);
+ seq_range_array_add(expunged_uids, src->uid);
}
}
if (seq_range_exists(&result->uids, uid))
return;
- seq_range_array_add(&result->uids, 0, uid);
+ seq_range_array_add(&result->uids, uid);
if (array_is_created(&result->added_uids)) {
- seq_range_array_add(&result->added_uids, 0, uid);
+ seq_range_array_add(&result->added_uids, uid);
seq_range_array_remove(&result->removed_uids, uid);
}
}
{
if (seq_range_array_remove(&result->uids, uid)) {
if (array_is_created(&result->removed_uids)) {
- seq_range_array_add(&result->removed_uids, 0, uid);
+ seq_range_array_add(&result->removed_uids, uid);
seq_range_array_remove(&result->added_uids, uid);
}
}
void mailbox_search_result_never(struct mail_search_result *result,
uint32_t uid)
{
- seq_range_array_add(&result->never_uids, 0, uid);
+ seq_range_array_add(&result->never_uids, uid);
}
void mailbox_search_results_never(struct mail_search_context *ctx,
return FALSE;
}
-bool seq_range_array_add(ARRAY_TYPE(seq_range) *array,
- unsigned int init_count, uint32_t seq)
+bool seq_range_array_try_add(ARRAY_TYPE(seq_range) *array, uint32_t seq)
{
struct seq_range *data, value;
unsigned int idx, count;
value.seq1 = value.seq2 = seq;
- if (!array_is_created(array))
- i_array_init(array, init_count);
-
data = array_get_modifiable(array, &count);
if (count == 0) {
array_append(array, &value, 1);
return FALSE;
}
+void seq_range_array_add(ARRAY_TYPE(seq_range) *array, uint32_t seq)
+{
+ (void)seq_range_array_try_add(array, seq);
+}
+
+void seq_range_array_add_with_init(ARRAY_TYPE(seq_range) *array,
+ unsigned int init_count, uint32_t seq)
+{
+ if (!array_is_created(array))
+ i_array_init(array, init_count);
+ (void)seq_range_array_try_add(array, seq);
+}
+
void seq_range_array_add_range(ARRAY_TYPE(seq_range) *array,
uint32_t seq1, uint32_t seq2)
{
};
/* Add sequrence to range. If the array isn't created yet, create it with
- initial size of init_count. Returns TRUE if seq was already in the array. */
-bool seq_range_array_add(ARRAY_TYPE(seq_range) *array, unsigned int init_count,
- uint32_t seq);
+ initial size of init_count. */
+void seq_range_array_add(ARRAY_TYPE(seq_range) *array, uint32_t seq);
+/* Like seq_range_array_add(), but reutrn TRUE if seq was already in the
+ array. */
+bool seq_range_array_try_add(ARRAY_TYPE(seq_range) *array, uint32_t seq);
+/* Like seq_range_array_add(), but if the array isn't already initialized do
+ it with i_array_init(). */
+void seq_range_array_add_with_init(ARRAY_TYPE(seq_range) *array,
+ unsigned int init_count, uint32_t seq);
void seq_range_array_add_range(ARRAY_TYPE(seq_range) *array,
uint32_t seq1, uint32_t seq2);
void seq_range_array_merge(ARRAY_TYPE(seq_range) *dest,
test_begin("seq_range_array_add() merging");
t_array_init(&range, 8);
- seq_range_array_add(&range, 0, 4);
- seq_range_array_add(&range, 0, 1);
- seq_range_array_add(&range, 0, 2);
+ seq_range_array_add(&range, 4);
+ seq_range_array_add(&range, 1);
+ seq_range_array_add(&range, 2);
test_assert(array_count(&range) == 2);
test_end();
}
test = rand() % 4;
switch (test) {
case 0:
- seq_range_array_add(&range, 0, seq1);
+ seq_range_array_add(&range, seq1);
shadowbuf[seq1] = 1;
break;
case 1:
success = TRUE;
start = i;
for (; input[i] != -1U; i++) {
- seq_range_array_add(&range, 32, input[i]);
+ seq_range_array_add_with_init(&range, 32, input[i]);
for (j = start; j < i; j++) {
if (!seq_range_exists(&range, input[j]))
success = FALSE;
array_clear(array);
for (i = 0; i < 8; i++) {
if ((byte & (1 << i)) != 0)
- seq_range_array_add(array, 0, i + 1);
+ seq_range_array_add(array, i + 1);
}
}
score->uid = uid;
score->score = hits->score(i);
}
- seq_range_array_add(uids_r, 0, uid);
+ seq_range_array_add(uids_r, uid);
}
_CLDELETE(hits);
return ret;
p_array_init(&br->definite_uids, result->pool, 32);
p_array_init(&br->scores, result->pool, 32);
}
- seq_range_array_add(&br->definite_uids, 0, uid);
+ seq_range_array_add(&br->definite_uids, uid);
score = array_append_space(&br->scores);
score->uid = uid;
score->score = hits->score(i);
}
result = solr_result_get(ctx, box_id);
- seq_range_array_add(&result->uids, 0, ctx->uid);
+ seq_range_array_add(&result->uids, ctx->uid);
if (ctx->score != 0) {
score = array_append_space(&result->scores);
score->uid = ctx->uid;
for (i = 0; i < count; i++) {
for (uid = src_range[i].seq1; uid <= src_range[i].seq2; uid++) {
if ((uid & 1) == mask)
- seq_range_array_add(dest, 0, uid/2);
+ seq_range_array_add(dest, uid/2);
}
}
}
ret = -1;
break;
}
- seq_range_array_add(&dest_uids, 0, parent_uid);
+ seq_range_array_add(&dest_uids, parent_uid);
for (; parent_idx < parent_count; parent_idx++) {
if (parent_range[parent_idx].seq2 <= parent_uid)
continue;
for (i = 0; i < count; i++) {
for (seq = range[i].seq1; seq <= range[i].seq2; seq++) {
if (seq_range_exists(src_maybe, seq))
- seq_range_array_add(dest_maybe, 0, seq);
+ seq_range_array_add(dest_maybe, seq);
}
}
}
mailbox = fts_expunge_log_mailbox_alloc(ctx, mailbox_guid);
ctx->prev_mailbox = mailbox;
}
- if (!seq_range_array_add(&mailbox->uids, 0, uid))
+ if (!seq_range_array_try_add(&mailbox->uids, uid))
mailbox->uids_count++;
}
t_array_init(&vuids_arr, count);
t_array_init(&backend_uids, 64);
for (i = 0; i < count; i++)
- seq_range_array_add(&backend_uids, 0, scores[i].uid);
+ seq_range_array_add(&backend_uids, scores[i].uid);
vbox->vfuncs.get_virtual_uid_map(&vbox->box, br->box,
&backend_uids, &vuids_arr);
i_assert(result != 0);
if (result > 0) {
/* full match, no need to check this any further */
- seq_range_array_add(&vctx->result, 0, ctx->seq);
+ seq_range_array_add(&vctx->result, ctx->seq);
} else {
/* possible match, save and check later */
mail_index_lookup_ext(mbox->box.view, ctx->seq,
/* the messages won't be returned sorted, so we'll have to
do it ourself */
while (index_storage_search_next_nonblock(ctx, mail_r, tryagain_r))
- seq_range_array_add(&vctx->result, 0, (*mail_r)->seq);
+ seq_range_array_add(&vctx->result, (*mail_r)->seq);
if (*tryagain_r)
return FALSE;
while (seq_range_array_iter_nth(&iter, n++, &uid)) {
while (i < count && uids[i].real_uid < uid) i++;
if (i < count && uids[i].real_uid == uid) {
- seq_range_array_add(virtual_uids_r, 0,
+ seq_range_array_add(virtual_uids_r,
uids[i].virtual_uid);
i++;
}
if (mail_index_lookup_seq(bbox->box->view,
vrec->real_uid, &seq)) {
- seq_range_array_add(&result->uids, 0,
+ seq_range_array_add(&result->uids,
vrec->real_uid);
} else {
- seq_range_array_add(&result->removed_uids, 0,
+ seq_range_array_add(&result->removed_uids,
vrec->real_uid);
}
}
modseq = mail_index_modseq_lookup(view, seq);
if (modseq > bbox->sync_highest_modseq) {
mail_index_lookup_uid(view, seq, &uid);
- seq_range_array_add(&flag_update_uids, 0, uid);
+ seq_range_array_add(&flag_update_uids, uid);
}
}
}
continue;
}
if (uidmap[i].real_uid == add_uid) {
- seq_range_array_add(&drop_uids, 0, add_uid);
+ seq_range_array_add(&drop_uids, add_uid);
i++;
}
if (!seq_range_array_iter_nth(&iter, n++, &add_uid))
continue;
}
if (uidmap[i].real_uid != remove_uid)
- seq_range_array_add(&drop_uids, 0, remove_uid);
+ seq_range_array_add(&drop_uids, remove_uid);
else
i++;
if (!seq_range_array_iter_nth(&iter, n++, &remove_uid)) {
}
if (!iter_done) {
do {
- seq_range_array_add(&drop_uids, 0, remove_uid);
+ seq_range_array_add(&drop_uids, remove_uid);
} while (seq_range_array_iter_nth(&iter, n++, &remove_uid));
}
seq_range_array_remove_seq_range(removed_uids, &drop_uids);
for (i = idx1; i < count; i++) {
if (uidmap[i].real_uid > uid2)
break;
- seq_range_array_add(&ctx->sync_expunges, 0, uidmap[i].real_uid);
+ seq_range_array_add(&ctx->sync_expunges, uidmap[i].real_uid);
}
}
if (!array_is_created(&bbox->sync_outside_expunges))
i_array_init(&bbox->sync_outside_expunges, 32);
}
- seq_range_array_add(&bbox->sync_outside_expunges, 0,
+ seq_range_array_add(&bbox->sync_outside_expunges,
vrec->real_uid);
}
}
projects / thirdparty / dovecot / core.git / commitdiff
