/*
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 *
 * Copyright (c) 1996
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 */

/*
Copyright (c) 2007 Lao wen bo

This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

    1. The origin of this software must not be misrepresented; you must not
    claim that you wrote the original software. If you use this software
    in a product, an acknowledgment in the product documentation would be
    appreciated but is not required.

    2. Altered source versions must be plainly marked as such, and must not be
    misrepresented as being the original software.

    3. This notice may not be removed or altered from any source
    distribution.

	Lao wen bo
	viewpl(at)gmail.com
*/

#include "c_iterator.h"

typedef void ** pp_t;

static c_iterator _c_array_iterator_assign(c_piterator thiz, const c_piterator val)
{
	if(thiz != val)
		thiz->_i = val->_i;
	return *thiz;
}

static value_type _c_array_iterator_ref(c_piterator thiz)
{
	return *(pp_t)thiz->_i;
}

static value_type _c_array_iterator_ref_assign(c_piterator thiz, const value_type val)
{
	return *(pp_t)thiz->_i = val;
}

static c_iterator _c_array_iterator_inc(c_piterator thiz)
{
	pp_t p = thiz->_i;
	++ p;
	thiz->_i = p;
	return *thiz;
}

static c_iterator _c_array_iterator_inc_n(c_piterator thiz, difference_type n)
{
	pp_t p = thiz->_i;
	p += n;
	thiz->_i = p;
	return *thiz;
}

static c_iterator _c_array_iterator_dec(c_piterator thiz)
{
	pp_t p = thiz->_i;
	-- p;
	thiz->_i = p;
	return *thiz;
}

static c_iterator _c_array_iterator_dec_n(c_piterator thiz, difference_type n)
{
	pp_t p = thiz->_i;
	p -= n;
	thiz->_i = p;
	return *thiz;
}

static difference_type _c_array_iterator_diff(c_piterator thiz, const c_piterator val)
{
	return ((pp_t)thiz->_i - (pp_t)val->_i);
}

static value_type _c_array_iterator_at(c_piterator thiz, difference_type n)
{
	return *((pp_t)thiz->_i + n);
}

static c_iterator _c_array_iterator_positive_n(c_piterator thiz, difference_type n)
{
	c_iterator iter;
	pp_t p = thiz->_i;
	p += n;
	iter = c_get_array_iterator(p);
	return iter;
}

static c_iterator _c_array_iterator_negative_n(c_piterator thiz, difference_type n)
{
	c_iterator iter;
	pp_t p = thiz->_i;
	p -= n;
	iter = c_get_array_iterator(p);
	return iter;
}

static c_bool _c_array_iterator_equal(c_piterator thiz, const c_piterator val)
{
	return (thiz->_i == val->_i &&
				thiz->_pft == val->_pft);
}

static c_bool _c_array_iterator_less(c_piterator thiz, const c_piterator val)
{
	return ((pp_t)thiz->_i < (pp_t)val->_i);
}

static c_iterator_ft _c_array_iterator_ft =
{
	_c_array_iterator_assign,
	_c_array_iterator_ref,
	_c_array_iterator_ref_assign,
	_c_array_iterator_inc,
	_c_array_iterator_inc_n,
	_c_array_iterator_dec,
	_c_array_iterator_dec_n,
	_c_array_iterator_diff,
	_c_array_iterator_at,
	_c_array_iterator_positive_n,
	_c_array_iterator_negative_n,
	_c_array_iterator_equal,
	_c_array_iterator_less
};

c_iterator c_get_array_iterator(void ** ppt)
{
	c_iterator iter;
	iter._pft = &_c_array_iterator_ft;
	iter._i = ppt;
	return iter;
}

static c_reverse_iterator _c_array_reverse_iterator_assign(c_preverse_iterator thiz, const c_preverse_iterator val)
{
	if(thiz != val)
		thiz->_i = val->_i;
	return *thiz;
}

static value_type _c_array_reverse_iterator_ref(c_preverse_iterator thiz)
{
	return *(pp_t)thiz->_i;
}

static value_type _c_array_reverse_iterator_ref_assign(c_preverse_iterator thiz, const value_type val)
{
	return *(pp_t)thiz->_i = val;
}

static c_reverse_iterator _c_array_reverse_iterator_inc(c_preverse_iterator thiz)
{
	pp_t p = thiz->_i;
	-- p;
	thiz->_i = p;
	return *thiz;
}

static c_reverse_iterator _c_array_reverse_iterator_inc_n(c_preverse_iterator thiz, difference_type n)
{
	pp_t p = thiz->_i;
	p -= n;
	thiz->_i = p;
	return *thiz;
}

static c_reverse_iterator _c_array_reverse_iterator_dec(c_preverse_iterator thiz)
{
	pp_t p = thiz->_i;
	++ p;
	thiz->_i = p;
	return *thiz;
}

static c_reverse_iterator _c_array_reverse_iterator_dec_n(c_preverse_iterator thiz, difference_type n)
{
	pp_t p = thiz->_i;
	p += n;
	thiz->_i = p;
	return *thiz;
}

static difference_type _c_array_reverse_iterator_diff(c_preverse_iterator thiz, const c_preverse_iterator val)
{
	return ((pp_t)val->_i - (pp_t)thiz->_i);
}

static value_type _c_array_reverse_iterator_at(c_preverse_iterator thiz, difference_type n)
{
	return *((pp_t)thiz->_i - n);
}

static c_reverse_iterator _c_array_reverse_iterator_positive_n(c_preverse_iterator thiz, difference_type n)
{
	c_reverse_iterator iter;
	pp_t p = thiz->_i;
	p -= n;
	iter = c_get_array_reverse_iterator(p);
	return iter;
}

static c_reverse_iterator _c_array_reverse_iterator_negative_n(c_preverse_iterator thiz, difference_type n)
{
	c_reverse_iterator iter;
	pp_t p = thiz->_i;
	p += n;
	iter = c_get_array_reverse_iterator(p);
	return iter;
}

static c_bool _c_array_reverse_iterator_equal(c_preverse_iterator thiz, const c_preverse_iterator val)
{
	return (thiz->_i == val->_i &&
				thiz->_pft == val->_pft);
}

static c_bool _c_array_reverse_iterator_less(c_preverse_iterator thiz, const c_preverse_iterator val)
{
	return ((pp_t)thiz->_i > (pp_t)val->_i);
}

static c_reverse_iterator_ft _c_array_reverse_iterator_ft =
{
	_c_array_reverse_iterator_assign,
	_c_array_reverse_iterator_ref,
	_c_array_reverse_iterator_ref_assign,
	_c_array_reverse_iterator_inc,
	_c_array_reverse_iterator_inc_n,
	_c_array_reverse_iterator_dec,
	_c_array_reverse_iterator_dec_n,
	_c_array_reverse_iterator_diff,
	_c_array_reverse_iterator_at,
	_c_array_reverse_iterator_positive_n,
	_c_array_reverse_iterator_negative_n,
	_c_array_reverse_iterator_equal,
	_c_array_reverse_iterator_less
};

c_reverse_iterator c_get_array_reverse_iterator(void ** ppt)
{
	c_reverse_iterator iter;
	iter._pft = &_c_array_reverse_iterator_ft;
	iter._i = ppt;
	return iter;
}

difference_type c_distance(c_iterator first, c_iterator last)
{
	if(CHECK_RANDOM_ACCESS_ITERATOR(first) &&
		CHECK_RANDOM_ACCESS_ITERATOR(last))
		return ITER_DIFF(last, first);
	else
	{
		difference_type n = 0;
		while(!ITER_EQUAL(first, last))
		{
			ITER_INC(first);
			++ n;
		}
		return n;
	}
}

void c_distance1(c_iterator first, c_iterator last, difference_type * pn)
{
	if(CHECK_RANDOM_ACCESS_ITERATOR(first) &&
		CHECK_RANDOM_ACCESS_ITERATOR(last))
		*pn += ITER_DIFF(last, first);
	else
	{
		while(!ITER_EQUAL(first, last))
		{
			ITER_INC(first);
			++ *pn;
		}
	}
}

void c_advance(c_piterator pval, difference_type n)
{
	c_iterator val = *pval;
	if(CHECK_RANDOM_ACCESS_ITERATOR(val))
		ITER_INC_N(val, n);
	else if(CHECK_BIDIRECTIONAL_ITERATOR(val))
	{
		if(n >= 0)
			while(n --)
				ITER_INC(val);
		else
			while(n ++)
				ITER_DEC(val);
	}
	else
		while(n --)
			ITER_INC(val);
	*pval = val;
}

value_type c_iter_ref(c_iterator x)
{
	return ITER_REF(x);
}

value_type c_iter_ref_assign(c_iterator x, const value_type val)
{
	return ITER_REF_ASSIGN(x, val);
}

difference_type c_iter_diff(c_iterator x, c_iterator y)
{
	return ITER_DIFF(x, y);
}

value_type c_iter_at(c_iterator x, difference_type n)
{
	return ITER_AT(x, n);
}

c_iterator c_iter_positive_n(c_iterator x, difference_type n)
{
	return ITER_POSITIVE_N(x, n);
}

c_iterator c_iter_negative_n(c_iterator x, difference_type n)
{
	return ITER_NEGATIVE_N(x, n);
}

c_bool c_iter_equal(c_iterator x, c_iterator y)
{
	return ITER_EQUAL(x, y);
}

c_bool c_iter_less(c_iterator x, c_iterator y)
{
	return ITER_LESS(x, y);
}