/*
 * Copyright (c) 2004-2006 Voltaire, Inc. All rights reserved.
 * Copyright (c) 2002-2005 Mellanox Technologies LTD. All rights reserved.
 * Copyright (c) 1996-2003 Intel Corporation. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     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 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.
 *
 */

/*
 * Abstract:
 *	This file contains ivector and isvector implementations.
 *
 */

#if HAVE_CONFIG_H
#  include <config.h>
#endif				/* HAVE_CONFIG_H */

#include <stdlib.h>
#include <string.h>
#include <complib/cl_ptr_vector.h>

void cl_ptr_vector_construct(IN cl_ptr_vector_t * const p_vector)
{
	CL_ASSERT(p_vector);

	memset(p_vector, 0, sizeof(cl_ptr_vector_t));

	p_vector->state = CL_UNINITIALIZED;
}

cl_status_t cl_ptr_vector_init(IN cl_ptr_vector_t * const p_vector,
			       IN const size_t min_size,
			       IN const size_t grow_size)
{
	cl_status_t status = CL_SUCCESS;

	CL_ASSERT(p_vector);

	cl_ptr_vector_construct(p_vector);

	p_vector->grow_size = grow_size;

	/*
	 * Set the state to initialized so that the call to set_size
	 * doesn't assert.
	 */
	p_vector->state = CL_INITIALIZED;

	/* get the storage needed by the user */
	if (min_size) {
		status = cl_ptr_vector_set_size(p_vector, min_size);
		if (status != CL_SUCCESS)
			cl_ptr_vector_destroy(p_vector);
	}

	return (status);
}

void cl_ptr_vector_destroy(IN cl_ptr_vector_t * const p_vector)
{
	CL_ASSERT(p_vector);
	CL_ASSERT(cl_is_state_valid(p_vector->state));

	/* Call the user's destructor for each element in the array. */
	if (p_vector->state == CL_INITIALIZED) {
		/* Destroy the page vector. */
		if (p_vector->p_ptr_array) {
			free((void *)p_vector->p_ptr_array);
			p_vector->p_ptr_array = NULL;
		}
	}

	p_vector->state = CL_UNINITIALIZED;
}

cl_status_t cl_ptr_vector_at(IN const cl_ptr_vector_t * const p_vector,
			     IN const size_t index, OUT void **const p_element)
{
	CL_ASSERT(p_vector);
	CL_ASSERT(p_vector->state == CL_INITIALIZED);

	/* Range check */
	if (index >= p_vector->size)
		return (CL_INVALID_PARAMETER);

	*p_element = cl_ptr_vector_get(p_vector, index);
	return (CL_SUCCESS);
}

cl_status_t cl_ptr_vector_set(IN cl_ptr_vector_t * const p_vector,
			      IN const size_t index,
			      IN const void *const element)
{
	cl_status_t status;

	CL_ASSERT(p_vector);
	CL_ASSERT(p_vector->state == CL_INITIALIZED);

	/* Determine if the vector has room for this element. */
	if (index >= p_vector->size) {
		/* Resize to accomodate the given index. */
		status = cl_ptr_vector_set_size(p_vector, index + 1);

		/* Check for failure on or before the given index. */
		if ((status != CL_SUCCESS) && (p_vector->size < index))
			return (status);
	}

	/* At this point, the array is guaranteed to be big enough */
	p_vector->p_ptr_array[index] = element;

	return (CL_SUCCESS);
}

void *cl_ptr_vector_remove(IN cl_ptr_vector_t * const p_vector,
			   IN const size_t index)
{
	size_t src;
	const void *element;

	CL_ASSERT(p_vector);
	CL_ASSERT(p_vector->state == CL_INITIALIZED);
	CL_ASSERT(p_vector->size > index);

	/* Store a copy of the element to return. */
	element = p_vector->p_ptr_array[index];
	/* Shift all items above the removed item down. */
	if (index < --p_vector->size) {
		for (src = index; src < p_vector->size; src++)
			p_vector->p_ptr_array[src] =
			    p_vector->p_ptr_array[src + 1];
	}
	/* Clear the entry for the element just outside of the new upper bound. */
	p_vector->p_ptr_array[p_vector->size] = NULL;

	return ((void *)element);
}

cl_status_t cl_ptr_vector_set_capacity(IN cl_ptr_vector_t * const p_vector,
				       IN const size_t new_capacity)
{
	void *p_new_ptr_array;

	CL_ASSERT(p_vector);
	CL_ASSERT(p_vector->state == CL_INITIALIZED);

	/* Do we have to do anything here? */
	if (new_capacity <= p_vector->capacity) {
		/* Nope */
		return (CL_SUCCESS);
	}

	/* Allocate our pointer array. */
	p_new_ptr_array = malloc(new_capacity * sizeof(void *));
	if (!p_new_ptr_array)
		return (CL_INSUFFICIENT_MEMORY);
	else
		memset(p_new_ptr_array, 0, new_capacity * sizeof(void *));

	if (p_vector->p_ptr_array) {
		/* Copy the old pointer array into the new. */
		memcpy(p_new_ptr_array, p_vector->p_ptr_array,
		       p_vector->capacity * sizeof(void *));

		/* Free the old pointer array. */
		free((void *)p_vector->p_ptr_array);
	}

	/* Set the new array. */
	p_vector->p_ptr_array = p_new_ptr_array;

	/* Update the vector with the new capactity. */
	p_vector->capacity = new_capacity;

	return (CL_SUCCESS);
}

cl_status_t cl_ptr_vector_set_size(IN cl_ptr_vector_t * const p_vector,
				   IN const size_t size)
{
	cl_status_t status;
	size_t new_capacity;

	CL_ASSERT(p_vector);
	CL_ASSERT(p_vector->state == CL_INITIALIZED);

	/* Check to see if the requested size is the same as the existing size. */
	if (size == p_vector->size)
		return (CL_SUCCESS);

	/* Determine if the vector has room for this element. */
	if (size >= p_vector->capacity) {
		if (!p_vector->grow_size)
			return (CL_INSUFFICIENT_MEMORY);

		/* Calculate the new capacity, taking into account the grow size. */
		new_capacity = size;
		if (size % p_vector->grow_size) {
			/* Round up to nearest grow_size boundary. */
			new_capacity += p_vector->grow_size -
			    (size % p_vector->grow_size);
		}

		status = cl_ptr_vector_set_capacity(p_vector, new_capacity);
		if (status != CL_SUCCESS)
			return (status);
	}

	p_vector->size = size;
	return (CL_SUCCESS);
}

cl_status_t cl_ptr_vector_set_min_size(IN cl_ptr_vector_t * const p_vector,
				       IN const size_t min_size)
{
	CL_ASSERT(p_vector);
	CL_ASSERT(p_vector->state == CL_INITIALIZED);

	if (min_size > p_vector->size) {
		/* We have to resize the array */
		return (cl_ptr_vector_set_size(p_vector, min_size));
	}

	/* We didn't have to do anything */
	return (CL_SUCCESS);
}

void cl_ptr_vector_apply_func(IN const cl_ptr_vector_t * const p_vector,
			      IN cl_pfn_ptr_vec_apply_t pfn_callback,
			      IN const void *const context)
{
	size_t i;

	CL_ASSERT(p_vector);
	CL_ASSERT(p_vector->state == CL_INITIALIZED);
	CL_ASSERT(pfn_callback);

	for (i = 0; i < p_vector->size; i++)
		pfn_callback(i, (void *)p_vector->p_ptr_array[i],
			     (void *)context);
}

size_t cl_ptr_vector_find_from_start(IN const cl_ptr_vector_t * const p_vector,
				     IN cl_pfn_ptr_vec_find_t pfn_callback,
				     IN const void *const context)
{
	size_t i;

	CL_ASSERT(p_vector);
	CL_ASSERT(p_vector->state == CL_INITIALIZED);
	CL_ASSERT(pfn_callback);

	for (i = 0; i < p_vector->size; i++) {
		/* Invoke the callback */
		if (pfn_callback(i, (void *)p_vector->p_ptr_array[i],
				 (void *)context) == CL_SUCCESS) {
			break;
		}
	}
	return (i);
}

size_t cl_ptr_vector_find_from_end(IN const cl_ptr_vector_t * const p_vector,
				   IN cl_pfn_ptr_vec_find_t pfn_callback,
				   IN const void *const context)
{
	size_t i;

	CL_ASSERT(p_vector);
	CL_ASSERT(p_vector->state == CL_INITIALIZED);
	CL_ASSERT(pfn_callback);

	i = p_vector->size;

	while (i) {
		/* Invoke the callback for the current element. */
		i--;
		if (pfn_callback(i, (void *)p_vector->p_ptr_array[i],
				 (void *)context) == CL_SUCCESS) {
			return (i);
		}
	}

	return (p_vector->size);
}