Circular.h Source File¶

Simu5G: Circular.h Source File
Simu5G
//
//                  Simu5G
//
// Copyright (C) 2012-2021 Giovanni Nardini, Giovanni Stea, Antonio Virdis et al. (University of Pisa)
// Copyright (C) 2022-2026 Giovanni Nardini, Giovanni Stea et al. (University of Pisa)
//
// This file is part of a software released under the license included in file
// "license.pdf". Please read LICENSE and README files before using it.
// The above files and the present reference are part of the software itself,
// and cannot be removed from it.
//
 
#ifndef _LTE_CIRCULAR_H_
#define _LTE_CIRCULAR_H_
 
#include <list>
#include <assert.h>
 
namespace simu5g {
template<typename T>
class CircularList
{
    std::list<T> list_;
    typename std::list<T>::iterator cur_;
    unsigned int size_ = 0;
 
  public:
    CircularList() : cur_(list_.begin())
    {
    }
    CircularList(const CircularList<T>& cl) : list_(cl.list_), cur_(list_.begin()), size_(cl.size_)
    {
        auto it = cl.list_.begin();
        if (size_ != 0) {
            while (it != cl.cur_) {
                ++it;
                ++cur_;
            }
        }
    }
    CircularList& operator=(const CircularList<T>& cl)
    {
        list_ = cl.list_;
        size_ = cl.size_;
        auto it = cl.list_.begin();
        cur_ = list_.begin();
        if (size_ != 0) {
            while (it != cl.cur_) {
                ++it;
                ++cur_;
            }
        }
        return *this;
    }
    bool empty()
    {
        return size_ == 0;
    }
    unsigned int size()
    {
        return size_;
    }
    void clear()
    {
        list_.clear();
        size_ = 0;
    }
    bool find(const T& t)
    {
        if (size_ == 0)
            return false;
        for (const auto& element : list_) {
            if (element == t) {
                return true;
            }
        }
        return false;
    }
    T& find(T& t, bool& valid)
    {
        if (size_ == 0) {
            valid = false;
            return t;
        }
        for (const auto& element : list_) {
            if (element == t) {
                valid = true;
                return const_cast<T&>(element);
            }
        }
        valid = false;
        return t;
    }
    void insert(const T& t)
    {
        if (size_ == 0) {
            list_.push_back(t);
            cur_ = list_.begin();
        }
        else
            list_.insert(cur_, t);
        ++size_;
    }
    void erase()
    {
        if (size_ == 0)
            return;
        typename std::list<T>::iterator drop = cur_++;
        if (cur_ == list_.end())
            cur_ = list_.begin();
        list_.erase(drop);
        --size_;
    }
    void eraseElem(T& t)
    {
        if (size_ == 0)
            return;
        for (auto it = list_.begin(); it != list_.end();) {
            if (*it == t) {
                if (cur_ == it) {
                    cur_++;
                    if (cur_ == list_.end())
                        cur_ = list_.begin();
                }
                it = list_.erase(it);
                --size_;
                return;
            } else {
                ++it;
            }
        }
    }
    void rewind()
    {
        cur_ = list_.begin();
    }
    void move()
    {
        if (size_ > 0 && ++cur_ == list_.end())
            cur_ = list_.begin();
    }
    const T& current() const
    {
        assert(size_ > 0);
        return *cur_;
    }
    T& current()
    {
        assert(size_ > 0);
        return *cur_;
    }
    void insertFront(const T& t)
    {
        if (size_ == 0) {
            list_.push_back(t);
            cur_ = list_.begin();
        }
        else {
            typename std::list<T>::iterator temp = cur_;
            ++temp;
            list_.insert(temp, t);
        }
        ++size_;
    }
 
};
 
} //namespace
 
#endif // _LTE_CIRCULAR_H_
 