/*
 * Copyright (c) 2009 Lukas Mejdrech
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup net
 *  @{
 */

/** @file
 *  Generic type field.
 */

#ifndef __GENERIC_FIELD_H__
#define __GENERIC_FIELD_H__

#include <errno.h>
#include <malloc.h>
#include <mem.h>
#include <unistd.h>

/** Internal magic value for a&nbsp;field consistency check.
 */
#define GENERIC_FIELD_MAGIC_VALUE		0x55667788

/** Generic type field declaration.
 *  @param[in] name Name of the field.
 *  @param[in] type Inner object type.
 */
#define GENERIC_FIELD_DECLARE(name, type)										\
																				\
typedef	struct name		name##_t;												\
typedef	name##_t *		name##_ref;												\
																				\
struct	name{																	\
	int size;																	\
	int next;																	\
	type **	items;																\
	int magic;																	\
};																				\
																				\
int name##_add(name##_ref field, type * value);									\
int name##_count(name##_ref field);												\
void name##_destroy(name##_ref field);											\
void name##_exclude_index(name##_ref field, int index);							\
type ** name##_get_field(name##_ref field);										\
type * name##_get_index(name##_ref field, int index);							\
int name##_initialize(name##_ref field);										\
int name##_is_valid(name##_ref field);

/** Generic type field implementation.
 *  Should follow declaration with the same parameters.
 *  @param[in] name Name of the field.
 *  @param[in] type Inner object type.
 */
#define GENERIC_FIELD_IMPLEMENT(name, type)										\
																				\
int name##_add(name##_ref field, type * value){									\
	if(name##_is_valid(field)){													\
		if(field->next == (field->size - 1)){									\
			type **	tmp;														\
																				\
			tmp = (type **) realloc(field->items, sizeof(type *) * 2 * field->size);	\
			if(! tmp){															\
				return ENOMEM;													\
			}																	\
			field->size *= 2;													\
			field->items = tmp;													\
		}																		\
		field->items[field->next] = value;										\
		++ field->next;															\
		field->items[field->next] = NULL;										\
		return field->next - 1;													\
	}																			\
	return EINVAL;																\
}																				\
																				\
int name##_count(name##_ref field){												\
	return name##_is_valid(field) ? field->next : -1;							\
}																				\
																				\
void name##_destroy(name##_ref field){											\
	if(name##_is_valid(field)){													\
		int index;																\
																				\
		field->magic = 0;														\
		for(index = 0; index < field->next; ++ index){							\
			if(field->items[index]){											\
				free(field->items[index]);										\
			}																	\
		}																		\
		free(field->items);														\
	}																			\
}																				\
																				\
void name##_exclude_index(name##_ref field, int index){							\
	if(name##_is_valid(field) && (index >= 0) && (index < field->next) && (field->items[index])){	\
		free(field->items[index]);												\
		field->items[index] = NULL;												\
	}																			\
}																				\
																				\
type * name##_get_index(name##_ref field, int index){							\
	if(name##_is_valid(field) && (index >= 0) && (index < field->next) && (field->items[index])){	\
		return field->items[index];												\
	}																			\
	return NULL;																\
}																				\
																				\
type ** name##_get_field(name##_ref field){										\
	return name##_is_valid(field) ? field->items : NULL;						\
}																				\
																				\
int name##_initialize(name##_ref field){										\
	if(! field){																\
		return EINVAL;															\
	}																			\
	field->size = 2;															\
	field->next = 0;															\
	field->items = (type **) malloc(sizeof(type *) * field->size);				\
	if(! field->items){															\
		return ENOMEM;															\
	}																			\
	field->items[field->next] = NULL;											\
	field->magic = GENERIC_FIELD_MAGIC_VALUE;									\
	return EOK;																	\
}																				\
																				\
int name##_is_valid(name##_ref field){											\
	return field && (field->magic == GENERIC_FIELD_MAGIC_VALUE);				\
}

#endif

/** @}
 */