FList.h

/******************************************************************************
**
** FAST.Framework
**
** Created: 2023-10-11
** Author:  Boris Fast
** Mail:    support@fast-framework.com
**
******************************************************************************/
 
#ifndef FLIST_H
#define FLIST_H
 
using namespace std;
 
#include "FObject.h"
#include "FString.h"
#include "FNode.h"
 
template <typename T>
class FList : public FObject
{
    public:
        FList() : head(0), tail(0), count(0) { }                               
        virtual ~FList() { Clear(); }                                          
 
        inline void Add(const T& item)                                         
        {
            if (this->head)
            {
                this->tail->next = new FNode<T>(item, this->tail);
                this->tail = this->tail->next;
            }
            else
            {
                this->head = this->tail = new FNode<T>(item);
            }
 
            this->count++;
        }
 
        inline ULLong Count() const { return this->count; }                    
 
        inline T operator [](ULLong position) const                              
        {
            if (position >= this->count) return T();
 
            if (this->head)
            {
                Boolean forward = position <= (this->count / 2) ? true : false;
                FNode<T>* current = forward ? this->head : this->tail;
                ULLong index = forward ? 0 : (this->count - 1);
 
                if (forward)
                {
                    while (index < position)
                    {
                        current = current->next;
                        index++;
                    }
                }
                else
                {
                    while (index > position)
                    {
                        current = current->last;
                        index--;
                    }
                }
 
                return current->data;
            }
 
            return T();
        }
 
        inline void Remove(ULLong position)                                      
        {
            if (position >= this->count) return;
 
            if (this->head)
            {
                if (position == 0 && !this->head->next)
                {
                    delete this->head;
                    this->head = nullptr;
                }
                else if (position == 0)
                {
                    FNode<T>* current = this->head;
                    this->head = current->next;
 
                    delete current;
                    current = nullptr;
                }
                else
                {
                    Boolean forward = position <= (this->count / 2) ? true : false;
                    FNode<T>* current = forward ? this->head : this->tail;
                    ULLong index = forward ? 0 : (this->count - 1);
 
                    if (forward)
                    {
                        while (index < position)
                        {
                            current = current->next;
                            index++;
                        }
                    }
                    else
                    {
                        while (index > position)
                        {
                            current = current->last;
                            index--;
                        }
                    }
 
                    FNode<T>* last = current->last;
                    FNode<T>* next = current->next;
 
                    if (next) next->last = last;
                    if (last) last->next = next;
 
                    delete current;
                    current = nullptr;
                }
 
                this->count--;
            }
        }
 
        inline void Clear()
        {
            if (this->head)
            {
                FNode<T>* current = this->head;
                FNode<T>* next = 0;
 
                while (current) {
                    next = current;
                    current = current->next;
                    
                    delete next;
                    next = nullptr;
                }
            }
        }
 
        inline const type_info& GetType() override                             
        {
            return typeid(FList);
        }
 
        inline FString GetName() const override                                
        {
            return typeid(FList).name();
        }
 
    private:
        FNode<T>* head;                                                        
        FNode<T>* tail;                                                        
        ULLong count;                                                          
};
 
#endif // FLIST_H