~drizzle-trunk/drizzle/development

/******************************************************
The dynamically allocated array

(c) 1996 Innobase Oy

Created 2/5/1996 Heikki Tuuri
*******************************************************/

#define DYN_BLOCK_MAGIC_N	375767
#define DYN_BLOCK_FULL_FLAG	0x1000000UL

/****************************************************************
Adds a new block to a dyn array. */

dyn_block_t*
dyn_array_add_block(
/*================*/
				/* out: created block */
	dyn_array_t*	arr);	/* in: dyn array */


/****************************************************************
Gets the first block in a dyn array. */
UNIV_INLINE
dyn_block_t*
dyn_array_get_first_block(
/*======================*/
	dyn_array_t*	arr)	/* in: dyn array */
{
	return(arr);
}

/****************************************************************
Gets the last block in a dyn array. */
UNIV_INLINE
dyn_block_t*
dyn_array_get_last_block(
/*=====================*/
	dyn_array_t*	arr)	/* in: dyn array */
{
	if (arr->heap == NULL) {

		return(arr);
	}

	return(UT_LIST_GET_LAST(arr->base));
}

/************************************************************************
Gets the next block in a dyn array. */
UNIV_INLINE
dyn_block_t*
dyn_array_get_next_block(
/*=====================*/
				/* out: pointer to next, NULL if end of list */
	dyn_array_t*	arr,	/* in: dyn array */
	dyn_block_t*	block)	/* in: dyn array block */
{
	ut_ad(arr && block);

	if (arr->heap == NULL) {
		ut_ad(arr == block);

		return(NULL);
	}

	return(UT_LIST_GET_NEXT(list, block));
}

/************************************************************************
Gets the number of used bytes in a dyn array block. */
UNIV_INLINE
ulint
dyn_block_get_used(
/*===============*/
				/* out: number of bytes used */
	dyn_block_t*	block)	/* in: dyn array block */
{
	ut_ad(block);

	return((block->used) & ~DYN_BLOCK_FULL_FLAG);
}

/************************************************************************
Gets pointer to the start of data in a dyn array block. */
UNIV_INLINE
byte*
dyn_block_get_data(
/*===============*/
				/* out: pointer to data */
	dyn_block_t*	block)	/* in: dyn array block */
{
	ut_ad(block);

	return(block->data);
}

/*************************************************************************
Initializes a dynamic array. */
UNIV_INLINE
dyn_array_t*
dyn_array_create(
/*=============*/
				/* out: initialized dyn array */
	dyn_array_t*	arr)	/* in: pointer to a memory buffer of
				size sizeof(dyn_array_t) */
{
	ut_ad(arr);
#if DYN_ARRAY_DATA_SIZE >= DYN_BLOCK_FULL_FLAG
# error "DYN_ARRAY_DATA_SIZE >= DYN_BLOCK_FULL_FLAG"
#endif

	arr->heap = NULL;
	arr->used = 0;

#ifdef UNIV_DEBUG
	arr->buf_end = 0;
	arr->magic_n = DYN_BLOCK_MAGIC_N;
#endif
	return(arr);
}

/****************************************************************
Frees a dynamic array. */
UNIV_INLINE
void
dyn_array_free(
/*===========*/
	dyn_array_t*	arr)	/* in: dyn array */
{
	if (arr->heap != NULL) {
		mem_heap_free(arr->heap);
	}

#ifdef UNIV_DEBUG
	arr->magic_n = 0;
#endif
}

/*************************************************************************
Makes room on top of a dyn array and returns a pointer to the added element.
The caller must copy the element to the pointer returned. */
UNIV_INLINE
void*
dyn_array_push(
/*===========*/
				/* out: pointer to the element */
	dyn_array_t*	arr,	/* in: dynamic array */
	ulint		size)	/* in: size in bytes of the element */
{
	dyn_block_t*	block;
	ulint		used;

	ut_ad(arr);
	ut_ad(arr->magic_n == DYN_BLOCK_MAGIC_N);
	ut_ad(size <= DYN_ARRAY_DATA_SIZE);
	ut_ad(size);

	block = arr;
	used = block->used;

	if (used + size > DYN_ARRAY_DATA_SIZE) {
		/* Get the last array block */

		block = dyn_array_get_last_block(arr);
		used = block->used;

		if (used + size > DYN_ARRAY_DATA_SIZE) {
			block = dyn_array_add_block(arr);
			used = block->used;
		}
	}

	block->used = used + size;
	ut_ad(block->used <= DYN_ARRAY_DATA_SIZE);

	return((block->data) + used);
}

/*************************************************************************
Makes room on top of a dyn array and returns a pointer to a buffer in it.
After copying the elements, the caller must close the buffer using
dyn_array_close. */
UNIV_INLINE
byte*
dyn_array_open(
/*===========*/
				/* out: pointer to the buffer */
	dyn_array_t*	arr,	/* in: dynamic array */
	ulint		size)	/* in: size in bytes of the buffer; MUST be
				smaller than DYN_ARRAY_DATA_SIZE! */
{
	dyn_block_t*	block;
	ulint		used;

	ut_ad(arr);
	ut_ad(arr->magic_n == DYN_BLOCK_MAGIC_N);
	ut_ad(size <= DYN_ARRAY_DATA_SIZE);
	ut_ad(size);

	block = arr;
	used = block->used;

	if (used + size > DYN_ARRAY_DATA_SIZE) {
		/* Get the last array block */

		block = dyn_array_get_last_block(arr);
		used = block->used;

		if (used + size > DYN_ARRAY_DATA_SIZE) {
			block = dyn_array_add_block(arr);
			used = block->used;
			ut_a(size <= DYN_ARRAY_DATA_SIZE);
		}
	}

	ut_ad(block->used <= DYN_ARRAY_DATA_SIZE);
#ifdef UNIV_DEBUG
	ut_ad(arr->buf_end == 0);

	arr->buf_end = used + size;
#endif
	return((block->data) + used);
}

/*************************************************************************
Closes the buffer returned by dyn_array_open. */
UNIV_INLINE
void
dyn_array_close(
/*============*/
	dyn_array_t*	arr,	/* in: dynamic array */
	byte*		ptr)	/* in: buffer space from ptr up was not used */
{
	dyn_block_t*	block;

	ut_ad(arr);
	ut_ad(arr->magic_n == DYN_BLOCK_MAGIC_N);

	block = dyn_array_get_last_block(arr);

	ut_ad(arr->buf_end + block->data >= ptr);

	block->used = ptr - block->data;

	ut_ad(block->used <= DYN_ARRAY_DATA_SIZE);

#ifdef UNIV_DEBUG
	arr->buf_end = 0;
#endif
}

/****************************************************************
Returns pointer to an element in dyn array. */
UNIV_INLINE
void*
dyn_array_get_element(
/*==================*/
				/* out: pointer to element */
	dyn_array_t*	arr,	/* in: dyn array */
	ulint		pos)	/* in: position of element as bytes
				from array start */
{
	dyn_block_t*	block;
	ulint		used;

	ut_ad(arr);
	ut_ad(arr->magic_n == DYN_BLOCK_MAGIC_N);

	/* Get the first array block */
	block = dyn_array_get_first_block(arr);

	if (arr->heap != NULL) {
		used = dyn_block_get_used(block);

		while (pos >= used) {
			pos -= used;
			block = UT_LIST_GET_NEXT(list, block);
			ut_ad(block);

			used = dyn_block_get_used(block);
		}
	}

	ut_ad(block);
	ut_ad(dyn_block_get_used(block) >= pos);

	return(block->data + pos);
}

/****************************************************************
Returns the size of stored data in a dyn array. */
UNIV_INLINE
ulint
dyn_array_get_data_size(
/*====================*/
				/* out: data size in bytes */
	dyn_array_t*	arr)	/* in: dyn array */
{
	dyn_block_t*	block;
	ulint		sum	= 0;

	ut_ad(arr);
	ut_ad(arr->magic_n == DYN_BLOCK_MAGIC_N);

	if (arr->heap == NULL) {

		return(arr->used);
	}

	/* Get the first array block */
	block = dyn_array_get_first_block(arr);

	while (block != NULL) {
		sum += dyn_block_get_used(block);
		block = dyn_array_get_next_block(arr, block);
	}

	return(sum);
}

/************************************************************
Pushes n bytes to a dyn array. */
UNIV_INLINE
void
dyn_push_string(
/*============*/
	dyn_array_t*	arr,	/* in: dyn array */
	const byte*	str,	/* in: string to write */
	ulint		len)	/* in: string length */
{
	ulint	n_copied;

	while (len > 0) {
		if (len > DYN_ARRAY_DATA_SIZE) {
			n_copied = DYN_ARRAY_DATA_SIZE;
		} else {
			n_copied = len;
		}

		memcpy(dyn_array_push(arr, n_copied), str, n_copied);

		str += n_copied;
		len -= n_copied;
	}
}