← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/egl/main/eglarray.c

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/egl/main/eglarray.c
1
 
/**************************************************************************
2
 
 *
3
 
 * Copyright 2010 LunarG, Inc.
4
 
 * All Rights Reserved.
5
 
 *
6
 
 * Permission is hereby granted, free of charge, to any person obtaining a
7
 
 * copy of this software and associated documentation files (the
8
 
 * "Software"), to deal in the Software without restriction, including
9
 
 * without limitation the rights to use, copy, modify, merge, publish,
10
 
 * distribute, sub license, and/or sell copies of the Software, and to
11
 
 * permit persons to whom the Software is furnished to do so, subject to
12
 
 * the following conditions:
13
 
 *
14
 
 * The above copyright notice and this permission notice (including the
15
 
 * next paragraph) shall be included in all copies or substantial portions
16
 
 * of the Software.
17
 
 *
18
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19
 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20
 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
21
 
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22
 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
23
 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
24
 
 * DEALINGS IN THE SOFTWARE.
25
 
 *
26
 
 **************************************************************************/
27
 
 
28
 
 
29
 
#include <assert.h>
30
 
#include <stdlib.h>
31
 
#include <string.h>
32
 
 
33
 
#include "egllog.h"
34
 
#include "eglarray.h"
35
 
 
36
 
 
37
 
/**
38
 
 * Grow the size of the array.
39
 
 */
40
 
static EGLBoolean
41
 
_eglGrowArray(_EGLArray *array)
42
 
{
43
 
   EGLint new_size;
44
 
   void **elems;
45
 
 
46
 
   new_size = array->MaxSize;
47
 
   while (new_size <= array->Size)
48
 
      new_size *= 2;
49
 
 
50
 
   elems = realloc(array->Elements, new_size * sizeof(array->Elements[0]));
51
 
   if (!elems) {
52
 
      _eglLog(_EGL_DEBUG, "failed to grow %s array to %d",
53
 
            array->Name, new_size);
54
 
      return EGL_FALSE;
55
 
   }
56
 
 
57
 
   array->Elements = elems;
58
 
   array->MaxSize = new_size;
59
 
 
60
 
   return EGL_TRUE;
61
 
}
62
 
 
63
 
 
64
 
/**
65
 
 * Create an array.
66
 
 */
67
 
_EGLArray *
68
 
_eglCreateArray(const char *name, EGLint init_size)
69
 
{
70
 
   _EGLArray *array;
71
 
 
72
 
   array = calloc(1, sizeof(*array));
73
 
   if (array) {
74
 
      array->Name = name;
75
 
      array->MaxSize = (init_size > 0) ? init_size : 1;
76
 
      if (!_eglGrowArray(array)) {
77
 
         free(array);
78
 
         array = NULL;
79
 
      }
80
 
   }
81
 
 
82
 
   return array;
83
 
}
84
 
 
85
 
 
86
 
/**
87
 
 * Destroy an array, optionally free the data.
88
 
 */
89
 
void
90
 
_eglDestroyArray(_EGLArray *array, void (*free_cb)(void *))
91
 
{
92
 
   if (free_cb) {
93
 
      EGLint i;
94
 
      for (i = 0; i < array->Size; i++)
95
 
         free_cb(array->Elements[i]);
96
 
   }
97
 
   free(array->Elements);
98
 
   free(array);
99
 
}
100
 
 
101
 
 
102
 
/**
103
 
 * Append a element to an array.
104
 
 */
105
 
void
106
 
_eglAppendArray(_EGLArray *array, void *elem)
107
 
{
108
 
   if (array->Size >= array->MaxSize && !_eglGrowArray(array))
109
 
      return;
110
 
 
111
 
   array->Elements[array->Size++] = elem;
112
 
}
113
 
 
114
 
 
115
 
/**
116
 
 * Erase an element from an array.
117
 
 */
118
 
void
119
 
_eglEraseArray(_EGLArray *array, EGLint i, void (*free_cb)(void *))
120
 
{
121
 
   if (free_cb)
122
 
      free_cb(array->Elements[i]);
123
 
   if (i < array->Size - 1) {
124
 
      memmove(&array->Elements[i], &array->Elements[i + 1],
125
 
            (array->Size - i - 1) * sizeof(array->Elements[0]));
126
 
   }
127
 
   array->Size--;
128
 
}
129
 
 
130
 
 
131
 
/**
132
 
 * Find in an array for the given element.
133
 
 */
134
 
void *
135
 
_eglFindArray(_EGLArray *array, void *elem)
136
 
{
137
 
   EGLint i;
138
 
 
139
 
   if (!array)
140
 
      return NULL;
141
 
 
142
 
   for (i = 0; i < array->Size; i++)
143
 
      if (array->Elements[i] == elem)
144
 
         return elem;
145
 
   return NULL;
146
 
}
147
 
 
148
 
 
149
 
/**
150
 
 * Filter an array and return the number of filtered elements.
151
 
 */
152
 
EGLint
153
 
_eglFilterArray(_EGLArray *array, void **data, EGLint size,
154
 
                _EGLArrayForEach filter, void *filter_data)
155
 
{
156
 
   EGLint count = 0, i;
157
 
 
158
 
   if (!array)
159
 
      return 0;
160
 
 
161
 
   assert(filter);
162
 
   for (i = 0; i < array->Size; i++) {
163
 
      if (filter(array->Elements[i], filter_data)) {
164
 
         if (data && count < size)
165
 
            data[count] = array->Elements[i];
166
 
         count++;
167
 
      }
168
 
      if (data && count >= size)
169
 
         break;
170
 
   }
171
 
 
172
 
   return count;
173
 
}
174
 
 
175
 
 
176
 
/**
177
 
 * Flatten an array by converting array elements into another form and store
178
 
 * them in a buffer.
179
 
 */
180
 
EGLint
181
 
_eglFlattenArray(_EGLArray *array, void *buffer, EGLint elem_size, EGLint size,
182
 
                 _EGLArrayForEach flatten)
183
 
{
184
 
   EGLint i, count;
185
 
 
186
 
   if (!array)
187
 
      return 0;
188
 
 
189
 
   count = array->Size;
190
 
   if (buffer) {
191
 
      /* clamp size to 0 */
192
 
      if (size < 0)
193
 
         size = 0;
194
 
      /* do not exceed buffer size */
195
 
      if (count > size)
196
 
         count = size;
197
 
      for (i = 0; i < count; i++)
198
 
         flatten(array->Elements[i],
199
 
               (void *) ((char *) buffer + elem_size * i));
200
 
   }
201
 
 
202
 
   return count;
203
 
}