340 lines
12 KiB
C
340 lines
12 KiB
C
/*-
|
|
* This file is provided under a dual BSD/GPLv2 license. When using or
|
|
* redistributing this file, you may do so under either license.
|
|
*
|
|
* GPL LICENSE SUMMARY
|
|
*
|
|
* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of version 2 of the GNU General Public License as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program 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, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
|
|
* The full GNU General Public License is included in this distribution
|
|
* in the file called LICENSE.GPL.
|
|
*
|
|
* BSD LICENSE
|
|
*
|
|
* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * 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
|
|
* OWNER 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.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
#ifndef _SCI_FAST_LIST_HEADER_
|
|
#define _SCI_FAST_LIST_HEADER_
|
|
|
|
/**
|
|
* @file
|
|
*
|
|
* @brief Header file that contains basic Linked List manipulation macros.
|
|
* These macros implement a double linked list (SCI_FAST_LIST_T) that is
|
|
* circular in nature. This means that the next and prev pointers for
|
|
* an empty queue head always the address of the queue head
|
|
* SCI_FAST_LIST_T. Likewise an element that has been removed from
|
|
* a queue will have its next and prev pointer set to the address of
|
|
* the SCI_FAST_LIST_T found in the structure just removed from the
|
|
* queue. Pointers in this implementation never == NULL.
|
|
*
|
|
* Definitions:
|
|
* - anchor : This is the list container and has a
|
|
* pointer to both the head and tail of the
|
|
* list elements
|
|
* - element: This is the list element not the actual
|
|
* object but the list element which has a
|
|
* pointer to the object.
|
|
*/
|
|
|
|
//******************************************************************************
|
|
//*
|
|
//* P U B L I C M E T H O D S
|
|
//*
|
|
//******************************************************************************
|
|
|
|
/**
|
|
* Initialize the double linked list anchor. The other macros require the list
|
|
* anchor to be set up using this macro.
|
|
*/
|
|
#define sci_fast_list_init(anchor) \
|
|
{ \
|
|
(anchor)->list_head = NULL; \
|
|
(anchor)->list_tail = NULL; \
|
|
(anchor)->element_count = 0; \
|
|
}
|
|
|
|
/**
|
|
* Initialize the sci_fast_list_element to point to its owning object
|
|
*/
|
|
#define sci_fast_list_element_init(list_object, element) \
|
|
{ \
|
|
(element)->object = (list_object); \
|
|
(element)->next = (element)->prev = NULL; \
|
|
(element)->owning_list = NULL; \
|
|
}
|
|
|
|
/**
|
|
* See if there is anything on the list by checking the list anchor.
|
|
*/
|
|
#define sci_fast_list_is_empty(anchor) ((anchor)->list_head == NULL)
|
|
|
|
/**
|
|
* Return a pointer to the element at the head of the sci_fast_list. The
|
|
* item is NOT removed from the list.
|
|
*
|
|
* NOTE: This macro will always return a value, even if the list is empty.
|
|
* You must insure the list is not empty or use Dlist_safeGetHead.
|
|
*
|
|
* element - A pointer into which to save the address of the structure
|
|
* containing the SCI_FAST_LIST at the list head.
|
|
*/
|
|
#define sci_fast_list_get_head(anchor) \
|
|
((anchor)->list_head == NULL ? NULL: (anchor)->list_head->object)
|
|
|
|
/**
|
|
* Return a pointer to the element at the tail of the sci_fast_list. The item
|
|
* is NOT removed from the list.
|
|
*
|
|
* NOTE: This macro will always return a value, even if the list is empty.
|
|
* You must insure the list is not empty or use Dlist_safeGetHead.
|
|
*
|
|
* element - A pointer into which to save the address of the structure
|
|
* containing the SCI_FAST_LIST at the list head.
|
|
*/
|
|
#define sci_fast_list_get_tail(anchor) \
|
|
((anchor)->list_tail == NULL ? NULL: (anchor)->list_head->object)
|
|
|
|
/**
|
|
* This method will get the next dListField in the SCI_FAST_LIST. This method
|
|
* returns a pointer to a SCI_FAST_LIST object.
|
|
*/
|
|
#define sci_fast_list_get_next(element) ((element)->next)
|
|
|
|
/**
|
|
* This method will get the prev dListField in the SCI_FAST_LIST. This method
|
|
* returns a pointer to a SCI_FAST_LIST object.
|
|
*/
|
|
#define sci_fast_list_get_prev(element) ((element)->prev)
|
|
|
|
|
|
/**
|
|
* This method returns the object that is represented by this
|
|
* sci_fast_list_element
|
|
*/
|
|
#define sci_fast_list_get_object(element) ((element)->object)
|
|
|
|
/**
|
|
* This method will determine if the supplied dListField is on a SCI_FAST_LIST.
|
|
* If the element has only one dListField but can be on more than one list,
|
|
* this will only tell you that it is on one of them. If the element has
|
|
* multiple dListFields and can exist on multiple lists at the same time, this
|
|
* macro can tell you exactly which list it is on.
|
|
*/
|
|
#define sci_fast_list_is_on_a_list(element) ((element)->owning_list != NULL)
|
|
|
|
/**
|
|
* This method will determine if the supplied dListFieldName is on the given
|
|
* specified list? If the element can be on more than one list, this
|
|
* allows you to determine exactly which list it is on. Performs a linear
|
|
* search through the list.
|
|
* result - BOOL_T that will contain the result of the search.
|
|
* TRUE - item is on the list described by head.
|
|
* FALSE - item is not on the list.
|
|
*/
|
|
#define sci_fast_list_is_on_this_list(anchor, element) \
|
|
((element)->owning_list == (anchor))
|
|
|
|
//******************************************************************************
|
|
//*
|
|
//* T Y P E S
|
|
//*
|
|
//******************************************************************************
|
|
|
|
/**
|
|
* @struct SCI_FAST_LIST
|
|
*
|
|
* @brief the list owner or list anchor for a set of SCI_FAST_LIST
|
|
* elements.
|
|
*/
|
|
typedef struct SCI_FAST_LIST
|
|
{
|
|
struct SCI_FAST_LIST_ELEMENT *list_head;
|
|
struct SCI_FAST_LIST_ELEMENT *list_tail;
|
|
int element_count;
|
|
} SCI_FAST_LIST_T;
|
|
|
|
/**
|
|
* @struct SCI_FAST_LIST_ELEMENT
|
|
*
|
|
* @brief This structure defines what a doubly linked list element contains.
|
|
*/
|
|
typedef struct SCI_FAST_LIST_ELEMENT
|
|
{
|
|
struct SCI_FAST_LIST_ELEMENT *next;
|
|
struct SCI_FAST_LIST_ELEMENT *prev;
|
|
struct SCI_FAST_LIST *owning_list;
|
|
void *object;
|
|
} SCI_FAST_LIST_ELEMENT_T;
|
|
|
|
|
|
/**
|
|
* Insert an element to be the new head of the list hanging off of the list
|
|
* anchor. An empty list has the list anchor pointing to itself.
|
|
* dListAnchor - The name of the SCI_FAST_LIST_T element that is the anchor
|
|
* of the queue.
|
|
* dListFieldBeingInserted - The SCI_FAST_LIST_T field in the data structure
|
|
* being queued. This SCI_FAST_LIST will become
|
|
* the new list head.
|
|
*/
|
|
INLINE
|
|
static void sci_fast_list_insert_head(
|
|
SCI_FAST_LIST_T *anchor,
|
|
SCI_FAST_LIST_ELEMENT_T *element
|
|
)
|
|
{
|
|
element->owning_list = anchor;
|
|
element->prev = NULL;
|
|
if ( anchor->list_head == NULL )
|
|
anchor->list_tail = element;
|
|
else
|
|
anchor->list_head->prev = element;
|
|
element->next = anchor->list_head;
|
|
anchor->list_head = element;
|
|
anchor->element_count++;
|
|
}
|
|
|
|
/**
|
|
* Insert an element at the tail of the list. Since the list is circular we
|
|
* can add the element at the tail through use the list anchors previous
|
|
* pointer.
|
|
* dListAnchor - The name of the SCI_FAST_LIST_T element that is the anchor
|
|
* of the queue.
|
|
* dListFieldBeingInserted - The SCI_FAST_LIST_T field in the data structure
|
|
* being queued. This SCI_FAST_LIST will become
|
|
* the new list head.
|
|
*/
|
|
INLINE
|
|
static void sci_fast_list_insert_tail(
|
|
SCI_FAST_LIST_T *anchor,
|
|
SCI_FAST_LIST_ELEMENT_T *element
|
|
)
|
|
{
|
|
element->owning_list = anchor;
|
|
element->next = NULL;
|
|
if ( anchor->list_tail == NULL ) {
|
|
anchor->list_head = element;
|
|
} else {
|
|
anchor->list_tail->next = element;
|
|
}
|
|
element->prev = anchor->list_tail;
|
|
anchor->list_tail = element;
|
|
anchor->element_count++;
|
|
}
|
|
|
|
/**
|
|
* This method will remove a dListFieldName from the head of the list.
|
|
*
|
|
* NOTE: This macro will always return a value, even if the list is empty.
|
|
* You must insure the list is not empty or use Dlist_safeRemoveHead.
|
|
*
|
|
* element - A pointer into which to save the address of the structure
|
|
* containing the SCI_FAST_LIST at the list head.
|
|
*/
|
|
INLINE
|
|
static void *sci_fast_list_remove_head(
|
|
SCI_FAST_LIST_T *anchor
|
|
)
|
|
{
|
|
void *object = NULL;
|
|
SCI_FAST_LIST_ELEMENT_T *element;
|
|
if ( anchor->list_head != NULL )
|
|
{
|
|
element = anchor->list_head;
|
|
object = anchor->list_head->object;
|
|
anchor->list_head = anchor->list_head->next;
|
|
if ( anchor->list_head == NULL )
|
|
{
|
|
anchor->list_tail = NULL;
|
|
}
|
|
anchor->element_count--;
|
|
element->next = element->prev = NULL;
|
|
element->owning_list = NULL;
|
|
}
|
|
return object;
|
|
}
|
|
|
|
INLINE
|
|
static void *sci_fast_list_remove_tail(
|
|
SCI_FAST_LIST_T *anchor
|
|
)
|
|
{
|
|
void *object = NULL;
|
|
SCI_FAST_LIST_ELEMENT_T *element;
|
|
if ( anchor->list_tail != NULL )
|
|
{
|
|
element = anchor->list_tail;
|
|
object = element->object;
|
|
anchor->list_tail = element->prev;
|
|
if ( anchor->list_tail == NULL )
|
|
anchor->list_head = NULL;
|
|
anchor->element_count--;
|
|
element->next = element->prev = NULL;
|
|
element->owning_list = NULL;
|
|
}
|
|
return object;
|
|
}
|
|
|
|
/**
|
|
* Remove an element from anywhere in the list referenced by name.
|
|
*/
|
|
INLINE
|
|
static void sci_fast_list_remove_element(
|
|
SCI_FAST_LIST_ELEMENT_T *element
|
|
)
|
|
{
|
|
if ( element->next == NULL )
|
|
element->owning_list->list_tail = element->prev;
|
|
else
|
|
element->next->prev = element->prev;
|
|
|
|
if ( element->prev == NULL )
|
|
element->owning_list->list_head = element->next;
|
|
else
|
|
element->prev->next = element->next;
|
|
|
|
element->owning_list->element_count--;
|
|
element->next = element->prev = NULL;
|
|
element->owning_list = NULL;
|
|
}
|
|
|
|
#endif // _SCI_FAST_LIST_HEADER_
|