This library provides few classes to better deal with the producer/consumer pattern.

Defined in header <haz/SharedQueue.hpp>

template<
    class T,
    std::size_t N
> class SharedQueue;

SharedQueue is an fixed size queue with additional functions to controle multiple access at the same time. The elements are stored contiguously in a buffer of size N, but are not in order. The iterators will iterate through the collection in order of insertion though.

Complexity: - Insertion at the beginning and removal at the end of elements: constant O(1) - Random Access: constant O(1)

T: The type of the elements N: The maximum number of element in the buffer

It is recommended to use a power of 2 for the size S so the index is computed faster.

constexpr size_type capacity() const noexcept;

Returns the maximum number of element in the container.

(none)

Maximum number of elements.

Constant.

For haz::SharedQueue<T, N>, the value returned is S.
It's a synonym of max_size.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue;
    std::cout << "The capacity of the queue is " << queue.capacity() << '\n';
}

Output:

The capacity of the queue is 10

constexpr size_type max_size() const noexcept;

Returns the maximum number of element in the container.

(none)

Maximum number of elements.

Constant.

For haz::SharedQueue<T, N>, the value returned is S.
It's a synonym of capacity.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue;
    std::cout << "The maximum size of the queue is " << queue.max_size() << '\n';
}

Output:

The maximum size of the queue is 10

constexpr size_type size() const noexcept;

Returns the number of elements in the container.

(none)

The number of elements in a SharedQueue.

Constant.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue{ 0, 1, 2 };
    std::cout << "The queue contains " << queue.size() << " elements\n";
}

Output:

The queue contains 3 elements

constexpr bool empty() const noexcept;

Checks whether the container has no elements.

(none)

true if the element is empty, otherwise false.

Constant.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> empty_queue;
    haz::SharedQueue<int, 10> not_empty_queue{ 0, 1, 2 };
    std::cout << "empty_queue is empty ? " << empty_queue.empty() << '\n';
    std::cout << "not_empty_queue is empty ? " << not_empty_queue.empty() << '\n';
}

Output:

empty_queue is empty ? 1
not_empty_queue is empty ? 0

constexpr const_reference front() const noexcept;
constexpr reference front() noexcept;

Returns the first element of the container. Calling front on an empty container is undefined.

(none)

Reference to the first element.

Constant.

The element returned is the first element that has been pushed but not poped yet.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue{ 0, 1, 2 };
    std::cout << "The first element is " << queue.front() << '\n';
}

Output:

The first element is 0

constexpr const_reference back() const noexcept;
constexpr reference back() noexcept;

Returns the last element of the container. Calling back on an empty container is undefined.

(none)

Reference to the last element.

Constant.

The element returned is the last element that has been pushed.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue{ 0, 1, 2 };
    std::cout << "The last element is " << queue.back() << '\n';
}

Output:

The last element is 2

constexpr const_reference at(size_type index) const;
constexpr reference at(size_type index);

Returns the number a reference to the element at the index specified. If the index is not within the range [0, size()), an exception of type std::out_of_range is thrown.

Reference to the requested element.

std::out_of_range if index >= size().

Constant.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue{ 0, 1, 2 };
    std::cout << "The second element is " << queue.at(1) << '\n';
}

Output:

The second element is 1

constexpr const_reference operator[](size_type index) const noexcept;
constexpr reference operator[](size_type index) noexcept;

Returns the number a reference to the element at the index specified.

Reference to the requested element.

Constant.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue{ 0, 1, 2 };
    std::cout << "The second element is " << queue[1] << '\n';
}

Output:

The second element is 1

template<typename InputIt>
constexpr void assign(InputIt first, InputIt last) noexcept(/* see below */);           (1)
constexpr void assign(size_type n, T const& value) noexcept(/* see below */);           (2)
constexpr void assign(std::initilializer_list<T> list) noexcept(/* see below */);       (3)

Replaces the content of the container.
    (1) Copy each element in the range [first, last) to the container
    (2) Replaces the content with n copies of value
    (3) Replaces the content with those in the list

(none)

noexcept specification: noexcept(is_nothrow_constructible_v<decltype(*std::declval<InputIt>)>) for (1)
noexcept(is_nothrow_copy_constructible_v<T>) for (2-3)

    (1) Linear in distance between first and last
    (2) Linear in n
    (3) Linear in list.size()

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue{ 0, 1, 2 };

    std::cout << "Contents:\n";
    for(auto i : queue) {
        std::cout << i << ", ";
    }
    std::cout << '\n';

    queue.assign(5, 1337);

    std::cout << "Contents:\n";
    for(auto i : queue) {
        std::cout << i << ", ";
    }
    std::cout << '\n';
}

Output:

Contents:
0, 1, 2,
Contents:
1337, 1337, 1337, 1337, 1337,

constexpr void clear() noexcept;

Remove all elements of the container. After that size() returns 0. Invalidate all iterators, references and pointers.

(none)

(none)

Constant if the elements are trivially destructible, otherwise linear in the size of the container.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue{ 0, 1, 2 };
    std::cout << "Size before : " << queue.size() << '\n';
    queue.clear();
    std::cout << "Size after : " << queue.size() << '\n';
}

Output:

Size before : 3
Size afer : 0

void push_back(T const& value);     (1)
void push_back(T&& value);          (2)

Insert the element at the end of the container.
    (1) The new element is initialized as a copy of value
    (2) value is moved into the new element

All iterators past-the-end, end included, are invalidated. No reference are invalidated. If the container is full, i.e. size() == max_size() then the behaviour is undefined.

T must meet the requirements of CopyInsertable in order to use overload (1).
T must meet the requirements of MoveInsertable in order to use overload (2).

(none)

Constant.

If an exception is thrown, this function has no effect (strong exception guarantee).

#include <haz/SharedQueue.hpp>
#include <iostream>
#include <string>

int main() {
    haz::SharedQueue<std::string, 10> queue;
    
    queue.push_back("abc");
    
    std::string s = "def";
    queue.push_back(std::move(s));

    std::cout << "Contents:\n";
    for(auto const& i : queue) {
        std::cout << std::quoted(i) << '\n';
    }
}

Output:

Contents:
"abc"
"def"

constexpr void pop_front() noexcept;

Removes the first element of the container. If there are no elements in the container, the behaviour is undefined. Iterator and reference to the erased element are invalidated. The other are not unless the container is now empty.

(none)

(none)

Constant.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue{ 0, 1, 2, 3 };
    std::cout << "Contents:\n";
    for(auto i : queue) {
        std::cout << i << '\n';
    }

    std::cout << "Pop 2 values\n";
    queue.pop_front();
    queue.pop_front();

    std::cout << "Contents:\n";
    for(auto i : queue) {
        std::cout << i << ", ";
    }
    std::cout << '\n';
}

Output:

Contents:
0, 1, 2, 3,
Pop 2 values
Contents:
2, 3,

template<typename...Args>
reference emplace_back(Args&&... args);

Construct a new element at the end of the container. The element is constructed in place using placement-new. The arguments args... are forwarded to the constructor using std::forward<Args>(args).... All iterators past-the-end, end included, are invalidated. No reference are invalidated. If the container is full, i.e. size() == max_size() then the behaviour is undefined.

T (the container's element type) must meet the requirement of EmplaceConstructible.

Reference to the inserted element.

Constant.

If an exception is thrown, this function has no effect (strong exception guarantee).

#include <haz/SharedQueue.hpp>
#include <iostream>
#include <string>

struct Person {
    std::string name;
    unsigned age;

    Person(std::string name, unsigned age) : name(name), age(age) {
        std::cout << "A person is constructed!\n";
    }

    Person(Person&& other) : name(std::move(other.name)), age(other.age) {
        std::cout << "A person is moved!\n";
    }

    Person& operator=(Person const& other) = default;
};

int main() {
    haz::SharedQueue<Person, 10> queue;

    std::cout << "emplace_back:\n";
    queue.emplace_back("John", 32);

    std::cout << "\npush_back:\n";
    queue.push_back(Person("Bob", 47));

    std::cout << "\nContents:\n";
    for(auto const& person : queue) {
        std::cout << person.name << " is " << person.age << '\n';
    }
}

Output:

emplace_back: 
A person is constructed!

push_back: 
A person is constructed!
A person is moved!

Contents:
John is 32
Bob is 47

constexpr void swap(SharedQueue& other) noexcept(/* see below */);

Exchanges the contents of the container with those of other. Does not cause iterators and references to associate with the other container.

(none)

noexcept specification: noexcept(is_nothrow_swappable_v<T>)

Linear in the size of the container.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue_a{ 0, 1, 2, 3 };
    haz::SharedQueue<int, 10> queue_b{ 4, 5, 6 };
    std::cout << "Contents of A:\n";
    for(auto i : queue_a) {
        std::cout << i << ", ";
    }
    std::cout << '\n';
    std::cout << "Contents of B:\n";
    for(auto i : queue_b) {
        std::cout << i << ", ";
    }
    std::cout << '\n';

    std::cout << "Swap\n";
    queue_a.swap(queue_b);

    std::cout << "Contents of A:\n";
    for(auto i : queue_a) {
        std::cout << i << ", ";
    }
    std::cout << '\n';
    std::cout << "Contents of B:\n";
    for(auto i : queue_b) {
        std::cout << i << ", ";
    }
    std::cout << '\n';
}

Output:

Contents of A:
0, 1, 2, 3,
Contents of B:
4, 5, 6,
Swap
Contents of A:
4, 5, 6,
Contents of B:
0, 1, 2, 3,

constexpr iterator begin() noexcept();
constexpr const_iterator begin() const noexcept();
constexpr const_iterator cbegin() const noexcept();

Returns an iterator to the first element of the container. If the container is empty, the returned iterator will be equal to end()

(none)

Iterator to the first element.

Constant.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue{ 0, 1, 2, 3 };
    for(typename haz::SharedQueue<int, 10>::iterator it = queue.begin(); it != queue.end(); ++it)
        std::cout << *it << ", ";
    std::cout << '\n';
}

Output:

0, 1, 2, 3,

constexpr iterator end() noexcept();
constexpr const_iterator end() const noexcept();
constexpr const_iterator cend() const noexcept();

Returns an iterator to the element following the last element of the container. This element acts as a placeholder; attempting to access it results in undefined behaviour, it is not dereferencable.

(none)

Iterator to the element following the last element.

Constant.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue{ 0, 1, 2, 3 };
    for(typename haz::SharedQueue<int, 10>::iterator it = queue.begin(); it != queue.end(); ++it)
        std::cout << *it << ", ";
    std::cout << '\n';
}

Output:

0, 1, 2, 3,

constexpr reverse_iterator rbegin() noexcept();
constexpr const_reverse_iterator rbegin() const noexcept();
constexpr const_reverse_iterator crbegin() const noexcept();

Returns an iterator to the first element of the reversed container. It corresponds to the last element of the non-reversed container. If the container is empty, the returned iterator will be equal to rend()

(none)

Reverse iterator to the first element.

Constant.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue{ 0, 1, 2, 3 };
    for(typename haz::SharedQueue<int, 10>::reverse_iterator it = queue.rbegin(); it != queue.rend(); ++it)
        std::cout << *it << ", ";
    std::cout << '\n';
}

Output:

3, 2, 1, 0,

constexpr reverse_iterator rend() noexcept();
constexpr const_reverse_iterator rend() const noexcept();
constexpr const_reverse_iterator crend() const noexcept();

Returns a reverse iterator to the element following the last element of the reversed container. It corresponds to the element preceding the first element of the non-reversed container. This element acts as a placeholder; attempting to access it results in undefined behaviour, it is not dereferencable.

(none)

reverse iterator to the element following the last element.

Constant.

#include <haz/SharedQueue.hpp>
#include <iostream>

int main() {
    haz::SharedQueue<int, 10> queue{ 0, 1, 2, 3 };
    for(typename haz::SharedQueue<int, 10>::reverse_iterator it = queue.rbegin(); it != queue.rend(); ++it)
        std::cout << *it << ", ";
    std::cout << '\n';
}

Output:

3, 2, 1, 0,

template<typename T, std::size_t N>
constexpr bool operator==(haz::SharedQueue<T, N> const& lhs, haz::SharedQueue<T, N> const& rhs) noexcept();         (1)
template<typename T, std::size_t N>
constexpr bool operator!=(haz::SharedQueue<T, N> const& lhs, haz::SharedQueue<T, N> const& rhs) noexcept();         (2)
template<typename T, std::size_t N>
constexpr bool operator<(haz::SharedQueue<T, N> const& lhs, haz::SharedQueue<T, N> const& rhs) noexcept();         (3)
template<typename T, std::size_t N>
constexpr bool operator<=(haz::SharedQueue<T, N> const& lhs, haz::SharedQueue<T, N> const& rhs) noexcept();         (4)
template<typename T, std::size_t N>
constexpr bool operator>(haz::SharedQueue<T, N> const& lhs, haz::SharedQueue<T, N> const& rhs) noexcept();         (5)
template<typename T, std::size_t N>
constexpr bool operator>=(haz::SharedQueue<T, N> const& lhs, haz::SharedQueue<T, N> const& rhs) noexcept();         (6)

Compare the contents of two queue.     (1-2) Checks if the contents of lhs and rhs are equal, that is, whether each element in lhs compares equals with the element in rhs at the same position.     (3-6) Compares the contents of lhs and rhs lexicographically. The comparaison is performed by a function equivalent to std::lexicographical_compare.

T must meet the requirements of EqualityComparable in order to use overload (1-2).
T must meet the requirements of LessThanComparable in order to use overload (3-6).

(1) true if the contents of the containers are equal, false otherwise.
(2) true if the contents of the containers are not equal, false otherwise.
(3) true if the contents of the lhs are lexicographically less than the contents of rhs, false otherwise.
(4) true if the contents of the lhs are lexicographically less than or equal the contents of rhs, false otherwise.
(5) true if the contents of the lhs are lexicographically greater than the contents of rhs, false otherwise.
(6) true if the contents of the lhs are lexicographically greater than or equal the contents of rhs, false otherwise.

Constant.

template<typename T, std::size_t N>
void swap(haz::SharedQueue<T, N> const& lhs, haz::SharedQueue<T, N> const& rhs) noexcept(/* see below */);

Specialize the std::swap algorithm for haz::SharedQueue. Swaps the contents of lhs and rhs. Calls lhs.swap(rhs).

(none)

Constant.

noexcept specification: noexcept(noexcept(lhs.swap(rhs)))

#include <haz/SharedQueue.hpp>
#include <iostream>
#include <algorithm>

int main() {
    haz::SharedQueue<int, 10> queue_a{ 0, 1, 2, 3 };
    haz::SharedQueue<int, 10> queue_b{ 4, 5, 6 };
    std::cout << "Contents of A:\n";
    for(auto i : queue_a) {
        std::cout << i << ", ";
    }
    std::cout << '\n';
    std::cout << "Contents of B:\n";
    for(auto i : queue_b) {
        std::cout << i << ", ";
    }
    std::cout << '\n';

    std::cout << "Swap\n";
    std::swap(queue_a, queue_b);

    std::cout << "Contents of A:\n";
    for(auto i : queue_a) {
        std::cout << i << ", ";
    }
    std::cout << '\n';
    std::cout << "Contents of B:\n";
    for(auto i : queue_b) {
        std::cout << i << ", ";
    }
    std::cout << '\n';
}

Output:

Contents of A:
0, 1, 2, 3,
Contents of B:
4, 5, 6,
Swap
Contents of A:
4, 5, 6,
Contents of B:
0, 1, 2, 3,