/simpletypesystem/trunk : contents of src/DynamicArray.c at revision 87

: (revision 87)

To get this branch, use:

bzr branch
http://gegoxaren.bato24.eu/bzr/simpletypesystem/trunk

/* c-basic-offset: 2; tab-width: 2; indent-tabs-mode: nil
 * vi: set shiftwidth=2 tabstop=2 expandtab:
 * :indentSize=2:tabSize=2:noTabs=true:
 */

/*
Copyright (c) 2013-2014 Gustav Hartvigsson

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

#include "DynamicArray.h"

struct
SDynamicArray {
  FreeFunc free_func;
  FuncPointer to_json;
  FuncPointer from_json;
  size_t max_size;
  size_t last_item;
  spointer * array;
};

void
_private_for_each_item_free (SDynamicArray * self, spointer item,
                             spointer data);

SDynamicArray *
_s_dynamic_array_new_full (size_t len,
                          FreeFunc free_func,
                          FuncPointer to_json,
                          FuncPointer from_json) {
  SDynamicArray * self = malloc (sizeof(SDynamicArray));
  
  self->max_size = len;
  
  self->last_item = 0;
  
  self->free_func = free_func;
  self->to_json = to_json;
  self->from_json = from_json;
  
  self->array = calloc (len ,sizeof (* self->array));
  
  return self;
}

SDynamicArray *
s_dynamic_array_new (size_t len,
                     FreeFunc free_func) {
  SDynamicArray * self = _s_dynamic_array_new_full (len, free_func, NULL, NULL);
  return self;
}

SDynamicArray *
s_dynamic_array_new_json (size_t len,
                          FreeFunc free_func,
                          FuncPointer to_json,
                          FuncPointer from_json) {
  SDynamicArray * self = _s_dynamic_array_new_full (len, free_func, to_json, from_json);
  return self;
}

void
s_dynamic_array_free (SDynamicArray * self, sboolean free_data) {
  if (free_data) {
    if (self->free_func != NULL) {
      s_dynamic_array_for_each (self, (ForEachFunc) _private_for_each_item_free,
                              NULL);
    } else {
      for (int i = 0; i < self->last_item; i++) {
        free (self->array[i]);
      }
    }
  }
  
  free (self->array);
  free (self);
}

spointer
s_dynamic_array_get (SDynamicArray * self, size_t index) {
  return self->array[index];
}

void
s_dynamic_array_set (SDynamicArray * self, size_t index, spointer item) {
  if (self->max_size <= index) {
    size_t new_size = round_up (index + ARRAY_PADDING, ARRAY_PADDING) + 1;
    s_dbg_print ("Index: %zu current array size: %zu new array size: %zu ",
      index, self->max_size, new_size);
    
    self->max_size = new_size;
    
    self->array = realloc (self->array,
                          (sizeof (* self->array) * (self->max_size)));
  }
  
  if (self->last_item < index) {
    self->last_item = index;
  }
  
  self->array[index] = item;
}

size_t
s_dynamic_array_size (SDynamicArray * self) {
  return self->max_size;
}

size_t
s_dynamic_array_last_item (SDynamicArray * self) {
  return self->last_item;
}

spointer *
s_dynamic_array_dump_array (SDynamicArray * self) {
  spointer * ret_val = calloc (self->last_item + 1, sizeof (* self->array));
  for (int i = 0; i < self->last_item; i++) {
    ret_val[i] = self->array[i];
  }
  ret_val[self->last_item] = NULL;
  return ret_val;
}

void
s_dynamic_array_for_each (SDynamicArray * self, ForEachFunc func,
                             spointer data) {
  for (int i = 0; i < self->max_size && i <= self->last_item; i++) {
    spointer item = self->array[i];
    if (item) {
      func (self, item, data);
    }
  }
}


void
_private_for_each_item_free (SDynamicArray * self, spointer item,
                             spointer data) {
  FreeFunc func = self->free_func;
  func (item);
}


5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	1	/* c-basic-offset: 2; tab-width: 2; indent-tabs-mode: nil
	2	* vi: set shiftwidth=2 tabstop=2 expandtab:
	3	* :indentSize=2:tabSize=2:noTabs=true:
	4	*/
	5
	6	/*
5.2.9 by Gustav Hartvigsson * Added license to files	7	Copyright (c) 2013-2014 Gustav Hartvigsson
	8
	9	Permission is hereby granted, free of charge, to any person obtaining a copy
	10	of this software and associated documentation files (the "Software"), to deal
	11	in the Software without restriction, including without limitation the rights
	12	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	13	copies of the Software, and to permit persons to whom the Software is
	14	furnished to do so, subject to the following conditions:
	15
	16	The above copyright notice and this permission notice shall be included in
	17	all copies or substantial portions of the Software.
	18
	19	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	20	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	21	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	22	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	23	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	24	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	25	THE SOFTWARE.
	26	*/
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	27
30 by Gustav Hartvigsson * Made the code compile using CMake.	28	#include "DynamicArray.h"
	29
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	30	struct
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	31	SDynamicArray {
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	32	FreeFunc free_func;
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	33	FuncPointer to_json;
	34	FuncPointer from_json;
	35	size_t max_size;
	36	size_t last_item;
30 by Gustav Hartvigsson * Made the code compile using CMake.	37	spointer * array;
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	38	};
	39
61 by Gustav Hartvigsson * Made the code more easy to read.	40	void
61 by Gustav Hartvigsson * Made the code more easy to read.	41	_private_for_each_item_free (SDynamicArray * self, spointer item,
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	42	spointer data);
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	43
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	44	SDynamicArray *
	45	_s_dynamic_array_new_full (size_t len,
	46	FreeFunc free_func,
	47	FuncPointer to_json,
	48	FuncPointer from_json) {
46 by Gustav Hartvigsson * Renamed DynamicArray to SDynamicArray.	49	SDynamicArray * self = malloc (sizeof(SDynamicArray));
	50
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	51	self->max_size = len;
	52
48 by Gustav Hartvigsson * Finnished SLinkedList.	53	self->last_item = 0;
48 by Gustav Hartvigsson * Finnished SLinkedList.	54
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	55	self->free_func = free_func;
	56	self->to_json = to_json;
	57	self->from_json = from_json;
	58
	59	self->array = calloc (len ,sizeof (* self->array));
	60
	61	return self;
	62	}
	63
	64	SDynamicArray *
	65	s_dynamic_array_new (size_t len,
	66	FreeFunc free_func) {
	67	SDynamicArray * self = _s_dynamic_array_new_full (len, free_func, NULL, NULL);
	68	return self;
	69	}
	70
	71	SDynamicArray *
	72	s_dynamic_array_new_json (size_t len,
	73	FreeFunc free_func,
	74	FuncPointer to_json,
	75	FuncPointer from_json) {
	76	SDynamicArray * self = _s_dynamic_array_new_full (len, free_func, to_json, from_json);
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	77	return self;
	78	}
	79
61 by Gustav Hartvigsson * Made the code more easy to read.	80	void
61 by Gustav Hartvigsson * Made the code more easy to read.	81	s_dynamic_array_free (SDynamicArray * self, sboolean free_data) {
48 by Gustav Hartvigsson * Finnished SLinkedList.	82	if (free_data) {
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	83	if (self->free_func != NULL) {
48 by Gustav Hartvigsson * Finnished SLinkedList.	84	s_dynamic_array_for_each (self, (ForEachFunc) _private_for_each_item_free,
	85	NULL);
	86	} else {
	87	for (int i = 0; i < self->last_item; i++) {
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	88	free (self->array[i]);
48 by Gustav Hartvigsson * Finnished SLinkedList.	89	}
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	90	}
	91	}
48 by Gustav Hartvigsson * Finnished SLinkedList.	92
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	93	free (self->array);
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	94	free (self);
	95	}
	96
61 by Gustav Hartvigsson * Made the code more easy to read.	97	spointer
61 by Gustav Hartvigsson * Made the code more easy to read.	98	s_dynamic_array_get (SDynamicArray * self, size_t index) {
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	99	return self->array[index];
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	100	}
	101
61 by Gustav Hartvigsson * Made the code more easy to read.	102	void
61 by Gustav Hartvigsson * Made the code more easy to read.	103	s_dynamic_array_set (SDynamicArray * self, size_t index, spointer item) {
47 by Gustav Hartvigsson * Added a few skeletal functions to Callback.h	104	if (self->max_size <= index) {
	105	size_t new_size = round_up (index + ARRAY_PADDING, ARRAY_PADDING) + 1;
48 by Gustav Hartvigsson * Finnished SLinkedList.	106	s_dbg_print ("Index: %zu current array size: %zu new array size: %zu ",
47 by Gustav Hartvigsson * Added a few skeletal functions to Callback.h	107	index, self->max_size, new_size);
	108
	109	self->max_size = new_size;
	110
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	111	self->array = realloc (self->array,
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	112	(sizeof (* self->array) * (self->max_size)));
47 by Gustav Hartvigsson * Added a few skeletal functions to Callback.h	113	}
	114
	115	if (self->last_item < index) {
	116	self->last_item = index;
	117	}
	118
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	119	self->array[index] = item;
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	120	}
	121
61 by Gustav Hartvigsson * Made the code more easy to read.	122	size_t
61 by Gustav Hartvigsson * Made the code more easy to read.	123	s_dynamic_array_size (SDynamicArray * self) {
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	124	return self->max_size;
	125	}
	126
61 by Gustav Hartvigsson * Made the code more easy to read.	127	size_t
61 by Gustav Hartvigsson * Made the code more easy to read.	128	s_dynamic_array_last_item (SDynamicArray * self) {
47 by Gustav Hartvigsson * Added a few skeletal functions to Callback.h	129	return self->last_item;
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	130	}
	131
61 by Gustav Hartvigsson * Made the code more easy to read.	132	spointer *
61 by Gustav Hartvigsson * Made the code more easy to read.	133	s_dynamic_array_dump_array (SDynamicArray * self) {
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	134	spointer * ret_val = calloc (self->last_item + 1, sizeof (* self->array));
47 by Gustav Hartvigsson * Added a few skeletal functions to Callback.h	135	for (int i = 0; i < self->last_item; i++) {
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	136	ret_val[i] = self->array[i];
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	137	}
47 by Gustav Hartvigsson * Added a few skeletal functions to Callback.h	138	ret_val[self->last_item] = NULL;
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	139	return ret_val;
	140	}
	141
61 by Gustav Hartvigsson * Made the code more easy to read.	142	void
61 by Gustav Hartvigsson * Made the code more easy to read.	143	s_dynamic_array_for_each (SDynamicArray * self, ForEachFunc func,
30 by Gustav Hartvigsson * Made the code compile using CMake.	144	spointer data) {
47 by Gustav Hartvigsson * Added a few skeletal functions to Callback.h	145	for (int i = 0; i < self->max_size && i <= self->last_item; i++) {
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	146	spointer item = self->array[i];
47 by Gustav Hartvigsson * Added a few skeletal functions to Callback.h	147	if (item) {
	148	func (self, item, data);
	149	}
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	150	}
	151	}
	152
	153
61 by Gustav Hartvigsson * Made the code more easy to read.	154	void
61 by Gustav Hartvigsson * Made the code more easy to read.	155	_private_for_each_item_free (SDynamicArray * self, spointer item,
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	156	spointer data) {
68 by Gustav Hartvigsson * Hid internals of SDynamicArray.	157	FreeFunc func = self->free_func;
5.2.8 by Gustav Hartvigsson * Copied over LinkedList and DynamicArray from c_sdl_js	158	func (item);
	159	}
	160