queue.h

Go to the documentation of this file.

 
#ifndef QUEUE_H
#define QUEUE_H
 
#include "list.h"
 
#include <initializer_list>
#include <iostream>
#include <utility>
 
namespace dsa
{
    template<typename T>
    class Queue;
 
    template<typename T>
    auto operator==(const Queue<T>& queue1, const Queue<T>& queue2) -> bool;
 
    template<typename T>
    auto operator<(const Queue<T>& queue1, const Queue<T>& queue2) -> bool;

    template<typename T>
    class Queue
    {
    public:

        using value_type = T;

        using reference = T&;

        using const_reference = const T&;

        Queue() = default;

        Queue(const std::initializer_list<T>& init_list);

        Queue(const Queue<T>& other);

        auto operator=(const Queue<T>& other) -> Queue&;

        Queue(Queue<T>&& other) noexcept;

        auto operator=(Queue<T>&& other) noexcept -> Queue&;

        ~Queue() = default;

        auto front() -> reference;

        [[nodiscard]] auto front() const -> const_reference;

        auto back() -> reference;

        [[nodiscard]] auto back() const -> const_reference;

        [[nodiscard]] auto empty() const -> bool;

        [[nodiscard]] auto size() const -> size_t;

        void push(const_reference value);

        void push(T&& value);

        void pop();

        void swap(Queue<T>& other) noexcept;

        auto operator+=(const Queue<T>& other) -> Queue<T>&;

        auto operator+=(const std::initializer_list<T>& init_list) -> Queue<T>&;
 
    private:

        friend auto operator==<T>(const Queue<T>& queue1, const Queue<T>& queue2) -> bool;

        friend auto operator< <T>(const Queue<T>& queue1, const Queue<T>& queue2) -> bool;
 
        List<T> container{};
    };
 
    template<typename T>
    Queue<T>::Queue(const std::initializer_list<T>& init_list)
    {
        for (const auto& item : init_list)
        {
            container.push_back(item);
        }
    }
 
    template<typename T>
    Queue<T>::Queue(const Queue<T>& other)
    {
        if (other.size() >= 1)
        {
            for (const auto& item : other.container)
            {
                container.push_back(item);
            }
        }
    }
 
    template<typename T>
    auto Queue<T>::operator=(const Queue<T>& other) -> Queue<T>&
    {
        if (&other != this)
        {
            while (!container.empty())
            {
                container.pop_front();
            }
 
            for (const auto& item : other.container)
            {
                container.push_back(item);
            }
        }
 
        return *this;
    }
 
    template<typename T>
    Queue<T>::Queue(Queue<T>&& other) noexcept
        : container{ std::move(other.container) }
    {
    }
 
    template<typename T>
    auto Queue<T>::operator=(Queue<T>&& other) noexcept -> Queue<T>&
    {
        if (&other != this)
        {
            container = std::move(other.container);
        }
 
        return *this;
    }
 
    template<typename T>
    auto Queue<T>::front() -> typename Queue<T>::reference
    {
        return container.front();
    }
 
    template<typename T>
    auto Queue<T>::front() const -> typename Queue<T>::const_reference
    {
        return container.front();
    }
 
    template<typename T>
    auto Queue<T>::back() -> typename Queue<T>::reference
    {
        return container.back();
    }
 
    template<typename T>
    auto Queue<T>::back() const -> typename Queue<T>::const_reference
    {
        return container.back();
    }
 
    template<typename T>
    auto Queue<T>::empty() const -> bool
    {
        return container.size() == 0;
    }
 
    template<typename T>
    auto Queue<T>::size() const -> size_t
    {
        return container.size();
    }
 
    template<typename T>
    void Queue<T>::push(const_reference value)
    {
        container.push_back(value);
    }
 
    template<typename T>
    void Queue<T>::push(T&& value)
    {
        container.push_back(std::move(value));
    }
 
    template<typename T>
    void Queue<T>::pop()
    {
        container.pop_front();
    }
 
    template<typename T>
    void Queue<T>::swap(Queue<T>& other) noexcept
    {
        if (&other != this)
        {
            std::swap(container, other.container);
        }
    }
 
    template<typename T>
    auto Queue<T>::operator+=(const Queue<T>& other) -> Queue<T>&
    {
        for (const auto& item : other.container)
        {
            push(item);
        }
 
        return *this;
    }

    template<typename T>
    auto operator<<(std::ostream& out, const Queue<T>& queue) -> std::ostream&
    {
        Queue<T> temp{ queue };
 
        while (!temp.empty())
        {
            out << temp.front() << ' ';
            temp.pop();
        }
 
        return out;
    }

    template<typename T>
    auto operator==(const Queue<T>& queue1, const Queue<T>& queue2) -> bool
    {
        return queue1.container == queue2.container;
    }

    template<typename T>
    auto operator!=(const Queue<T>& queue1, const Queue<T>& queue2) -> bool
    {
        return !(operator==(queue1, queue2));
    }

    template<typename T>
    auto operator<(const Queue<T>& queue1, const Queue<T>& queue2) -> bool
    {
        return queue1.container < queue2.container;
    }

    template<typename T>
    auto operator>(const Queue<T>& queue1, const Queue<T>& queue2) -> bool
    {
        return operator<(queue2, queue1);
    }

    template<typename T>
    auto operator<=(const Queue<T>& queue1, const Queue<T>& queue2) -> bool
    {
        return !(operator>(queue1, queue2));
    }

    template<typename T>
    auto operator>=(const Queue<T>& queue1, const Queue<T>& queue2) -> bool
    {
        return !(operator<(queue1, queue2));
    }
 
}
#endif // !QUEUE_H