libStatGen Software  1
MemoryAllocators.cpp
1 /*
2  * Copyright (C) 2010 Regents of the University of Michigan
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
16  */
17 
18 #include "MemoryAllocators.h"
19 
20 #include <stdlib.h>
21 
22 char *** AllocateCharCube(int n, int rows, int cols)
23 {
24  char *** cube = new char ** [n];
25 
26  // Stop early if we are out of memory
27  if (cube == NULL)
28  return NULL;
29 
30  for (int i = 0; i < n; i++)
31  {
32  cube[i] = AllocateCharMatrix(rows, cols);
33 
34  // Safely unravel allocation if we run out of memory
35  if (cube[i] == NULL)
36  {
37  while (i--)
38  FreeCharMatrix(cube[i], rows);
39 
40  delete [] cube;
41 
42  return NULL;
43  }
44  }
45 
46  return cube;
47 }
48 
49 int ** AllocateIntMatrix(int rows, int cols)
50 {
51  int ** matrix = new int * [rows];
52 
53  // Stop early if we are out of memory
54  if (matrix == NULL)
55  return NULL;
56 
57  for (int i = 0; i < rows; i++)
58  {
59  matrix[i] = new int [cols];
60 
61  // Safely unravel allocation if we run out of memory
62  if (matrix[i] == NULL)
63  {
64  while (i--)
65  delete [] matrix[i];
66 
67  delete [] matrix;
68 
69  return NULL;
70  }
71  }
72 
73  return matrix;
74 }
75 
76 char ** AllocateCharMatrix(int rows, int cols)
77 {
78  char ** matrix = new char * [rows];
79 
80  // Stop early if we are out of memory
81  if (matrix == NULL)
82  return NULL;
83 
84  for (int i = 0; i < rows; i++)
85  {
86  matrix[i] = new char [cols];
87 
88  // Safely unravel allocation if we run out of memory
89  if (matrix[i] == NULL)
90  {
91  while (i--)
92  delete [] matrix[i];
93 
94  delete [] matrix;
95 
96  return NULL;
97  }
98  }
99 
100  return matrix;
101 }
102 
103 float ** AllocateFloatMatrix(int rows, int cols)
104 {
105  float ** matrix = new float * [rows];
106 
107  // Stop early if we are out of memory
108  if (matrix == NULL)
109  return NULL;
110 
111  for (int i = 0; i < rows; i++)
112  {
113  matrix[i] = new float [cols];
114 
115  // Safely unravel allocation if we run out of memory
116  if (matrix[i] == NULL)
117  {
118  while (i--)
119  delete [] matrix[i];
120 
121  delete [] matrix;
122 
123  return NULL;
124  }
125  }
126 
127  return matrix;
128 }
129 
130 void FreeCharCube(char *** & cube, int n, int rows)
131 {
132  if (cube == NULL)
133  return;
134 
135  for (int i = 0; i < n; i++)
136  FreeCharMatrix(cube[i], rows);
137 
138  delete [] cube;
139 
140  cube = NULL;
141 }
142 
143 void FreeCharMatrix(char ** & matrix, int rows)
144 {
145  if (matrix == NULL)
146  return;
147 
148  for (int i = 0; i < rows; i++)
149  delete [] matrix[i];
150 
151  delete [] matrix;
152 
153  matrix = NULL;
154 }
155 
156 void FreeFloatMatrix(float ** & matrix, int rows)
157 {
158  if (matrix == NULL)
159  return;
160 
161  for (int i = 0; i < rows; i++)
162  delete [] matrix[i];
163 
164  delete [] matrix;
165 
166  matrix = NULL;
167 }
168 
169 void FreeIntMatrix(int ** & matrix, int rows)
170 {
171  if (matrix == NULL)
172  return;
173 
174  for (int i = 0; i < rows; i++)
175  delete [] matrix[i];
176 
177  delete [] matrix;
178 
179  matrix = NULL;
180 }
181 
182 short ** AllocateShortMatrix(int rows, int cols)
183 {
184  short ** matrix = new short * [rows];
185 
186  // Stop early if we are out of memory
187  if (matrix == NULL)
188  return NULL;
189 
190  for (int i = 0; i < rows; i++)
191  {
192  matrix[i] = new short [cols];
193 
194  // Safely unravel allocation if we run out of memory
195  if (matrix[i] == NULL)
196  {
197  while (i--)
198  delete [] matrix[i];
199 
200  delete [] matrix;
201 
202  return NULL;
203  }
204  }
205 
206  return matrix;
207 }
208 
209 void FreeShortMatrix(short ** & matrix, int rows)
210 {
211  if (matrix == NULL)
212  return;
213 
214  for (int i = 0; i < rows; i++)
215  delete [] matrix[i];
216 
217  delete [] matrix;
218 
219  matrix = NULL;
220 }
221 
222 double ** AllocateDoubleMatrix(int rows, int cols)
223 {
224  double ** matrix = new double * [rows];
225 
226  // Stop early if we are out of memory
227  if (matrix == NULL)
228  return NULL;
229 
230  for (int i = 0; i < rows; i++)
231  {
232  matrix[i] = new double [cols];
233 
234  // Safely unravel allocation if we run out of memory
235  if (matrix[i] == NULL)
236  {
237  while (i--)
238  delete [] matrix[i];
239 
240  delete [] matrix;
241 
242  return NULL;
243  }
244  }
245 
246  return matrix;
247 }
248 
249 void FreeDoubleMatrix(double ** & matrix, int rows)
250 {
251  for (int i = 0; i < rows; i++)
252  delete [] matrix[i];
253 
254  delete [] matrix;
255 
256  matrix = NULL;
257 }
258 
259