ring.h

Go to the documentation of this file.

/*
 * Copyright 2006, 2007 Daniel Silverstone <dsilvers@digital-scurf.org>
 *
 * This file is part of NetSurf, http://www.netsurf-browser.org/
 *
 * NetSurf is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * NetSurf is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
/** \file
 * Ring list structure.
 *
 * Rings are structures which have an r_next pointer and an r_prev
 * pointer which are always initialised and always point at the next
 * or previous element respectively.
 *
 * The degenerate case of a single element in the ring simply points
 * at itself in both directions. A zero element ring is NULL.
 *
 * Some of the ring functions are specific to the fetcher but may be
 * of use to others and are thus included here.
 */
 
#ifndef _NETSURF_UTILS_RING_H_
#define _NETSURF_UTILS_RING_H_
 
 
/** Insert the given item into the specified ring.
 * Assumes that the element is zeroed as appropriate.
 */
#define RING_INSERT(ring,element) \
        /*LOG("RING_INSERT(%s, %p(%s))", #ring, element, element->host);*/ \
        if (ring) { \
                element->r_next = ring; \
                element->r_prev = ring->r_prev; \
                ring->r_prev = element; \
                element->r_prev->r_next = element; \
        } else \
                ring = element->r_prev = element->r_next = element
 
/** Remove the given element from the specified ring.
 * Will zero the element as needed
 */
#define RING_REMOVE(ring, element) \
        /*LOG("RING_REMOVE(%s, %p(%s)", #ring, element, element->host);*/ \
        if (element->r_next != element ) { \
                /* Not the only thing in the ring */ \
                element->r_next->r_prev = element->r_prev; \
                element->r_prev->r_next = element->r_next; \
                if (ring == element) ring = element->r_next; \
        } else { \
                /* Only thing in the ring */ \
                ring = 0; \
        } \
        element->r_next = element->r_prev = 0
 
/** Find the element (by hostname) in the given ring, leave it in the
 * provided element variable
 */
#define RING_FINDBYLWCHOST(ring, element, lwc_hostname) \
        /*LOG("RING_FINDBYHOST(%s, %s)", #ring, hostname);*/ \
        if (ring) { \
                bool found = false; \
                element = ring; \
                do { \
                        if (lwc_string_isequal(element->host, lwc_hostname, \
                                        &found) == lwc_error_ok && \
                                        found == true) { \
                                break; \
                        } \
                        element = element->r_next; \
                } while (element != ring); \
                if (!found) element = 0; \
        } else element = 0
 
/** Measure the size of a ring and put it in the supplied variable */
#define RING_GETSIZE(ringtype, ring, sizevar) \
        /*LOG("RING_GETSIZE(%s)", #ring);*/ \
        if (ring) { \
                ringtype *p = ring; \
                sizevar = 0; \
                do { \
                        sizevar++; \
                        p = p->r_next; \
                } while (p != ring); \
        } else sizevar = 0
 
/** Count the number of elements in the ring which match the provided lwc_hostname */
#define RING_COUNTBYLWCHOST(ringtype, ring, sizevar, lwc_hostname) \
        /*LOG("RING_COUNTBYHOST(%s, %s)", #ring, hostname);*/ \
        if (ring) { \
                ringtype *p = ring; \
                sizevar = 0; \
                do { \
                        bool matches = false; \
                        /* nsurl guarantees lowercase host */ \
                        if (lwc_string_isequal(p->host, lwc_hostname, \
                                        &matches) == lwc_error_ok) \
                                if (matches) \
                                        sizevar++; \
                        p = p->r_next; \
                } while (p != ring); \
        } else sizevar = 0
 
/*
 * Ring iteration works as follows:
 *
 * RING_ITERATE_START(ringtype, ring, iteratorptr) {
 *    code_using(iteratorptr);
 * } RING_ITERATE_END(ring, iteratorptr);
 *
 * If you want to stop iterating (e.g. you found your answer)
 * RING_ITERATE_STOP(ring, iteratorptr);
 * You *MUST* abort the iteration if you do something to modify
 * the ring such as deleting or adding an element.
 */
 
#define RING_ITERATE_START(ringtype, ring, iteratorptr) \
        if (ring != NULL) {                             \
                ringtype *iteratorptr = ring;           \
                do {                                    \
                        do {                            \
                        
#define RING_ITERATE_STOP(ring, iteratorptr)    \
        goto iteration_end_ring##_##iteratorptr
 
#define RING_ITERATE_END(ring, iteratorptr)             \
                        } while (false);                \
                        iteratorptr = iteratorptr->r_next;      \
                } while (iteratorptr != ring);          \
        }                                               \
        iteration_end_ring##_##iteratorptr:
 
#endif