source: lib/data-struct/linked_list.c @ ee6e802

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivendag_formatrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since ee6e802 was ee6e802, checked in by Shane Alcock <salcock@…>, 4 years ago

Updated copyright blurb on all source files

In some cases, this meant adding copyright blurbs to files that
had never had them before.

  • Property mode set to 100644
File size: 4.3 KB
Line 
1/*
2 *
3 * Copyright (c) 2007-2016 The University of Waikato, Hamilton, New Zealand.
4 * All rights reserved.
5 *
6 * This file is part of libtrace.
7 *
8 * This code has been developed by the University of Waikato WAND
9 * research group. For further information please see http://www.wand.net.nz/
10 *
11 * libtrace is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU Lesser General Public License as published by
13 * the Free Software Foundation; either version 3 of the License, or
14 * (at your option) any later version.
15 *
16 * libtrace is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 * GNU Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public License
22 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
23 *
24 *
25 */
26#include "linked_list.h"
27
28#include <assert.h>
29#include <stddef.h>
30#include <stdlib.h>
31#include <string.h>
32
33libtrace_list_t *libtrace_list_init(size_t element_size)
34{
35        libtrace_list_t *l = (libtrace_list_t *)malloc(sizeof(libtrace_list_t));
36        if (l == NULL)
37                return NULL;
38
39        memset(l, 0, sizeof(libtrace_list_t));
40        l->element_size = element_size;
41
42        return l;
43}
44
45void libtrace_list_deinit(libtrace_list_t *l)
46{
47        libtrace_list_node_t *tmp, *next;
48        if (l == NULL)
49                return;
50
51        tmp = l->head;
52        while (tmp != NULL) {
53                next = tmp->next;
54
55                if (tmp->data)
56                        free(tmp->data);
57                free(tmp);
58
59                tmp = next;
60        }
61
62        free(l);
63}
64
65void libtrace_list_push_front(libtrace_list_t *l, void *item)
66{
67        libtrace_list_node_t *new;
68
69        if (l == NULL || item == NULL)
70                return;
71
72        /* Create the new node */
73        new = (libtrace_list_node_t *)malloc(sizeof(libtrace_list_node_t));
74        assert(new != NULL);
75        new->data = malloc(l->element_size);
76        assert(new->data != NULL);
77
78        new->prev = NULL;
79        memcpy(new->data, item, l->element_size);
80
81        if (l->head == NULL) {
82                assert(l->tail == NULL && l->size == 0);
83                new->next = NULL;
84                l->head = l->tail = new;
85        } else {
86                l->head->prev = new;
87                new->next = l->head;
88                l->head = new;
89        }
90        l->size++;
91}
92
93void libtrace_list_push_back(libtrace_list_t *l, void *item)
94{
95        libtrace_list_node_t *new;
96
97        if (l == NULL || item == NULL)
98                return;
99
100        /* Create the new node */
101        new = (libtrace_list_node_t *)malloc(sizeof(libtrace_list_node_t));
102        assert(new != NULL);
103        new->data = malloc(l->element_size);
104        assert(new->data != NULL);
105
106        new->next = NULL;
107        memcpy(new->data, item, l->element_size);
108
109        if (l->tail == NULL) {
110                assert(l->head == NULL && l->size == 0);
111                new->prev = NULL;
112                l->head = l->tail = new;
113        } else {
114                l->tail->next = new;
115                new->prev = l->tail;
116                l->tail = new;
117        }
118        l->size++;
119}
120
121int libtrace_list_pop_front(libtrace_list_t *l, void *item)
122{
123        int ret = 0;
124        libtrace_list_node_t *n;
125
126        if (l == NULL || item == NULL)
127                return -1;
128
129        if (l->head != NULL) {
130                n = l->head;
131                ret = 1;
132
133                /* Relink the list */
134                l->head = l->head->next;
135                if (l->head)
136                        l->head->prev = NULL;
137                l->size--;
138                if (l->size <= 1)
139                        l->tail = l->head;
140        }
141
142        /* If we managed to pull a node out, copy the data and free the
143         * node */
144        if (ret) {
145                memcpy(item, n->data, l->element_size);
146                free(n->data);
147                free(n);
148        }
149
150        return ret;
151}
152
153int libtrace_list_pop_back(libtrace_list_t *l, void *item)
154{
155        int ret = 0;
156        libtrace_list_node_t *n;
157
158        if (l == NULL || item == NULL)
159                return -1;
160
161        if (l->tail != NULL) {
162                n = l->tail;
163                ret = 1;
164
165                /* Relink the list */
166                l->tail = l->tail->prev;
167                if (l->tail)
168                        l->tail->next = NULL;
169                l->size--;
170                if (l->size <= 1)
171                        l->head = l->tail;
172        }
173
174        /* If we managed to pull a node out, copy the data and free the
175         * node */
176        if (ret) {
177                memcpy(item, n->data, l->element_size);
178                free(n->data);
179                free(n);
180        }
181
182        return ret;
183}
184
185libtrace_list_node_t *libtrace_list_get_index(libtrace_list_t *list,
186                                              size_t index) {
187        libtrace_list_node_t *ret = list->head;
188
189        /* Ensure the index is within the list */
190        if (index >= list->size) {
191                printf("List index out of range\n");
192                return NULL;
193        }
194
195        /* Scan the list until we get to the desired index. We could be smart
196         * and scan from the top or the bottom depending on which is closer */
197        while (index--) {
198                ret = ret->next;
199                assert(ret != NULL);
200        }
201
202        return ret;
203}
204
205size_t libtrace_list_get_size(libtrace_list_t *l)
206{
207        if (l == NULL)
208                return 0;
209
210        return l->size;
211}
Note: See TracBrowser for help on using the repository browser.