LCOV - code coverage report
Current view: top level - src/include/nodes - pg_list.h (source / functions) Hit Total Coverage
Test: test.info Lines: 1 1 100.0 %
Date: 2013-01-22 Functions: 0 0 -
Branches: 11 20 55.0 %

           Branch data     Line data    Source code
       1                 :            : /*-------------------------------------------------------------------------
       2                 :            :  *
       3                 :            :  * pg_list.h
       4                 :            :  *        interface for PostgreSQL generic linked list package
       5                 :            :  *
       6                 :            :  * This package implements singly-linked homogeneous lists.
       7                 :            :  *
       8                 :            :  * It is important to have constant-time length, append, and prepend
       9                 :            :  * operations. To achieve this, we deal with two distinct data
      10                 :            :  * structures:
      11                 :            :  *
      12                 :            :  *              1. A set of "list cells": each cell contains a data field and
      13                 :            :  *                 a link to the next cell in the list or NULL.
      14                 :            :  *              2. A single structure containing metadata about the list: the
      15                 :            :  *                 type of the list, pointers to the head and tail cells, and
      16                 :            :  *                 the length of the list.
      17                 :            :  *
      18                 :            :  * We support three types of lists:
      19                 :            :  *
      20                 :            :  *      T_List: lists of pointers
      21                 :            :  *              (in practice usually pointers to Nodes, but not always;
      22                 :            :  *              declared as "void *" to minimize casting annoyances)
      23                 :            :  *      T_IntList: lists of integers
      24                 :            :  *      T_OidList: lists of Oids
      25                 :            :  *
      26                 :            :  * (At the moment, ints and Oids are the same size, but they may not
      27                 :            :  * always be so; try to be careful to maintain the distinction.)
      28                 :            :  *
      29                 :            :  *
      30                 :            :  * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
      31                 :            :  * Portions Copyright (c) 1994, Regents of the University of California
      32                 :            :  *
      33                 :            :  * src/include/nodes/pg_list.h
      34                 :            :  *
      35                 :            :  *-------------------------------------------------------------------------
      36                 :            :  */
      37                 :            : #ifndef PG_LIST_H
      38                 :            : #define PG_LIST_H
      39                 :            : 
      40                 :            : #include "nodes/nodes.h"
      41                 :            : 
      42                 :            : 
      43                 :            : typedef struct ListCell ListCell;
      44                 :            : 
      45                 :            : typedef struct List
      46                 :            : {
      47                 :            :         NodeTag         type;                   /* T_List, T_IntList, or T_OidList */
      48                 :            :         int                     length;
      49                 :            :         ListCell   *head;
      50                 :            :         ListCell   *tail;
      51                 :            : } List;
      52                 :            : 
      53                 :            : struct ListCell
      54                 :            : {
      55                 :            :         union
      56                 :            :         {
      57                 :            :                 void       *ptr_value;
      58                 :            :                 int                     int_value;
      59                 :            :                 Oid                     oid_value;
      60                 :            :         }                       data;
      61                 :            :         ListCell   *next;
      62                 :            : };
      63                 :            : 
      64                 :            : /*
      65                 :            :  * The *only* valid representation of an empty list is NIL; in other
      66                 :            :  * words, a non-NIL list is guaranteed to have length >= 1 and
      67                 :            :  * head/tail != NULL
      68                 :            :  */
      69                 :            : #define NIL                                             ((List *) NULL)
      70                 :            : 
      71                 :            : /*
      72                 :            :  * These routines are used frequently. However, we can't implement
      73                 :            :  * them as macros, since we want to avoid double-evaluation of macro
      74                 :            :  * arguments. Therefore, we implement them using static inline functions
      75                 :            :  * if supported by the compiler, or as regular functions otherwise.
      76                 :            :  * See STATIC_IF_INLINE in c.h.
      77                 :            :  */
      78                 :            : #ifndef PG_USE_INLINE
      79                 :            : extern ListCell *list_head(const List *l);
      80                 :            : extern ListCell *list_tail(List *l);
      81                 :            : extern int      list_length(const List *l);
      82                 :            : #endif   /* PG_USE_INLINE */
      83                 :            : #if defined(PG_USE_INLINE) || defined(PG_LIST_INCLUDE_DEFINITIONS)
      84                 :            : STATIC_IF_INLINE ListCell *
      85                 :            : list_head(const List *l)
      86                 :            : {
      87 [ +  + ][ +  + ]:        412 :         return l ? l->head : NULL;
         [ +  + ][ #  # ]
         [ #  # ][ #  # ]
         [ +  - ][ +  - ]
         [ +  - ][ +  + ]
      88                 :            : }
      89                 :            : 
      90                 :            : STATIC_IF_INLINE ListCell *
      91                 :            : list_tail(List *l)
      92                 :            : {
      93                 :            :         return l ? l->tail : NULL;
      94                 :            : }
      95                 :            : 
      96                 :            : STATIC_IF_INLINE int
      97                 :            : list_length(const List *l)
      98                 :            : {
      99                 :            :         return l ? l->length : 0;
     100                 :            : }
     101                 :            : #endif   /*-- PG_USE_INLINE || PG_LIST_INCLUDE_DEFINITIONS */
     102                 :            : 
     103                 :            : /*
     104                 :            :  * NB: There is an unfortunate legacy from a previous incarnation of
     105                 :            :  * the List API: the macro lfirst() was used to mean "the data in this
     106                 :            :  * cons cell". To avoid changing every usage of lfirst(), that meaning
     107                 :            :  * has been kept. As a result, lfirst() takes a ListCell and returns
     108                 :            :  * the data it contains; to get the data in the first cell of a
     109                 :            :  * List, use linitial(). Worse, lsecond() is more closely related to
     110                 :            :  * linitial() than lfirst(): given a List, lsecond() returns the data
     111                 :            :  * in the second cons cell.
     112                 :            :  */
     113                 :            : 
     114                 :            : #define lnext(lc)                               ((lc)->next)
     115                 :            : #define lfirst(lc)                              ((lc)->data.ptr_value)
     116                 :            : #define lfirst_int(lc)                  ((lc)->data.int_value)
     117                 :            : #define lfirst_oid(lc)                  ((lc)->data.oid_value)
     118                 :            : 
     119                 :            : #define linitial(l)                             lfirst(list_head(l))
     120                 :            : #define linitial_int(l)                 lfirst_int(list_head(l))
     121                 :            : #define linitial_oid(l)                 lfirst_oid(list_head(l))
     122                 :            : 
     123                 :            : #define lsecond(l)                              lfirst(lnext(list_head(l)))
     124                 :            : #define lsecond_int(l)                  lfirst_int(lnext(list_head(l)))
     125                 :            : #define lsecond_oid(l)                  lfirst_oid(lnext(list_head(l)))
     126                 :            : 
     127                 :            : #define lthird(l)                               lfirst(lnext(lnext(list_head(l))))
     128                 :            : #define lthird_int(l)                   lfirst_int(lnext(lnext(list_head(l))))
     129                 :            : #define lthird_oid(l)                   lfirst_oid(lnext(lnext(list_head(l))))
     130                 :            : 
     131                 :            : #define lfourth(l)                              lfirst(lnext(lnext(lnext(list_head(l)))))
     132                 :            : #define lfourth_int(l)                  lfirst_int(lnext(lnext(lnext(list_head(l)))))
     133                 :            : #define lfourth_oid(l)                  lfirst_oid(lnext(lnext(lnext(list_head(l)))))
     134                 :            : 
     135                 :            : #define llast(l)                                lfirst(list_tail(l))
     136                 :            : #define llast_int(l)                    lfirst_int(list_tail(l))
     137                 :            : #define llast_oid(l)                    lfirst_oid(list_tail(l))
     138                 :            : 
     139                 :            : /*
     140                 :            :  * Convenience macros for building fixed-length lists
     141                 :            :  */
     142                 :            : #define list_make1(x1)                          lcons(x1, NIL)
     143                 :            : #define list_make2(x1,x2)                       lcons(x1, list_make1(x2))
     144                 :            : #define list_make3(x1,x2,x3)            lcons(x1, list_make2(x2, x3))
     145                 :            : #define list_make4(x1,x2,x3,x4)         lcons(x1, list_make3(x2, x3, x4))
     146                 :            : 
     147                 :            : #define list_make1_int(x1)                      lcons_int(x1, NIL)
     148                 :            : #define list_make2_int(x1,x2)           lcons_int(x1, list_make1_int(x2))
     149                 :            : #define list_make3_int(x1,x2,x3)        lcons_int(x1, list_make2_int(x2, x3))
     150                 :            : #define list_make4_int(x1,x2,x3,x4) lcons_int(x1, list_make3_int(x2, x3, x4))
     151                 :            : 
     152                 :            : #define list_make1_oid(x1)                      lcons_oid(x1, NIL)
     153                 :            : #define list_make2_oid(x1,x2)           lcons_oid(x1, list_make1_oid(x2))
     154                 :            : #define list_make3_oid(x1,x2,x3)        lcons_oid(x1, list_make2_oid(x2, x3))
     155                 :            : #define list_make4_oid(x1,x2,x3,x4) lcons_oid(x1, list_make3_oid(x2, x3, x4))
     156                 :            : 
     157                 :            : /*
     158                 :            :  * foreach -
     159                 :            :  *        a convenience macro which loops through the list
     160                 :            :  */
     161                 :            : #define foreach(cell, l)        \
     162                 :            :         for ((cell) = list_head(l); (cell) != NULL; (cell) = lnext(cell))
     163                 :            : 
     164                 :            : /*
     165                 :            :  * for_each_cell -
     166                 :            :  *        a convenience macro which loops through a list starting from a
     167                 :            :  *        specified cell
     168                 :            :  */
     169                 :            : #define for_each_cell(cell, initcell)   \
     170                 :            :         for ((cell) = (initcell); (cell) != NULL; (cell) = lnext(cell))
     171                 :            : 
     172                 :            : /*
     173                 :            :  * forboth -
     174                 :            :  *        a convenience macro for advancing through two linked lists
     175                 :            :  *        simultaneously. This macro loops through both lists at the same
     176                 :            :  *        time, stopping when either list runs out of elements. Depending
     177                 :            :  *        on the requirements of the call site, it may also be wise to
     178                 :            :  *        assert that the lengths of the two lists are equal.
     179                 :            :  */
     180                 :            : #define forboth(cell1, list1, cell2, list2)                                                     \
     181                 :            :         for ((cell1) = list_head(list1), (cell2) = list_head(list2);    \
     182                 :            :                  (cell1) != NULL && (cell2) != NULL;                                            \
     183                 :            :                  (cell1) = lnext(cell1), (cell2) = lnext(cell2))
     184                 :            : 
     185                 :            : /*
     186                 :            :  * forthree -
     187                 :            :  *        the same for three lists
     188                 :            :  */
     189                 :            : #define forthree(cell1, list1, cell2, list2, cell3, list3)                      \
     190                 :            :         for ((cell1) = list_head(list1), (cell2) = list_head(list2), (cell3) = list_head(list3); \
     191                 :            :                  (cell1) != NULL && (cell2) != NULL && (cell3) != NULL;         \
     192                 :            :                  (cell1) = lnext(cell1), (cell2) = lnext(cell2), (cell3) = lnext(cell3))
     193                 :            : 
     194                 :            : extern List *lappend(List *list, void *datum);
     195                 :            : extern List *lappend_int(List *list, int datum);
     196                 :            : extern List *lappend_oid(List *list, Oid datum);
     197                 :            : 
     198                 :            : extern ListCell *lappend_cell(List *list, ListCell *prev, void *datum);
     199                 :            : extern ListCell *lappend_cell_int(List *list, ListCell *prev, int datum);
     200                 :            : extern ListCell *lappend_cell_oid(List *list, ListCell *prev, Oid datum);
     201                 :            : 
     202                 :            : extern List *lcons(void *datum, List *list);
     203                 :            : extern List *lcons_int(int datum, List *list);
     204                 :            : extern List *lcons_oid(Oid datum, List *list);
     205                 :            : 
     206                 :            : extern List *list_concat(List *list1, List *list2);
     207                 :            : extern List *list_truncate(List *list, int new_size);
     208                 :            : 
     209                 :            : extern void *list_nth(const List *list, int n);
     210                 :            : extern int      list_nth_int(const List *list, int n);
     211                 :            : extern Oid      list_nth_oid(const List *list, int n);
     212                 :            : 
     213                 :            : extern bool list_member(const List *list, const void *datum);
     214                 :            : extern bool list_member_ptr(const List *list, const void *datum);
     215                 :            : extern bool list_member_int(const List *list, int datum);
     216                 :            : extern bool list_member_oid(const List *list, Oid datum);
     217                 :            : 
     218                 :            : extern List *list_delete(List *list, void *datum);
     219                 :            : extern List *list_delete_ptr(List *list, void *datum);
     220                 :            : extern List *list_delete_int(List *list, int datum);
     221                 :            : extern List *list_delete_oid(List *list, Oid datum);
     222                 :            : extern List *list_delete_first(List *list);
     223                 :            : extern List *list_delete_cell(List *list, ListCell *cell, ListCell *prev);
     224                 :            : 
     225                 :            : extern List *list_union(const List *list1, const List *list2);
     226                 :            : extern List *list_union_ptr(const List *list1, const List *list2);
     227                 :            : extern List *list_union_int(const List *list1, const List *list2);
     228                 :            : extern List *list_union_oid(const List *list1, const List *list2);
     229                 :            : 
     230                 :            : extern List *list_intersection(const List *list1, const List *list2);
     231                 :            : 
     232                 :            : /* currently, there's no need for list_intersection_int etc */
     233                 :            : 
     234                 :            : extern List *list_difference(const List *list1, const List *list2);
     235                 :            : extern List *list_difference_ptr(const List *list1, const List *list2);
     236                 :            : extern List *list_difference_int(const List *list1, const List *list2);
     237                 :            : extern List *list_difference_oid(const List *list1, const List *list2);
     238                 :            : 
     239                 :            : extern List *list_append_unique(List *list, void *datum);
     240                 :            : extern List *list_append_unique_ptr(List *list, void *datum);
     241                 :            : extern List *list_append_unique_int(List *list, int datum);
     242                 :            : extern List *list_append_unique_oid(List *list, Oid datum);
     243                 :            : 
     244                 :            : extern List *list_concat_unique(List *list1, List *list2);
     245                 :            : extern List *list_concat_unique_ptr(List *list1, List *list2);
     246                 :            : extern List *list_concat_unique_int(List *list1, List *list2);
     247                 :            : extern List *list_concat_unique_oid(List *list1, List *list2);
     248                 :            : 
     249                 :            : extern void list_free(List *list);
     250                 :            : extern void list_free_deep(List *list);
     251                 :            : 
     252                 :            : extern List *list_copy(const List *list);
     253                 :            : extern List *list_copy_tail(const List *list, int nskip);
     254                 :            : 
     255                 :            : /*
     256                 :            :  * To ease migration to the new list API, a set of compatibility
     257                 :            :  * macros are provided that reduce the impact of the list API changes
     258                 :            :  * as far as possible. Until client code has been rewritten to use the
     259                 :            :  * new list API, the ENABLE_LIST_COMPAT symbol can be defined before
     260                 :            :  * including pg_list.h
     261                 :            :  */
     262                 :            : #ifdef ENABLE_LIST_COMPAT
     263                 :            : 
     264                 :            : #define lfirsti(lc)                                     lfirst_int(lc)
     265                 :            : #define lfirsto(lc)                                     lfirst_oid(lc)
     266                 :            : 
     267                 :            : #define makeList1(x1)                           list_make1(x1)
     268                 :            : #define makeList2(x1, x2)                       list_make2(x1, x2)
     269                 :            : #define makeList3(x1, x2, x3)           list_make3(x1, x2, x3)
     270                 :            : #define makeList4(x1, x2, x3, x4)       list_make4(x1, x2, x3, x4)
     271                 :            : 
     272                 :            : #define makeListi1(x1)                          list_make1_int(x1)
     273                 :            : #define makeListi2(x1, x2)                      list_make2_int(x1, x2)
     274                 :            : 
     275                 :            : #define makeListo1(x1)                          list_make1_oid(x1)
     276                 :            : #define makeListo2(x1, x2)                      list_make2_oid(x1, x2)
     277                 :            : 
     278                 :            : #define lconsi(datum, list)                     lcons_int(datum, list)
     279                 :            : #define lconso(datum, list)                     lcons_oid(datum, list)
     280                 :            : 
     281                 :            : #define lappendi(list, datum)           lappend_int(list, datum)
     282                 :            : #define lappendo(list, datum)           lappend_oid(list, datum)
     283                 :            : 
     284                 :            : #define nconc(l1, l2)                           list_concat(l1, l2)
     285                 :            : 
     286                 :            : #define nth(n, list)                            list_nth(list, n)
     287                 :            : 
     288                 :            : #define member(datum, list)                     list_member(list, datum)
     289                 :            : #define ptrMember(datum, list)          list_member_ptr(list, datum)
     290                 :            : #define intMember(datum, list)          list_member_int(list, datum)
     291                 :            : #define oidMember(datum, list)          list_member_oid(list, datum)
     292                 :            : 
     293                 :            : /*
     294                 :            :  * Note that the old lremove() determined equality via pointer
     295                 :            :  * comparison, whereas the new list_delete() uses equal(); in order to
     296                 :            :  * keep the same behavior, we therefore need to map lremove() calls to
     297                 :            :  * list_delete_ptr() rather than list_delete()
     298                 :            :  */
     299                 :            : #define lremove(elem, list)                     list_delete_ptr(list, elem)
     300                 :            : #define LispRemove(elem, list)          list_delete(list, elem)
     301                 :            : #define lremovei(elem, list)            list_delete_int(list, elem)
     302                 :            : #define lremoveo(elem, list)            list_delete_oid(list, elem)
     303                 :            : 
     304                 :            : #define ltruncate(n, list)                      list_truncate(list, n)
     305                 :            : 
     306                 :            : #define set_union(l1, l2)                       list_union(l1, l2)
     307                 :            : #define set_uniono(l1, l2)                      list_union_oid(l1, l2)
     308                 :            : #define set_ptrUnion(l1, l2)            list_union_ptr(l1, l2)
     309                 :            : 
     310                 :            : #define set_difference(l1, l2)          list_difference(l1, l2)
     311                 :            : #define set_differenceo(l1, l2)         list_difference_oid(l1, l2)
     312                 :            : #define set_ptrDifference(l1, l2)       list_difference_ptr(l1, l2)
     313                 :            : 
     314                 :            : #define equali(l1, l2)                          equal(l1, l2)
     315                 :            : #define equalo(l1, l2)                          equal(l1, l2)
     316                 :            : 
     317                 :            : #define freeList(list)                          list_free(list)
     318                 :            : 
     319                 :            : #define listCopy(list)                          list_copy(list)
     320                 :            : 
     321                 :            : extern int      length(List *list);
     322                 :            : #endif   /* ENABLE_LIST_COMPAT */
     323                 :            : 
     324                 :            : #endif   /* PG_LIST_H */

Generated by: LCOV version 1.9