dict_connection_transaction_lookup(struct dict_connection *conn,
unsigned int id)
{
- struct dict_connection_transaction *transactions;
- unsigned int i, count;
+ struct dict_connection_transaction *transaction;
if (!array_is_created(&conn->transactions))
return NULL;
- transactions = array_get_modifiable(&conn->transactions, &count);
- for (i = 0; i < count; i++) {
- if (transactions[i].id == id)
- return &transactions[i];
+ array_foreach_modifiable(&conn->transactions, transaction) {
+ if (transaction->id == id)
+ return transaction;
}
return NULL;
}
void dict_connection_destroy(struct dict_connection *conn)
{
- struct dict_connection_transaction *transactions;
- unsigned int i, count;
+ struct dict_connection_transaction *transaction;
DLLIST_REMOVE(&dict_connections, conn);
if (array_is_created(&conn->transactions)) {
- transactions = array_get_modifiable(&conn->transactions, &count);
- for (i = 0; i < count; i++)
- dict_transaction_rollback(&transactions[i].ctx);
+ array_foreach_modifiable(&conn->transactions, transaction)
+ dict_transaction_rollback(&transaction->ctx);
array_free(&conn->transactions);
}
get_mailbox_guids(const ARRAY_TYPE(dsync_brain_mailbox) *mailboxes,
ARRAY_TYPE(mailbox_guid) *guids)
{
- const struct dsync_brain_mailbox *brain_boxes;
- unsigned int i, count;
+ const struct dsync_brain_mailbox *brain_box;
t_array_init(guids, array_count(mailboxes));
- brain_boxes = array_get(mailboxes, &count);
- for (i = 0; i < count; i++)
- array_append(guids, &brain_boxes[i].box.mailbox_guid, 1);
+ array_foreach(mailboxes, brain_box)
+ array_append(guids, &brain_box->box.mailbox_guid, 1);
}
struct dsync_brain_mailbox_sync *
static void
dsync_brain_msg_sync_update_mailbox(struct dsync_brain *brain)
{
- const struct dsync_brain_mailbox *mailboxes;
- unsigned int i, count;
+ const struct dsync_brain_mailbox *mailbox;
/* FIXME: handle different hierarchy separators? */
- mailboxes = array_get(&brain->mailbox_sync->mailboxes, &count);
- for (i = 0; i < count; i++) {
- dsync_worker_update_mailbox(brain->src_worker,
- &mailboxes[i].box);
- dsync_worker_update_mailbox(brain->dest_worker,
- &mailboxes[i].box);
+ array_foreach(&brain->mailbox_sync->mailboxes, mailbox) {
+ dsync_worker_update_mailbox(brain->src_worker, &mailbox->box);
+ dsync_worker_update_mailbox(brain->dest_worker, &mailbox->box);
}
}
void client_search_updates_free(struct client *client)
{
- struct imap_search_update *updates;
- unsigned int i, count;
+ struct imap_search_update *update;
if (!array_is_created(&client->search_updates))
return;
- updates = array_get_modifiable(&client->search_updates, &count);
- for (i = 0; i < count; i++) {
- i_free(updates[i].tag);
- mailbox_search_result_free(&updates[i].result);
+ array_foreach_modifiable(&client->search_updates, update) {
+ i_free(update->tag);
+ mailbox_search_result_free(&update->result);
}
array_clear(&client->search_updates);
}
client requested them. This is especially useful to get UID
returned first, which some clients rely on..
*/
- const struct imap_fetch_context_handler *handlers;
+ const struct imap_fetch_context_handler *ctx_handler;
struct imap_fetch_context_handler h;
- unsigned int i, size;
if (context == NULL) {
/* don't allow duplicate handlers */
- handlers = array_get(&ctx->handlers, &size);
-
- for (i = 0; i < size; i++) {
- if (handlers[i].handler == handler &&
- handlers[i].context == NULL)
+ array_foreach(&ctx->handlers, ctx_handler) {
+ if (ctx_handler->handler == handler &&
+ ctx_handler->context == NULL)
return;
}
}
mailbox_expunge_to_range(const ARRAY_TYPE(mailbox_expunge_rec) *input,
ARRAY_TYPE(seq_range) *output)
{
- const struct mailbox_expunge_rec *expunges;
- unsigned int i, count;
+ const struct mailbox_expunge_rec *expunge;
- expunges = array_get(input, &count);
- for (i = 0; i < count; i++)
- seq_range_array_add(output, 0, expunges[i].uid);
+ array_foreach(input, expunge)
+ seq_range_array_add(output, 0, expunge->uid);
}
static int
int imap_fetch_deinit(struct imap_fetch_context *ctx)
{
- const struct imap_fetch_context_handler *handlers;
- unsigned int i, count;
+ const struct imap_fetch_context_handler *handler;
- handlers = array_get(&ctx->handlers, &count);
- for (i = 0; i < count; i++) {
- if (handlers[i].want_deinit)
- handlers[i].handler(ctx, NULL, handlers[i].context);
+ array_foreach(&ctx->handlers, handler) {
+ if (handler->want_deinit)
+ handler->handler(ctx, NULL, handler->context);
}
if (!ctx->line_finished) {
const struct auth_mech_desc *
auth_client_find_mech(struct auth_client *client, const char *name)
{
- const struct auth_mech_desc *mechs;
- unsigned int i, count;
+ const struct auth_mech_desc *mech;
- mechs = array_get(&client->conn->available_auth_mechs, &count);
- for (i = 0; i < count; i++) {
- if (strcasecmp(mechs[i].name, name) == 0)
- return &mechs[i];
+ array_foreach(&client->conn->available_auth_mechs, mech) {
+ if (strcasecmp(mech->name, name) == 0)
+ return mech;
}
return NULL;
}
static bool
array_has_name(const ARRAY_TYPE(const_string) *names, const char *name)
{
- const char *const *str;
- unsigned int i, count;
+ const char *const *namep;
- str = array_get(names, &count);
- for (i = 0; i < count; i++) {
- if (strcmp(str[i], name) == 0)
+ array_foreach(names, namep) {
+ if (strcmp(*namep, name) == 0)
return TRUE;
}
return FALSE;
unsigned int *lock_id)
{
struct mail_index *index = map->index;
- mail_index_sync_lost_handler_t *const *handlers;
+ mail_index_sync_lost_handler_t *const *handlerp;
struct stat st;
- unsigned int i, count;
+ unsigned int i;
int ret;
bool try_retry, retry;
/* notify all "sync lost" handlers */
- handlers = array_get(&index->sync_lost_handlers, &count);
- for (i = 0; i < count; i++)
- (*handlers[i])(index);
+ array_foreach(&index->sync_lost_handlers, handlerp)
+ (**handlerp)(index);
for (i = 0;; i++) {
try_retry = i < MAIL_INDEX_ESTALE_RETRY_COUNT;
struct mail_index_map *mail_index_map_clone(const struct mail_index_map *map)
{
struct mail_index_map *mem_map;
- struct mail_index_ext *extensions;
- unsigned int i, count;
+ struct mail_index_ext *ext;
+ unsigned int count;
mem_map = i_new(struct mail_index_map, 1);
mem_map->index = map->index;
array_append_array(&mem_map->ext_id_map, &map->ext_id_map);
/* fix the name pointers to use our own pool */
- extensions = array_get_modifiable(&mem_map->extensions, &count);
- for (i = 0; i < count; i++) {
- i_assert(extensions[i].record_offset +
- extensions[i].record_size <=
+ array_foreach_modifiable(&mem_map->extensions, ext) {
+ i_assert(ext->record_offset + ext->record_size <=
mem_map->hdr.record_size);
- extensions[i].name = p_strdup(mem_map->extension_pool,
- extensions[i].name);
+ ext->name = p_strdup(mem_map->extension_pool,
+ ext->name);
}
}
uint32_t seq1, uint32_t seq2)
{
struct metadata_modseqs *metadata;
- unsigned int i, count;
uint64_t modseq;
if (ctx->mmap == NULL)
return;
seq1--;
- metadata = array_get_modifiable(&ctx->mmap->metadata_modseqs, &count);
- for (i = 0; i < count; i++) {
- if (array_is_created(&metadata[i].modseqs))
- array_delete(&metadata[i].modseqs, seq1, seq2-seq1);
+ array_foreach_modifiable(&ctx->mmap->metadata_modseqs, metadata) {
+ if (array_is_created(&metadata->modseqs))
+ array_delete(&metadata->modseqs, seq1, seq2-seq1);
}
modseq = mail_transaction_log_view_get_prev_modseq(ctx->log_view);
{
struct mail_index_map_modseq *mmap = *_mmap;
struct metadata_modseqs *metadata;
- unsigned int i, count;
*_mmap = NULL;
- metadata = array_get_modifiable(&mmap->metadata_modseqs, &count);
- for (i = 0; i < count; i++) {
- if (array_is_created(&metadata[i].modseqs))
- array_free(&metadata[i].modseqs);
+ array_foreach_modifiable(&mmap->metadata_modseqs, metadata) {
+ if (array_is_created(&metadata->modseqs))
+ array_free(&metadata->modseqs);
}
array_free(&mmap->metadata_modseqs);
i_free(mmap);
mail_index_sync_deinit_expunge_handlers(struct mail_index_sync_map_ctx *ctx)
{
const struct mail_index_expunge_handler *eh;
- unsigned int i, count;
if (!array_is_created(&ctx->expunge_handlers))
return;
- eh = array_get(&ctx->expunge_handlers, &count);
- for (i = 0; i < count; i++) {
- if (eh[i].sync_context != NULL) {
- eh[i].handler(ctx, 0, NULL, eh[i].sync_context,
- eh[i].context);
+ array_foreach(&ctx->expunge_handlers, eh) {
+ if (eh->sync_context != NULL) {
+ eh->handler(ctx, 0, NULL, eh->sync_context,
+ eh->context);
}
}
-
array_free(&ctx->expunge_handlers);
}
{
const struct mail_index_expunge_handler *eh;
struct mail_index_record *rec;
- unsigned int i, count;
uint32_t seq;
/* call expunge handlers only when syncing index file */
if (!array_is_created(&ctx->expunge_handlers))
return;
- eh = array_get(&ctx->expunge_handlers, &count);
- for (i = 0; i < count; i++, eh++) {
+ array_foreach(&ctx->expunge_handlers, eh) {
for (seq = seq1; seq <= seq2; seq++) {
rec = MAIL_INDEX_MAP_IDX(ctx->view->map, seq-1);
/* FIXME: does expunge handler's return value matter?
bool mail_index_sync_have_more(struct mail_index_sync_ctx *ctx)
{
const struct mail_index_sync_list *sync_list;
- unsigned int i, count;
if (ctx->sync_appends)
return TRUE;
- sync_list = array_get(&ctx->sync_list, &count);
- for (i = 0; i < count; i++) {
- if (array_is_created(sync_list[i].array) &&
- sync_list[i].idx != array_count(sync_list[i].array))
+ array_foreach(&ctx->sync_list, sync_list) {
+ if (array_is_created(sync_list->array) &&
+ sync_list->idx != array_count(sync_list->array))
return TRUE;
}
return FALSE;
void mail_index_sync_reset(struct mail_index_sync_ctx *ctx)
{
struct mail_index_sync_list *sync_list;
- unsigned int i, count;
ctx->next_uid = 0;
-
- sync_list = array_get_modifiable(&ctx->sync_list, &count);
- for (i = 0; i < count; i++)
- sync_list[i].idx = 0;
+ array_foreach_modifiable(&ctx->sync_list, sync_list)
+ sync_list->idx = 0;
}
static void mail_index_sync_end(struct mail_index_sync_ctx **_ctx)
static void keyword_updates_convert_to_uids(struct mail_index_transaction *t)
{
- struct mail_index_transaction_keyword_update *updates;
- unsigned int i, count;
+ struct mail_index_transaction_keyword_update *update;
if (!array_is_created(&t->keyword_updates))
return;
- updates = array_get_modifiable(&t->keyword_updates, &count);
- for (i = 0; i < count; i++) {
- mail_index_convert_to_uid_ranges(t, &updates[i].add_seq);
- mail_index_convert_to_uid_ranges(t, &updates[i].remove_seq);
+ array_foreach_modifiable(&t->keyword_updates, update) {
+ mail_index_convert_to_uid_ranges(t, &update->add_seq);
+ mail_index_convert_to_uid_ranges(t, &update->remove_seq);
}
}
static void
mail_index_transaction_convert_to_uids(struct mail_index_transaction *t)
{
- ARRAY_TYPE(seq_array) *updates;
- unsigned int i, count;
+ ARRAY_TYPE(seq_array) *update;
if (array_is_created(&t->ext_rec_updates)) {
- updates = array_get_modifiable(&t->ext_rec_updates, &count);
- for (i = 0; i < count; i++)
- mail_index_convert_to_uids(t, (void *)&updates[i]);
+ array_foreach_modifiable(&t->ext_rec_updates, update)
+ mail_index_convert_to_uids(t, update);
}
if (array_is_created(&t->ext_rec_atomics)) {
- updates = array_get_modifiable(&t->ext_rec_atomics, &count);
- for (i = 0; i < count; i++)
- mail_index_convert_to_uids(t, (void *)&updates[i]);
+ array_foreach_modifiable(&t->ext_rec_atomics, update)
+ mail_index_convert_to_uids(t, update);
}
keyword_updates_convert_to_uids(t);
mail_index_transaction_sort_appends_keywords(struct mail_index_transaction *t,
const uint32_t *old_to_newseq_map)
{
- struct mail_index_transaction_keyword_update *updates;
- unsigned int i, count;
+ struct mail_index_transaction_keyword_update *update;
if (array_is_created(&t->keyword_updates)) {
- updates = array_get_modifiable(&t->keyword_updates, &count);
- for (i = 0; i < count; i++) {
- if (array_is_created(&updates[i].add_seq)) {
- sort_appends_seq_range(&updates[i].add_seq,
+ array_foreach_modifiable(&t->keyword_updates, update) {
+ if (array_is_created(&update->add_seq)) {
+ sort_appends_seq_range(&update->add_seq,
t->first_new_seq,
old_to_newseq_map);
}
- if (array_is_created(&updates[i].remove_seq)) {
- sort_appends_seq_range(&updates[i].remove_seq,
+ if (array_is_created(&update->remove_seq)) {
+ sort_appends_seq_range(&update->remove_seq,
t->first_new_seq,
old_to_newseq_map);
}
void mail_index_transaction_reset_v(struct mail_index_transaction *t)
{
- ARRAY_TYPE(seq_array) *recs;
- struct mail_index_transaction_ext_hdr_update *ext_hdrs;
- unsigned i, count;
+ ARRAY_TYPE(seq_array) *rec;
+ struct mail_index_transaction_ext_hdr_update *ext_hdr;
if (array_is_created(&t->ext_rec_updates)) {
- recs = array_get_modifiable(&t->ext_rec_updates, &count);
- for (i = 0; i < count; i++) {
- if (array_is_created(&recs[i]))
- array_free(&recs[i]);
+ array_foreach_modifiable(&t->ext_rec_updates, rec) {
+ if (array_is_created(rec))
+ array_free(rec);
}
array_free(&t->ext_rec_updates);
}
if (array_is_created(&t->ext_rec_atomics)) {
- recs = array_get_modifiable(&t->ext_rec_atomics, &count);
- for (i = 0; i < count; i++) {
- if (array_is_created(&recs[i]))
- array_free(&recs[i]);
+ array_foreach_modifiable(&t->ext_rec_atomics, rec) {
+ if (array_is_created(rec))
+ array_free(rec);
}
array_free(&t->ext_rec_atomics);
}
if (array_is_created(&t->ext_hdr_updates)) {
- ext_hdrs = array_get_modifiable(&t->ext_hdr_updates, &count);
- for (i = 0; i < count; i++) {
- i_free(ext_hdrs[i].data);
- i_free(ext_hdrs[i].mask);
+ array_foreach_modifiable(&t->ext_hdr_updates, ext_hdr) {
+ i_free(ext_hdr->data);
+ i_free(ext_hdr->mask);
}
array_free(&t->ext_hdr_updates);
}
if (array_is_created(&t->keyword_updates)) {
struct mail_index_transaction_keyword_update *u;
- u = array_get_modifiable(&t->keyword_updates, &count);
- for (i = 0; i < count; i++) {
- if (array_is_created(&u[i].add_seq))
- array_free(&u[i].add_seq);
- if (array_is_created(&u[i].remove_seq))
- array_free(&u[i].remove_seq);
+ array_foreach_modifiable(&t->keyword_updates, u) {
+ if (array_is_created(&u->add_seq))
+ array_free(&u->add_seq);
+ if (array_is_created(&u->remove_seq))
+ array_free(&u->remove_seq);
}
array_free(&t->keyword_updates);
}
uint32_t seq)
{
ARRAY_TYPE(seq_array) *seqs;
- unsigned int i, count, idx;
+ unsigned int idx;
if (!array_is_created(ext_updates))
return;
- seqs = array_get_modifiable(ext_updates, &count);
- for (i = 0; i < count; i++) {
- if (array_is_created(&seqs[i]) &&
- mail_index_seq_array_lookup(&seqs[i], seq, &idx))
- array_delete(&seqs[i], idx, 1);
+ array_foreach_modifiable(ext_updates, seqs) {
+ if (array_is_created(seqs) &&
+ mail_index_seq_array_lookup(seqs, seq, &idx))
+ array_delete(seqs, idx, 1);
}
}
static void
mail_index_expunge_last_append(struct mail_index_transaction *t, uint32_t seq)
{
- struct mail_index_transaction_keyword_update *kw_updates;
- unsigned int i, count;
+ struct mail_index_transaction_keyword_update *kw_update;
+ unsigned int i;
i_assert(seq == t->last_new_seq);
if (array_is_created(&t->keyword_resets))
seq_range_array_remove(&t->keyword_resets, seq);
if (array_is_created(&t->keyword_updates)) {
- kw_updates = array_get_modifiable(&t->keyword_updates, &count);
- for (i = 0; i < count; i++) {
- if (array_is_created(&kw_updates[i].add_seq)) {
- seq_range_array_remove(&kw_updates[i].add_seq,
+ array_foreach_modifiable(&t->keyword_updates, kw_update) {
+ if (array_is_created(&kw_update->add_seq)) {
+ seq_range_array_remove(&kw_update->add_seq,
seq);
}
- if (array_is_created(&kw_updates[i].remove_seq)) {
- seq_range_array_remove(
- &kw_updates[i].remove_seq, seq);
+ if (array_is_created(&kw_update->remove_seq)) {
+ seq_range_array_remove(&kw_update->remove_seq,
+ seq);
}
}
}
mail_index_transaction_has_ext_updates(const ARRAY_TYPE(seq_array_array) *arr)
{
const ARRAY_TYPE(seq_array) *array;
- unsigned int i, count;
if (array_is_created(arr)) {
- array = array_get(arr, &count);
- for (i = 0; i < count; i++) {
- if (array_is_created(&array[i]))
+ array_foreach(arr, array) {
+ if (array_is_created(array))
return TRUE;
}
}
static bool
mail_index_transaction_has_ext_changes(struct mail_index_transaction *t)
{
- unsigned int i, count;
-
if (mail_index_transaction_has_ext_updates(&t->ext_rec_updates))
return TRUE;
if (mail_index_transaction_has_ext_updates(&t->ext_rec_atomics))
if (array_is_created(&t->ext_hdr_updates)) {
const struct mail_index_transaction_ext_hdr_update *hdr;
- hdr = array_get(&t->ext_hdr_updates, &count);
- for (i = 0; i < count; i++) {
- if (hdr[i].alloc_size > 0)
+ array_foreach(&t->ext_hdr_updates, hdr) {
+ if (hdr->alloc_size > 0)
return TRUE;
}
}
if (array_is_created(&t->ext_resets)) {
- const struct mail_transaction_ext_reset *resets;
+ const struct mail_transaction_ext_reset *reset;
- resets = array_get(&t->ext_resets, &count);
- for (i = 0; i < count; i++) {
- if (resets[i].new_reset_id != 0)
+ array_foreach(&t->ext_resets, reset) {
+ if (reset->new_reset_id != 0)
return TRUE;
}
}
if (array_is_created(&t->ext_resizes)) {
- const struct mail_transaction_ext_intro *resizes;
+ const struct mail_transaction_ext_intro *resize;
- resizes = array_get(&t->ext_resizes, &count);
- for (i = 0; i < count; i++) {
- if (resizes[i].name_size > 0)
+ array_foreach(&t->ext_resizes, resize) {
+ if (resize->name_size > 0)
return TRUE;
}
}
struct mail_keywords *keywords)
{
struct mail_index_transaction_keyword_update *u;
- unsigned int i, ku_count;
+ unsigned int i;
bool changed;
i_assert(seq > 0 &&
case MODIFY_REPLACE:
/* Remove sequence from all add/remove arrays */
if (array_is_created(&t->keyword_updates)) {
- u = array_get_modifiable(&t->keyword_updates,
- &ku_count);
- for (i = 0; i < ku_count; i++) {
- seq_range_array_remove(&u[i].add_seq, seq);
- seq_range_array_remove(&u[i].remove_seq, seq);
+ array_foreach_modifiable(&t->keyword_updates, u) {
+ seq_range_array_remove(&u->add_seq, seq);
+ seq_range_array_remove(&u->remove_seq, seq);
}
}
/* Add the wanted keyword back */
uint32_t seq)
{
struct mail_index_transaction_keyword_update *kw;
- unsigned int i, count;
bool ret, have_kw_changes = FALSE;
ret = mail_index_cancel_array(&t->keyword_resets, seq);
if (!array_is_created(&t->keyword_updates))
return ret;
- kw = array_get_modifiable(&t->keyword_updates, &count);
- for (i = 0; i < count; i++) {
- if (mail_index_cancel_array(&kw[i].add_seq, seq))
+ array_foreach_modifiable(&t->keyword_updates, kw) {
+ if (mail_index_cancel_array(&kw->add_seq, seq))
ret = TRUE;
- if (mail_index_cancel_array(&kw[i].remove_seq, seq))
+ if (mail_index_cancel_array(&kw->remove_seq, seq))
ret = TRUE;
- if (array_is_created(&kw[i].add_seq) ||
- array_is_created(&kw[i].remove_seq))
+ if (array_is_created(&kw->add_seq) ||
+ array_is_created(&kw->remove_seq))
have_kw_changes = TRUE;
}
if (!have_kw_changes)
static bool
view_sync_is_hidden(struct mail_index_view *view, uint32_t seq, uoff_t offset)
{
- const struct mail_index_view_log_sync_area *syncs;
- unsigned int i, count;
+ const struct mail_index_view_log_sync_area *sync;
if (!array_is_created(&view->syncs_hidden))
return FALSE;
- syncs = array_get(&view->syncs_hidden, &count);
- for (i = 0; i < count; i++) {
- if (syncs[i].log_file_offset <= offset &&
- offset - syncs[i].log_file_offset < syncs[i].length &&
- syncs[i].log_file_seq == seq)
+ array_foreach(&view->syncs_hidden, sync) {
+ if (sync->log_file_offset <= offset &&
+ offset - sync->log_file_offset < sync->length &&
+ sync->log_file_seq == seq)
return TRUE;
}
{
struct mysql_db *db = (struct mysql_db *)_db;
struct mysql_connection *conn;
- unsigned int i, count;
int ret = -1;
- conn = array_get_modifiable(&db->connections, &count);
- for (i = 0; i < count; i++) {
- if (driver_mysql_connect(&conn[i]))
+ array_foreach_modifiable(&db->connections, conn) {
+ if (driver_mysql_connect(conn))
ret = 1;
}
return ret;
{
struct mysql_db *db = (struct mysql_db *)_db;
struct mysql_connection *conn;
- unsigned int i, count;
- conn = array_get_modifiable(&db->connections, &count);
- for (i = 0; i < count; i++)
- (void)driver_mysql_connection_free(&conn[i]);
+ array_foreach_modifiable(&db->connections, conn)
+ (void)driver_mysql_connection_free(conn);
array_free(&_db->module_contexts);
pool_unref(&db->pool);
}
if (array_is_created(&result->binary_values)) {
- struct pgsql_binary_value *values;
- unsigned int i, count;
+ struct pgsql_binary_value *value;
- values = array_get_modifiable(&result->binary_values, &count);
- for (i = 0; i < count; i++)
- PQfreemem(values[i].value);
+ array_foreach_modifiable(&result->binary_values, value)
+ PQfreemem(value->value);
array_free(&result->binary_values);
}
{
struct index_mailbox *ibox = (struct index_mailbox *)box;
const struct seq_range *seqs;
- unsigned int i, count;
uint32_t seq, uid;
if (array_count(&box->search_results) == 0)
return;
- seqs = array_get(expunges, &count);
- for (i = 0; i < count; i++) {
- for (seq = seqs[i].seq1; seq <= seqs[i].seq2; seq++) {
+ array_foreach(expunges, seqs) {
+ for (seq = seqs->seq1; seq <= seqs->seq2; seq++) {
mail_index_lookup_uid(ibox->view, seq, &uid);
mailbox_search_results_remove(box, uid);
}
static void index_sort_list_reset_broken(struct sort_string_context *ctx)
{
struct mailbox *box = ctx->program->t->box;
- struct mail_sort_node *nodes;
- unsigned int i, count;
+ struct mail_sort_node *node;
mail_storage_set_critical(box->storage,
"%s: Broken %s indexes, resetting",
&ctx->nonzero_nodes);
array_clear(&ctx->nonzero_nodes);
- nodes = array_get_modifiable(&ctx->zero_nodes, &count);
- for (i = 0; i < count; i++)
- nodes[i].sort_id = 0;
+ array_foreach_modifiable(&ctx->zero_nodes, node)
+ node->sort_id = 0;
}
void index_sort_list_finish_string(struct mail_search_sort_program *program)
static void index_sync_uidify_array(struct index_mailbox_sync_context *ctx,
const ARRAY_TYPE(seq_range) *changes)
{
- const struct seq_range *seqs;
- unsigned int i, count;
+ const struct seq_range *range;
uint32_t seq, uid;
- seqs = array_get(changes, &count);
- for (i = 0; i < count; i++) {
- for (seq = seqs[i].seq1; seq <= seqs[i].seq2; seq++) {
+ array_foreach(changes, range) {
+ for (seq = range->seq1; seq <= range->seq2; seq++) {
mail_index_lookup_uid(ctx->ibox->view, seq, &uid);
seq_range_array_add(&ctx->all_flag_update_uids, 0, uid);
}
const ARRAY_TYPE(seq_range) *src)
{
const struct seq_range *range;
- unsigned int i, count;
if (array_count(dest) == 0) {
array_append_array(dest, src);
return;
}
- range = array_get(src, &count);
- for (i = 0; i < count; i++)
- seq_range_array_add_range(dest, range[i].seq1, range[i].seq2);
+ array_foreach(src, range)
+ seq_range_array_add_range(dest, range->seq1, range->seq2);
}
bool seq_range_array_remove(ARRAY_TYPE(seq_range) *array, uint32_t seq)
{
unsigned int ret = 0;
const struct seq_range *src_range;
- unsigned int i, count;
- src_range = array_get(src, &count);
- for (i = 0; i < count; i++) {
- ret += seq_range_array_remove_range(dest, src_range[i].seq1,
- src_range[i].seq2);
+ array_foreach(src, src_range) {
+ ret += seq_range_array_remove_range(dest, src_range->seq1,
+ src_range->seq2);
}
return ret;
}
unsigned int seq_range_count(const ARRAY_TYPE(seq_range) *array)
{
const struct seq_range *range;
- unsigned int i, count, seq_count;
+ unsigned int seq_count = 0;
- range = array_get(array, &count);
- for (i = seq_count = 0; i < count; i++)
- seq_count += range[i].seq2 - range[i].seq1 + 1;
+ array_foreach(array, range)
+ seq_count += range->seq2 - range->seq1 + 1;
return seq_count;
}
static bool rcpt_is_duplicate(struct client *client, const char *name)
{
- const struct mail_recipient *rcpts;
- unsigned int i, count;
+ const struct mail_recipient *rcpt;
- rcpts = array_get(&client->state.rcpt_to, &count);
- for (i = 0; i < count; i++) {
- if (strcmp(rcpts[i].name, name) == 0)
+ array_foreach(&client->state.rcpt_to, rcpt) {
+ if (strcmp(rcpt->name, name) == 0)
return TRUE;
}
return FALSE;
static void client_rcpt_fail_all(struct client *client)
{
- const struct mail_recipient *rcpts;
- unsigned int i, count;
+ const struct mail_recipient *rcpt;
- rcpts = array_get(&client->state.rcpt_to, &count);
- for (i = 0; i < count; i++) {
- client_send_line(client, ERRSTR_TEMP_MAILBOX_FAIL,
- rcpts[i].name);
- }
+ array_foreach(&client->state.rcpt_to, rcpt)
+ client_send_line(client, ERRSTR_TEMP_MAILBOX_FAIL, rcpt->name);
}
static struct istream *client_get_input(struct client *client)
const char *reason)
{
struct lmtp_proxy_recipient *rcpt;
- unsigned int i, count;
/* set failure replies to all recipients in this connection */
- rcpt = array_get_modifiable(&conn->proxy->rcpt_to, &count);
- for (i = 0; i < count; i++) {
- if (rcpt[i].conn == conn && !rcpt[i].rcpt_to_failed)
- rcpt[i].reply = reason;
+ array_foreach_modifiable(&conn->proxy->rcpt_to, rcpt) {
+ if (rcpt->conn == conn && !rcpt->rcpt_to_failed)
+ rcpt->reply = reason;
}
if (conn->client != NULL)
const char *name)
{
const struct acl_backend_vfile_acllist *acllist;
- unsigned int i, count;
- acllist = array_get(&backend->acllist, &count);
- for (i = 0; i < count; i++) {
- if (strcmp(acllist[i].name, name) == 0)
- return &acllist[i];
+ array_foreach(&backend->acllist, acllist) {
+ if (strcmp(acllist->name, name) == 0)
+ return acllist;
}
return NULL;
}
static int
squat_trie_iterate_deinit(struct squat_trie_iterate_context *ctx)
{
- struct squat_trie_iterate_node *nodes;
- unsigned int i, count;
+ struct squat_trie_iterate_node *node;
int ret = ctx->failed ? -1 : 0;
if (array_is_created(&ctx->cur.shifts)) {
- nodes = array_get_modifiable(&ctx->parents, &count);
- for (i = 0; i < count; i++)
- array_free(&nodes[i].shifts);
+ array_foreach_modifiable(&ctx->parents, node)
+ array_free(&node->shifts);
array_free(&ctx->cur.shifts);
}
array_free(&ctx->parents);
static void quota_root_set_namespace(struct quota_root *root,
struct mail_namespace *namespaces)
{
- const struct quota_rule *rules;
- unsigned int i, count;
+ const struct quota_rule *rule;
const char *name;
if (root->ns_prefix != NULL && root->ns == NULL) {
}
}
- rules = array_get(&root->set->rules, &count);
- for (i = 0; i < count; i++) {
- name = rules[i].mailbox_name;
+ array_foreach(&root->set->rules, rule) {
+ name = rule->mailbox_name;
if (mail_namespace_find(namespaces, &name) == NULL)
i_error("quota: Unknown namespace: %s", name);
}
struct quota_rule *
quota_root_rule_find(struct quota_root_settings *root_set, const char *name)
{
- struct quota_rule *rules;
- unsigned int i, count;
+ struct quota_rule *rule;
- rules = array_get_modifiable(&root_set->rules, &count);
- for (i = 0; i < count; i++) {
- if (strcmp(rules[i].mailbox_name, name) == 0)
- return &rules[i];
+ array_foreach_modifiable(&root_set->rules, rule) {
+ if (strcmp(rule->mailbox_name, name) == 0)
+ return rule;
}
return NULL;
}
void quota_root_recalculate_relative_rules(struct quota_root_settings *root_set)
{
- struct quota_rule *rules;
- struct quota_warning_rule *warning_rules;
- unsigned int i, count;
+ struct quota_rule *rule;
+ struct quota_warning_rule *warning_rule;
- rules = array_get_modifiable(&root_set->rules, &count);
- for (i = 0; i < count; i++) {
- quota_rule_recalculate_relative_rules(&rules[i],
+ array_foreach_modifiable(&root_set->rules, rule) {
+ quota_rule_recalculate_relative_rules(rule,
&root_set->default_rule);
}
- warning_rules = array_get_modifiable(&root_set->warning_rules, &count);
- for (i = 0; i < count; i++) {
- quota_rule_recalculate_relative_rules(&warning_rules[i].rule,
+ array_foreach_modifiable(&root_set->warning_rules, warning_rule) {
+ quota_rule_recalculate_relative_rules(&warning_rule->rule,
&root_set->default_rule);
}
}
projects / thirdparty / dovecot / core.git / commitdiff
