ucx/cx/iterator.h

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
/**
 * @file iterator.h
 * @brief Interface for iterator implementations.
 * @author Mike Becker
 * @author Olaf Wintermann
 * @copyright 2-Clause BSD License
 */

#ifndef UCX_ITERATOR_H
#define UCX_ITERATOR_H

#include "common.h"

/**
 * Common data for all iterators.
 */
struct cx_iterator_base_s {
    /**
     * True if the iterator points to valid data.
     */
    bool (*valid)(const void *);
    /**
     * Original implementation in case the function needs to be wrapped.
     */
    bool (*valid_impl)(const void *);
    /**
     * Returns a pointer to the current element.
     *
     * When valid returns false, the behavior of this function is undefined.
     */
    void *(*current)(const void *);

    /**
     * Original implementation in case the function needs to be wrapped.
     */
    void *(*current_impl)(const void *);
    /**
     * Advances the iterator.
     *
     * When valid returns false, the behavior of this function is undefined.
     */
    void (*next)(void *);
    /**
     * Original implementation in case the function needs to be wrapped.
     */
    void (*next_impl)(void *);
    /**
     * Indicates whether this iterator may remove elements.
     */
    bool allow_remove;
    /**
     * Internal flag for removing the current element when advancing.
     */
    bool remove;
};

/**
 * Convenience type definition for the base structure of an iterator.
 * @see #CX_ITERATOR_BASE
 */
typedef struct cx_iterator_base_s CxIteratorBase;

/**
 * Declares base attributes for an iterator.
 * Must be the first member of an iterator structure.
 */
#define CX_ITERATOR_BASE struct cx_iterator_base_s base

/**
 * Internal iterator struct - use CxIterator.
 */
struct cx_iterator_s {
    /**
     * Inherited common data for all iterators.
     */
    CX_ITERATOR_BASE;

    /**
     * Handle for the current element.
     */
    void *elem_handle;

    /**
     * Handle for the source collection, if any.
     */
    void *src_handle;

    /**
     * If the iterator is position-aware, contains the index of the element in the underlying collection.
     * Otherwise, this field is usually uninitialized.
     */
    size_t index;

    /**
     * The size of an individual element.
     */
    size_t elem_size;

    /**
     * May contain the total number of elements, if known.
     * Shall be set to @c SIZE_MAX when the total number is unknown during iteration.
     */
    size_t elem_count;
};

/**
 * Iterator type.
 *
 * An iterator points to a certain element in a (possibly unbounded) chain of elements.
 * Iterators that are based on collections (which have a defined "first" element) are supposed
 * to be "position-aware", which means that they keep track of the current index within the collection.
 *
 * @note Objects that are pointed to by an iterator are always mutable through that iterator. However,
 * any concurrent mutation of the collection other than by this iterator makes this iterator obsolete,
 * and it must not be used anymore.
 */
typedef struct cx_iterator_s CxIterator;

/**
 * Checks if the iterator points to valid data.
 *
 * @param iter the iterator
 * @retval true if the iterator points to valid data
 * @retval false if the iterator already moved past the end
 */
#define cxIteratorValid(iter) (iter).base.valid(&(iter))

/**
 * Returns a pointer to the current element.
 *
 * The behavior is undefined if this iterator is invalid.
 *
 * @param iter the iterator
 * @return a pointer to the current element
 * @see cxIteratorValid()
 */
#define cxIteratorCurrent(iter) (iter).base.current(&iter)

/**
 * Advances the iterator to the next element.
 *
 * @param iter the iterator
 */
#define cxIteratorNext(iter) (iter).base.next(&iter)

/**
 * Flags the current element for removal if the iterator allows it.
 *
 * @param iter the iterator
 * @return @c true if removal is allowed, @c false otherwise
 */
#define cxIteratorFlagRemoval(iter) ((iter).base.remove = (iter).base.allow_remove)

/**
 * Loops over an iterator.
 *
 * @param type the type of the elements
 * @param elem the name of the iteration variable
 * @param iter the iterator
 */
#define cx_foreach(type, elem, iter) \
for (type elem; cxIteratorValid(iter) && (elem = (type)cxIteratorCurrent(iter)) != NULL ; cxIteratorNext(iter))


/**
 * Creates an iterator for the specified plain array.
 *
 * The @p array can be @c NULL, in which case the iterator will be immediately
 * initialized such that #cxIteratorValid() returns @c false.
 *
 * This iterator yields the addresses of the array elements.
 * If you want to iterator over an array of pointers, you can
 * use cxIteratorPtr() to create an iterator which directly
 * yields the stored pointers.
 *
 * @param array a pointer to the array (can be @c NULL)
 * @param elem_size the size of one array element
 * @param elem_count the number of elements in the array
 * @return an iterator for the specified array
 * @see cxIteratorPtr()
 */
CX_EXTERN CX_NODISCARD
CxIterator cxIterator(const void *array,
        size_t elem_size, size_t elem_count);

/**
 * Creates an iterator for the specified plain pointer array.
 *
 * This iterator assumes that every element in the array is a pointer
 * and yields exactly those pointers during iteration (on the other
 * hand, an iterator created with cxIterator() would return the
 * addresses of those pointers within the array).
 *
 * @param array a pointer to the array (can be @c NULL)
 * @param elem_count the number of elements in the array
 * @return an iterator for the specified array
 * @see cxIterator()
 */
CX_EXTERN CX_NODISCARD
CxIterator cxIteratorPtr(const void *array, size_t elem_count);

#endif // UCX_ITERATOR_H