/usr/include/pj/list.h is in libpjproject-dev 2.1.0.0.ast20130823-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 | /* $Id: list.h 3553 2011-05-05 06:14:19Z nanang $ */
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_LIST_H__
#define __PJ_LIST_H__
/**
* @file list.h
* @brief Linked List data structure.
*/
#include <pj/types.h>
PJ_BEGIN_DECL
/*
* @defgroup PJ_DS Data Structure.
*/
/**
* @defgroup PJ_LIST Linked List
* @ingroup PJ_DS
* @{
*
* List in PJLIB is implemented as doubly-linked list, and it won't require
* dynamic memory allocation (just as all PJLIB data structures). The list here
* should be viewed more like a low level C list instead of high level C++ list
* (which normally are easier to use but require dynamic memory allocations),
* therefore all caveats with C list apply here too (such as you can NOT put
* a node in more than one lists).
*
* \section pj_list_example_sec Examples
*
* See below for examples on how to manipulate linked list:
* - @ref page_pjlib_samples_list_c
* - @ref page_pjlib_list_test
*/
/**
* Use this macro in the start of the structure declaration to declare that
* the structure can be used in the linked list operation. This macro simply
* declares additional member @a prev and @a next to the structure.
* @hideinitializer
*/
#define PJ_DECL_LIST_MEMBER(type) \
/** List @a prev. */ \
type *prev; \
/** List @a next. */ \
type *next
/**
* This structure describes generic list node and list. The owner of this list
* must initialize the 'value' member to an appropriate value (typically the
* owner itself).
*/
struct pj_list
{
PJ_DECL_LIST_MEMBER(void);
} PJ_ATTR_MAY_ALIAS; /* may_alias avoids warning with gcc-4.4 -Wall -O2 */
/**
* Initialize the list.
* Initially, the list will have no member, and function pj_list_empty() will
* always return nonzero (which indicates TRUE) for the newly initialized
* list.
*
* @param node The list head.
*/
PJ_INLINE(void) pj_list_init(pj_list_type * node)
{
((pj_list*)node)->next = ((pj_list*)node)->prev = node;
}
/**
* Check that the list is empty.
*
* @param node The list head.
*
* @return Non-zero if the list is empty, or zero if it is not empty.
*
*/
PJ_INLINE(int) pj_list_empty(const pj_list_type * node)
{
return ((pj_list*)node)->next == node;
}
/**
* Insert the node to the list before the specified element position.
*
* @param pos The element to which the node will be inserted before.
* @param node The element to be inserted.
*
* @return void.
*/
PJ_IDECL(void) pj_list_insert_before(pj_list_type *pos, pj_list_type *node);
/**
* Insert the node to the back of the list. This is just an alias for
* #pj_list_insert_before().
*
* @param list The list.
* @param node The element to be inserted.
*/
PJ_INLINE(void) pj_list_push_back(pj_list_type *list, pj_list_type *node)
{
pj_list_insert_before(list, node);
}
/**
* Inserts all nodes in \a nodes to the target list.
*
* @param lst The target list.
* @param nodes Nodes list.
*/
PJ_IDECL(void) pj_list_insert_nodes_before(pj_list_type *lst,
pj_list_type *nodes);
/**
* Insert a node to the list after the specified element position.
*
* @param pos The element in the list which will precede the inserted
* element.
* @param node The element to be inserted after the position element.
*
* @return void.
*/
PJ_IDECL(void) pj_list_insert_after(pj_list_type *pos, pj_list_type *node);
/**
* Insert the node to the front of the list. This is just an alias for
* #pj_list_insert_after().
*
* @param list The list.
* @param node The element to be inserted.
*/
PJ_INLINE(void) pj_list_push_front(pj_list_type *list, pj_list_type *node)
{
pj_list_insert_after(list, node);
}
/**
* Insert all nodes in \a nodes to the target list.
*
* @param lst The target list.
* @param nodes Nodes list.
*/
PJ_IDECL(void) pj_list_insert_nodes_after(pj_list_type *lst,
pj_list_type *nodes);
/**
* Remove elements from the source list, and insert them to the destination
* list. The elements of the source list will occupy the
* front elements of the target list. Note that the node pointed by \a list2
* itself is not considered as a node, but rather as the list descriptor, so
* it will not be inserted to the \a list1. The elements to be inserted starts
* at \a list2->next. If \a list2 is to be included in the operation, use
* \a pj_list_insert_nodes_before.
*
* @param list1 The destination list.
* @param list2 The source list.
*
* @return void.
*/
PJ_IDECL(void) pj_list_merge_first(pj_list_type *list1, pj_list_type *list2);
/**
* Remove elements from the second list argument, and insert them to the list
* in the first argument. The elements from the second list will be appended
* to the first list. Note that the node pointed by \a list2
* itself is not considered as a node, but rather as the list descriptor, so
* it will not be inserted to the \a list1. The elements to be inserted starts
* at \a list2->next. If \a list2 is to be included in the operation, use
* \a pj_list_insert_nodes_before.
*
* @param list1 The element in the list which will precede the inserted
* element.
* @param list2 The element in the list to be inserted.
*
* @return void.
*/
PJ_IDECL(void) pj_list_merge_last( pj_list_type *list1, pj_list_type *list2);
/**
* Erase the node from the list it currently belongs.
*
* @param node The element to be erased.
*/
PJ_IDECL(void) pj_list_erase(pj_list_type *node);
/**
* Find node in the list.
*
* @param list The list head.
* @param node The node element to be searched.
*
* @return The node itself if it is found in the list, or NULL if it is not
* found in the list.
*/
PJ_IDECL(pj_list_type*) pj_list_find_node(pj_list_type *list,
pj_list_type *node);
/**
* Search the list for the specified value, using the specified comparison
* function. This function iterates on nodes in the list, started with the
* first node, and call the user supplied comparison function until the
* comparison function returns ZERO.
*
* @param list The list head.
* @param value The user defined value to be passed in the comparison
* function
* @param comp The comparison function, which should return ZERO to
* indicate that the searched value is found.
*
* @return The first node that matched, or NULL if it is not found.
*/
PJ_IDECL(pj_list_type*) pj_list_search(pj_list_type *list, void *value,
int (*comp)(void *value,
const pj_list_type *node)
);
/**
* Traverse the list to get the number of elements in the list.
*
* @param list The list head.
*
* @return Number of elements.
*/
PJ_IDECL(pj_size_t) pj_list_size(const pj_list_type *list);
/**
* @}
*/
#if PJ_FUNCTIONS_ARE_INLINED
# include "list_i.h"
#endif
PJ_END_DECL
#endif /* __PJ_LIST_H__ */
|