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);
}