#define _connector_iter_init(iter, xconn, xsize, xread) \
    do {                                                \
        (iter)->conn = xconn;                           \
        (iter)->req_size = xsize;                       \
        (iter)->size = xsize;                           \
        (iter)->loc = xsize;                            \
        (iter)->block = NULL;                           \
        (iter)->read = xread;                           \
    } while (0)

#define connector_iter_write_init(iter, conn, size)     \
    _connector_iter_init(iter, conn, size, 0)

#define _connector_read_next_loc(iter, rec)                     \
    (*((uint8_t **)rec) = ((iter)->block + (iter)->loc),        \
     (iter)->loc += sizeof(**(rec)),                            \
     0)

#define _connector_read_block_next_rec(iter, rec, err)          \
    ((iter)->size = (iter)->req_size,                           \
     (sk_connector_get_read_block((iter)->conn, &(iter)->block, \
                                  &(iter)->size, err)           \
      ? -1                                                      \
      : _connector_read_next_loc(iter, rec)))

#define _connector_read_reset_block(iter, rec, err)     \
    ((iter)->block = NULL,                              \
     (iter)->loc = 0,                                   \
     _connector_read_block_next_rec(iter, rec, err))

#define connector_iter_read_rec(iter, rec, err)                         \
    (((iter)->loc >= (iter)->size)                                      \
     ? ((iter)->block                                                   \
        ? (sk_connector_return_read_block((iter)->conn, (iter)->block, err) \
           ? -1                                                         \
           : _connector_read_reset_block(iter, rec, err))               \
        : _connector_read_reset_block(iter, rec, err))                  \
     : _connector_read_next_loc(iter, rec))

#define _connector_write_next_loc(iter, rec)                    \
    (memcpy((iter)->block + (iter)->loc, (rec), sizeof(*rec)),  \
     (iter)->loc += sizeof(*(rec)),                             \
     0)

#define _connector_write_block_next_rec(iter, rec, err)                 \
        ((iter)->size = (iter)->req_size,                               \
         (sk_connector_get_write_block((iter)->conn, &(iter)->block,    \
                                       &(iter)->size, err)              \
          ? -1                                                          \
          : _connector_write_next_loc(iter, rec)))

#define _connector_write_reset_block(iter, rec, err)    \
    ((iter)->block = NULL,                              \
     (iter)->loc = 0,                                   \
     _connector_write_block_next_rec(iter, rec, err))

#define connector_iter_write_rec(iter, rec, err)                        \
    (((iter)->loc + sizeof(*(rec)) > (iter)->size)                      \
     ? ((iter)->block                                                   \
        ? (sk_connector_return_write_block((iter)->conn, (iter)->block, \
                                           (iter)->loc, err)            \
           ? -1                                                         \
           : _connector_write_reset_block(iter, rec, err))              \
        : _connector_write_reset_block(iter, rec, err))                 \
     : _connector_write_next_loc(iter, rec))

#define connector_iter_finalize(iter, err)                              \
    ((iter)->block                                                      \
     ? ((iter)->read                                                    \
        ? sk_connector_return_read_block((iter)->conn, (iter)->block, err) \
        : sk_connector_return_write_block((iter)->conn, (iter)->block,  \
                                          (iter)->loc, err))            \
     : 0)

/*
** Local Variables:
** mode:c
** indent-tabs-mode:nil
** c-basic-offset:4
** End:
*/