src/fe_utils/simple_list.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * Simple list facilities for frontend code
   4  *
   5  * Data structures for simple lists of OIDs and strings.  The support for
   6  * these is very primitive compared to the backend's List facilities, but
   7  * it's all we need in, eg, pg_dump.
   8  *
   9  *
  10  * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
  11  * Portions Copyright (c) 1994, Regents of the University of California
  12  *
  13  * src/fe_utils/simple_list.c
  14  *
  15  *-------------------------------------------------------------------------
  16  */
  17 #include "postgres_fe.h"
  18
  19 #include "fe_utils/simple_list.h"
  20
  21
  22 /*
  23  * Append an OID to the list.
  24  */
  25 void
  26 simple_oid_list_append(SimpleOidList *list, Oid val)
  27 {
  28         SimpleOidListCell *cell;
  29
  30         cell = (SimpleOidListCell *) pg_malloc(sizeof(SimpleOidListCell));
  31         cell->next = NULL;
  32         cell->val = val;
  33
  34         if (list->tail)
  35                 list->tail->next = cell;
  36         else
  37                 list->head = cell;
  38         list->tail = cell;
  39 }
  40
  41 /*
  42  * Is OID present in the list?
  43  */
  44 bool
  45 simple_oid_list_member(SimpleOidList *list, Oid val)
  46 {
  47         SimpleOidListCell *cell;
  48
  49         for (cell = list->head; cell; cell = cell->next)
  50         {
  51                 if (cell->val == val)
  52                         return true;
  53         }
  54         return false;
  55 }
  56
  57 /*
  58  * Append a string to the list.
  59  *
  60  * The given string is copied, so it need not survive past the call.
  61  */
  62 void
  63 simple_string_list_append(SimpleStringList *list, const char *val)
  64 {
  65         SimpleStringListCell *cell;
  66
  67         cell = (SimpleStringListCell *)
  68                 pg_malloc(offsetof(SimpleStringListCell, val) + strlen(val) + 1);
  69
  70         cell->next = NULL;
  71         cell->touched = false;
  72         strcpy(cell->val, val);
  73
  74         if (list->tail)
  75                 list->tail->next = cell;
  76         else
  77                 list->head = cell;
  78         list->tail = cell;
  79 }
  80
  81 /*
  82  * Is string present in the list?
  83  *
  84  * If found, the "touched" field of the first match is set true.
  85  */
  86 bool
  87 simple_string_list_member(SimpleStringList *list, const char *val)
  88 {
  89         SimpleStringListCell *cell;
  90
  91         for (cell = list->head; cell; cell = cell->next)
  92         {
  93                 if (strcmp(cell->val, val) == 0)
  94                 {
  95                         cell->touched = true;
  96                         return true;
  97                 }
  98         }
  99         return false;
 100 }
 101
 102 /*
 103  * Destroy an OID list
 104  */
 105 void
 106 simple_oid_list_destroy(SimpleOidList *list)
 107 {
 108         SimpleOidListCell *cell;
 109
 110         cell = list->head;
 111         while (cell != NULL)
 112         {
 113                 SimpleOidListCell *next;
 114
 115                 next = cell->next;
 116                 pg_free(cell);
 117                 cell = next;
 118         }
 119 }
 120
 121 /*
 122  * Destroy a string list
 123  */
 124 void
 125 simple_string_list_destroy(SimpleStringList *list)
 126 {
 127         SimpleStringListCell *cell;
 128
 129         cell = list->head;
 130         while (cell != NULL)
 131         {
 132                 SimpleStringListCell *next;
 133
 134                 next = cell->next;
 135                 pg_free(cell);
 136                 cell = next;
 137         }
 138 }
 139
 140 /*
 141  * Find first not-touched list entry, if there is one.
 142  */
 143 const char *
 144 simple_string_list_not_touched(SimpleStringList *list)
 145 {
 146         SimpleStringListCell *cell;
 147
 148         for (cell = list->head; cell; cell = cell->next)
 149         {
 150                 if (!cell->touched)
 151                         return cell->val;
 152         }
 153         return NULL;
 154 }
 155
 156 /*
 157  * Append a pointer to the list.
 158  *
 159  * Caller must ensure that the pointer remains valid.
 160  */
 161 void
 162 simple_ptr_list_append(SimplePtrList *list, void *ptr)
 163 {
 164         SimplePtrListCell *cell;
 165
 166         cell = (SimplePtrListCell *) pg_malloc(sizeof(SimplePtrListCell));
 167         cell->next = NULL;
 168         cell->ptr = ptr;
 169
 170         if (list->tail)
 171                 list->tail->next = cell;
 172         else
 173                 list->head = cell;
 174         list->tail = cell;
 175 }