openmohaa/code/uilib/ulist.h

/*
===========================================================================
Copyright (C) 2024 the OpenMoHAA team

This file is part of OpenMoHAA source code.

OpenMoHAA source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

OpenMoHAA source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with OpenMoHAA source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

#pragma once

template< typename type >
class UListItem {
public:
	type					item;
	class UListItem< type >	*next;
	class UListItem< type >	*prev;

	UListItem();
};

template< typename type >
class UList {
	UListItem<type> m_top;
	UListItem<type> *m_at;
	int m_count;

public:
	UList();
	~UList();

	void		AddHead( type& head );
	void		AddTail( const type& tail );
	bool		IterateFromHead( void );
	bool		IterateFromTail( void );
	bool		IterateNext( void );
	bool		IteratePrev( void );
	type&		getCurrent( void );
	void		RemoveCurrentSetNext( void );
	void		RemoveCurrentSetPrev( void );
	bool		IsCurrentValid( void );
	bool		IsCurrentHead( void );
	bool		IsCurrentTail( void );
	void		InsertBeforeCurrent( type& which );
	void		InsertAfterCurrent( type& which );
	int			getCount( void );
	void		RemoveAllItems( void );
	void		*getPosition( void );
	void		setPosition( void *pos );
};

template< typename type >
UListItem< type >::UListItem()
{
	next = prev = NULL;
}

template< typename type >
UList< type >::UList()
{
	m_at = NULL;
	m_count = 0;
	m_top.next = &m_top;
	m_top.prev = &m_top;
}

template< typename type >
UList< type >::~UList()
{
	RemoveAllItems();
}

template< typename type >
void UList< type >::AddHead
	(
	type& head
	)

{
	// FIXME: stub
}

template< typename type >
void UList< type >::AddTail
	(
	const type& tail
	)

{
	UListItem<type> *item = new UListItem <type>;

	item->item = tail;
	item->next = &m_top;
	item->prev = m_top.prev;
	m_top.prev->next = item;
	m_top.prev = item;

	m_count++;
}

template< typename type >
bool UList< type >::IterateFromHead
	(
	void
	)

{
	if( m_top.next == &m_top )
	{
		m_at = NULL;
		return false;
	}
	else
	{
		m_at = m_top.next;
		return true;
	}
}

template< typename type >
bool UList< type >::IterateFromTail
	(
	void
	)

{
	if (m_top.prev == &m_top)
	{
		m_at = NULL;
		return false;
	}
	else
	{
		m_at = m_top.prev;
		return true;
	}
}

template< typename type >
bool UList< type >::IterateNext
	(
	void
	)

{
	m_at = m_at->next;

	if( m_at == &m_top )
	{
		m_at = NULL;
		return false;
	}
	else
	{
		return true;
	}
}

template< typename type >
bool UList< type >::IteratePrev
	(
	void
	)

{
	m_at = m_at->prev;

	if( m_at == &m_top )
	{
		m_at = NULL;
		return false;
	}
	else
	{
		return true;
	}
}

template< typename type >
type& UList< type >::getCurrent
	(
	void
	)

{
	return m_at->item;
}

template< typename type >
void UList< type >::RemoveCurrentSetNext
	(
	void
	)

{
	UListItem<type> *item;

	item = m_at;
	IterateNext();

	item->next->prev = item->prev;
	item->prev->next = item->next;

	delete item;

	m_count--;
}

template< typename type >
void UList< type >::RemoveCurrentSetPrev
	(
	void
	)

{
	UListItem<type> *item;

	item = m_at;
	IteratePrev();

	item->next->prev = item->prev;
	item->prev->next = item->next;

	delete item;

	m_count--;
}

template< typename type >
bool UList< type >::IsCurrentValid
	(
	void
	)

{
	return m_at != NULL;
}

template< typename type >
bool UList< type >::IsCurrentHead
	(
	void
	)

{
	return m_at == &m_top;
}

template< typename type >
bool UList< type >::IsCurrentTail
	(
	void
	)

{
	// FIXME: stub
	return false;
}

template< typename type >
void UList< type >::InsertBeforeCurrent
	(
	type& which
	)

{
	// FIXME: stub
}

template< typename type >
void UList< type >::InsertAfterCurrent
	(
	type& which
	)

{
	UListItem<type> *item = new UListItem <type>;

	item->item = which;
	item->next = m_at->next;
	item->prev = m_at;
	m_at->next->prev = item;
	item->prev->next = item;

	m_count++;
}

template< typename type >
int UList< type >::getCount
	(
	void
	)

{
	return m_count;
}

template< typename type >
void UList< type >::RemoveAllItems
	(
	void
	)

{
	UListItem<type> *item;
	UListItem<type> *next;

	for( item = m_top.next; item && item != &m_top; item = next )
	{
		next = item->next;
		delete item;
	}

	m_top.next = &m_top;
	m_top.prev = &m_top;
	m_count = 0;
}

template< typename type >
void *UList< type >::getPosition
	(
	void
	)

{
	return (void*)m_at;
}

template< typename type >
void UList< type >::setPosition
	(
	void *pos
	)

{
	m_at = static_cast<UListItem<type>*>(pos);
}