queue.h

Go to the documentation of this file.

#pragma once
 
#include "fl/stl/deque.h"
#include "fl/stl/move.h"
#include "fl/stl/noexcept.h"
namespace fl {

template <typename T, typename Container = fl::deque<T>>
class queue {
public:
    using value_type = T;
    using size_type = fl::size;
    using reference = T&;
    using const_reference = const T&;
    using container_type = Container;
 
private:
    Container mContainer;
 
public:
    queue() FL_NOEXCEPT = default;

    explicit queue(const Container& container) : mContainer(container) {}

    explicit queue(Container&& container) : mContainer(fl::move(container)) {}

    queue(const queue& other) FL_NOEXCEPT = default;

    queue(queue&& other) FL_NOEXCEPT = default;

    queue& operator=(const queue& other) FL_NOEXCEPT = default;

    queue& operator=(queue&& other) FL_NOEXCEPT = default;

    ~queue() FL_NOEXCEPT = default;

    reference front() {
        return mContainer.front();
    }

    const_reference front() const {
        return mContainer.front();
    }

    reference back() {
        return mContainer.back();
    }

    const_reference back() const {
        return mContainer.back();
    }

    bool empty() const {
        return mContainer.empty();
    }

    size_type size() const {
        return mContainer.size();
    }

    void push(const value_type& value) {
        mContainer.push_back(value);
    }

    void push(value_type&& value) {
        mContainer.push_back(fl::move(value));
    }

    template<typename... Args>
    void emplace(Args&&... args) {
        mContainer.emplace_back(fl::forward<Args>(args)...);
    }

    void pop() {
        mContainer.pop_front();
    }

    void swap(queue& other) {
        mContainer.swap(other.mContainer);
    }

    void clear() {
        mContainer.clear();
    }

    Container& get_container() {
        return mContainer;
    }

    const Container& get_container() const {
        return mContainer;
    }

    bool operator==(const queue& other) const {
        return mContainer == other.mContainer;
    }

    bool operator!=(const queue& other) const {
        return mContainer != other.mContainer;
    }

    bool operator<(const queue& other) const {
        return mContainer < other.mContainer;
    }

    bool operator<=(const queue& other) const {
        return mContainer <= other.mContainer;
    }

    bool operator>(const queue& other) const {
        return mContainer > other.mContainer;
    }

    bool operator>=(const queue& other) const {
        return mContainer >= other.mContainer;
    }
};

template <typename T, typename Container>
void swap(queue<T, Container>& lhs, queue<T, Container>& rhs) {
    lhs.swap(rhs);
}

template <typename T, typename Container>
bool operator==(const queue<T, Container>& lhs, const queue<T, Container>& rhs) {
    return lhs.get_container() == rhs.get_container();
}

template <typename T, typename Container>
bool operator!=(const queue<T, Container>& lhs, const queue<T, Container>& rhs) {
    return lhs.get_container() != rhs.get_container();
}

template <typename T, typename Container>
bool operator<(const queue<T, Container>& lhs, const queue<T, Container>& rhs) {
    return lhs.get_container() < rhs.get_container();
}

template <typename T, typename Container>
bool operator<=(const queue<T, Container>& lhs, const queue<T, Container>& rhs) {
    return lhs.get_container() <= rhs.get_container();
}

template <typename T, typename Container>
bool operator>(const queue<T, Container>& lhs, const queue<T, Container>& rhs) {
    return lhs.get_container() > rhs.get_container();
}

template <typename T, typename Container>
bool operator>=(const queue<T, Container>& lhs, const queue<T, Container>& rhs) {
    return lhs.get_container() >= rhs.get_container();
}
 
} // namespace fl