2 ha cambiato i file con 384 aggiunte e 0 eliminazioni
-
+193 -0include/cont/deque.h
-
+191 -0test/tests/deque.cpp
+ 193
- 0
include/cont/deque.h
Vedi File
| @@ -0,0 +1,193 @@ | |||
| /*! | |||
| * \file cont/deque.h | |||
| * \brief | |||
| * A statically allocated deque based on a ring buffer. | |||
| * | |||
| * \copyright Copyright (C) 2021 Christos Choutouridis <christos@choutouridis.net> | |||
| * | |||
| * <dl class=\"section copyright\"><dt>License</dt><dd> | |||
| * The MIT License (MIT) | |||
| * | |||
| * Permission is hereby granted, free of charge, to any person obtaining a copy | |||
| * of this software and associated documentation files (the "Software"), to deal | |||
| * in the Software without restriction, including without limitation the rights | |||
| * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |||
| * copies of the Software, and to permit persons to whom the Software is | |||
| * furnished to do so, subject to the following conditions: | |||
| * | |||
| * The above copyright notice and this permission notice shall be included in all | |||
| * copies or substantial portions of the Software. | |||
| * | |||
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |||
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |||
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |||
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |||
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |||
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |||
| * SOFTWARE. | |||
| * </dd></dl> | |||
| */ | |||
| #ifndef TBX_CONT_DEQUE_H_ | |||
| #define TBX_CONT_DEQUE_H_ | |||
| #include <core/core.h> | |||
| #include <core/ring_iterator.h> | |||
| #include <array> | |||
| namespace tbx { | |||
| /*! | |||
| * \class deque | |||
| * \brief | |||
| * A statically allocated deque based on a ring buffer | |||
| * | |||
| * The deque uses two ring_iterators one for the front and one for the rear. The iterators | |||
| * are pointing to the next available spot, not on the last inserted spot. This way at the | |||
| * initialization the iterators wont "pretend" to point to a valid item . | |||
| * | |||
| * We use a ring buffer of size \c N+1. We start the front iterator at the last location of the buffer | |||
| * and the rear on the first. This way when the queue is full the iterators are pointing to the same location. | |||
| * | |||
| * \tparam Data_t The char-like queued item type. Usually \c char | |||
| * \tparam N The size of deque | |||
| */ | |||
| template <typename Data_t, size_t N> | |||
| class deque { | |||
| public: | |||
| // meta-identity type | |||
| using type = deque<Data_t, N>; | |||
| using buffer_t = std::array<Data_t, N+1>; // We need N+1 spaces ring buffer for N spaces deque | |||
| using iterator_t = ring_iterator<Data_t*, N+1>; | |||
| // STL | |||
| using value_type = Data_t; | |||
| using reference = Data_t&; | |||
| using const_reference = const Data_t&; | |||
| using pointer = Data_t*; | |||
| using const_pointer = const Data_t*; | |||
| using iterator = iterator_t; | |||
| using const_iterator = const iterator_t; | |||
| using reverse_iterator = std::reverse_iterator<iterator>; | |||
| using const_reverse_iterator = std::reverse_iterator<const_iterator>; | |||
| //! \name Constructor / Destructor | |||
| //! @{ | |||
| public: | |||
| //! Default constructor | |||
| deque () noexcept : | |||
| data_{}, | |||
| f{data_.data(), N}, | |||
| r{data_.data()} { } | |||
| //! fill contructor | |||
| deque(const Data_t& value) noexcept { | |||
| data_.fill(value); | |||
| f = iterator(data_.data(), N); | |||
| r = iterator(data_.data(), N); | |||
| } | |||
| //! Initializer list contructor | |||
| template <typename ...It> | |||
| deque(It&& ...it) noexcept : | |||
| data_{{std::forward<It>(it)...}}, | |||
| f(data_.data(), sizeof...(It)), | |||
| r(data_.data(), sizeof...(It)) { } | |||
| deque(const deque&) = delete; //!< No copies | |||
| deque& operator= (const deque&) = delete; //!< No copy assignments | |||
| ~deque () = default; //!< default destructor | |||
| //! @} | |||
| //! \name Iterators | |||
| //! @{ | |||
| public: | |||
| iterator begin() noexcept { return f+1; } | |||
| const_iterator begin() const noexcept { return f+1; } | |||
| const_iterator cbegin() const noexcept { return f+1; } | |||
| iterator end() noexcept { return r; } | |||
| const_iterator end() const noexcept { return r; } | |||
| const_iterator cend() const noexcept { return r; } | |||
| reverse_iterator rbegin() noexcept { return r; } | |||
| const_reverse_iterator rbegin() const noexcept { return r; } | |||
| const_reverse_iterator crbegin() const noexcept { return r; } | |||
| reverse_iterator rend() noexcept { return f+1; } | |||
| const_reverse_iterator rend() const noexcept { return f+1; } | |||
| const_reverse_iterator crend() const noexcept { return f+1; } | |||
| //! @} | |||
| //! \name Capacity | |||
| //! @{ | |||
| public: | |||
| //! \return The size of the deque. The items currently in queue. | |||
| size_t size() noexcept { | |||
| return full() ? N: (r - f) -1; | |||
| } | |||
| //! \return The maximum size of the deque. The items the queue can hold. | |||
| size_t max_size() noexcept { return N; } | |||
| //! \return The capacity of the deque. The items the queue can hold. | |||
| size_t capacity() noexcept { return N; } | |||
| //! \return True if the deque is empty | |||
| bool empty() noexcept { return size() == 0 ? true : false; } | |||
| //! \return True if the deque is full | |||
| bool full() noexcept { return (r == f) ? true : false; } | |||
| //! @} | |||
| //! \name Member access | |||
| //! @{ | |||
| public: | |||
| //! \brief Clears-empty the deque and return it to init state, without | |||
| //! really deleting the contents. | |||
| void clear() noexcept { | |||
| f = iterator_t(data_.data(), N); | |||
| r = iterator_t(data_.data()); | |||
| } | |||
| //! \brief Push an item in the front of the deque | |||
| //! \param it The item to push | |||
| void push_front (const Data_t& it) { | |||
| if (full()) return; | |||
| *f-- = it; | |||
| } | |||
| //! \brief Extract an item from the front of the deque and remove it from the deque | |||
| //! \param it The item to push | |||
| Data_t pop_front () { | |||
| if (empty()) return Data_t{}; | |||
| return *++f; | |||
| } | |||
| //! \brief Push an item in the back of the deque | |||
| //! \param it The item to push | |||
| void push_back (const Data_t& it) { | |||
| if (full()) return; | |||
| *r++ = it; | |||
| } | |||
| //! \brief Extract an item from the back of the deque and remove it from the deque | |||
| //! \param it The item to push | |||
| Data_t pop_back () { | |||
| if (empty()) return Data_t{}; | |||
| return *--r; | |||
| } | |||
| //! \brief Get a reference to the item in the front of the deque without extracting it. | |||
| //! \return Reference to the item | |||
| Data_t& front() noexcept { return *(f+1); } | |||
| const Data_t& front() const noexcept { return *(f+1); } | |||
| //! \brief Get a reference to the item in the front of the deque without extracting it. | |||
| //! \return Reference to the item | |||
| Data_t& back() noexcept { return *(r-1); } | |||
| const Data_t& back() const noexcept { return *(r-1); } | |||
| //! @} | |||
| private: | |||
| buffer_t data_{}; //!< The statically allocated buffer | |||
| iterator_t f{data_.data(), N}; //!< A ring iterator for the front (points to the next available location) | |||
| iterator_t r{data_.data()}; //!< A ring iterator for the rear (points to the next available location). | |||
| }; | |||
| } | |||
| #endif /* TBX_CONT_ADEQUE_H_ */ | |||
+ 191
- 0
test/tests/deque.cpp
Vedi File
| @@ -0,0 +1,191 @@ | |||
| /*! | |||
| * \file deque.cpp | |||
| * \brief | |||
| * Unit tests for deque | |||
| * | |||
| * \copyright Copyright (C) 2020 Christos Choutouridis <christos@choutouridis.net> | |||
| * | |||
| * <dl class=\"section copyright\"><dt>License</dt><dd> | |||
| * The MIT License (MIT) | |||
| * | |||
| * Permission is hereby granted, free of charge, to any person obtaining a copy | |||
| * of this software and associated documentation files (the "Software"), to deal | |||
| * in the Software without restriction, including without limitation the rights | |||
| * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |||
| * copies of the Software, and to permit persons to whom the Software is | |||
| * furnished to do so, subject to the following conditions: | |||
| * | |||
| * The above copyright notice and this permission notice shall be included in all | |||
| * copies or substantial portions of the Software. | |||
| * | |||
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |||
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |||
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |||
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |||
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |||
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |||
| * SOFTWARE. | |||
| * </dd></dl> | |||
| * | |||
| */ | |||
| #include <cont/deque.h> | |||
| #include <gtest/gtest.h> | |||
| namespace Tdeque { | |||
| using namespace tbx; | |||
| // Test construction | |||
| TEST(Tdeque, contruct) { | |||
| deque<int, 8> q1; | |||
| deque<int, 8> q2{1, 2, 3, 4, 5, 6, 7, 8}; | |||
| EXPECT_EQ (8UL, q1.capacity()); | |||
| EXPECT_EQ (8UL, q2.capacity()); | |||
| } | |||
| // simple push-pop functionality | |||
| TEST(Tdeque, push_pop) { | |||
| deque<int, 8> q1; | |||
| deque<int, 8> q2{1, 2, 3, 4, 5, 6, 7, 8}; | |||
| q1.push_front(1); | |||
| q1.push_front(2); | |||
| EXPECT_EQ (1, q1.pop_back()); | |||
| EXPECT_EQ (2, q1.pop_back()); | |||
| q1.push_back(1); | |||
| q1.push_back(2); | |||
| EXPECT_EQ (1, q1.pop_front()); | |||
| EXPECT_EQ (2, q1.pop_front()); | |||
| q1.push_front(2); | |||
| q1.push_back(3); | |||
| q1.push_front(1); | |||
| q1.push_back(4); | |||
| for (int i=1 ; i<= 4 ; ++i) | |||
| EXPECT_EQ ((int)i, q1.pop_front()); | |||
| } | |||
| // front-back | |||
| TEST(Tdeque, front_back) { | |||
| deque<int, 8> q1; | |||
| deque<int, 8> q2{1, 2, 3, 4, 5, 6, 7, 8}; | |||
| q1.push_front(2); | |||
| q1.push_front(1); | |||
| q1.push_back(3); | |||
| q1.push_back(4); | |||
| EXPECT_EQ (1, q1.front()); | |||
| EXPECT_EQ (4, q1.back()); | |||
| EXPECT_EQ (1, q2.front()); | |||
| EXPECT_EQ (8, q2.back()); | |||
| } | |||
| // capacity | |||
| TEST(Tdeque, capacity) { | |||
| deque<int, 8> q1; | |||
| deque<int, 8> q2{1, 2, 3, 4, 5, 6, 7, 8}; | |||
| q1.push_back(1); | |||
| q1.clear(); | |||
| EXPECT_EQ (true, q1.empty()); | |||
| EXPECT_EQ (true, q2.full()); | |||
| EXPECT_EQ (8UL, q1.capacity()); | |||
| EXPECT_EQ (8UL, q2.capacity()); | |||
| EXPECT_EQ (0UL, q1.size()); | |||
| EXPECT_EQ (8UL, q2.size()); | |||
| q1.push_back(2); | |||
| EXPECT_EQ (1UL, q1.size()); | |||
| q1.push_front(1); | |||
| EXPECT_EQ (2UL, q1.size()); | |||
| q1.pop_back(); | |||
| EXPECT_EQ (1UL, q1.size()); | |||
| q1.pop_front(); | |||
| EXPECT_EQ (0UL, q1.size()); | |||
| } | |||
| // push-pop limits | |||
| TEST (Tdeque, push_pop_limits) { | |||
| deque<int, 8> q1; | |||
| deque<int, 8> q2{1, 2, 3, 4, 5, 6, 7, 8}; | |||
| EXPECT_EQ (int{}, q1.pop_back()); | |||
| EXPECT_EQ (0UL, q1.size()); | |||
| EXPECT_EQ (true, q1.empty()); | |||
| EXPECT_EQ (false, q1.full()); | |||
| EXPECT_EQ (int{}, q1.pop_front()); | |||
| EXPECT_EQ (0UL, q1.size()); | |||
| EXPECT_EQ (true, q1.empty()); | |||
| EXPECT_EQ (false, q1.full()); | |||
| q2.push_front(0); | |||
| EXPECT_EQ (1, q2.front()); | |||
| EXPECT_EQ (8, q2.back()); | |||
| EXPECT_EQ (8UL, q2.size()); | |||
| EXPECT_EQ (false, q2.empty()); | |||
| EXPECT_EQ (true, q2.full()); | |||
| q2.push_back(9); | |||
| EXPECT_EQ (1, q2.front()); | |||
| EXPECT_EQ (8, q2.back()); | |||
| EXPECT_EQ (8UL, q2.size()); | |||
| EXPECT_EQ (false, q2.empty()); | |||
| EXPECT_EQ (true, q2.full()); | |||
| } | |||
| // iterators | |||
| TEST (Tdeque, iterators) { | |||
| deque<int, 8> q1{1, 2, 3, 4, 5, 6, 7, 8}; | |||
| int check_it=1; | |||
| EXPECT_EQ (q1.begin().base(), q1.end().base()); | |||
| EXPECT_NE (q1.begin().iter(), q1.end().iter()); | |||
| EXPECT_EQ (1, *q1.begin()); | |||
| EXPECT_EQ (true, (q1.begin() == ++q1.end())); // loop edge iterators | |||
| for (auto it = q1.begin() ; it != q1.end() ; ++it) | |||
| EXPECT_EQ(*it, check_it++); | |||
| EXPECT_EQ(9, check_it); // run through all | |||
| EXPECT_EQ (1, q1.front()); // queue stays intact | |||
| EXPECT_EQ (8, q1.back()); | |||
| EXPECT_EQ (8UL, q1.size()); | |||
| EXPECT_EQ (false, q1.empty()); | |||
| EXPECT_EQ (true, q1.full()); | |||
| q1.pop_front(); | |||
| q1.pop_back(); | |||
| check_it=2; | |||
| for (auto& it : q1) | |||
| EXPECT_EQ(it, check_it++); | |||
| EXPECT_EQ(8, check_it); // run through all | |||
| EXPECT_EQ (2, q1.front()); // queue stays intact | |||
| EXPECT_EQ (7, q1.back()); | |||
| EXPECT_EQ (6UL, q1.size()); | |||
| EXPECT_EQ (false, q1.empty()); | |||
| EXPECT_EQ (false, q1.full()); | |||
| deque<int, 8> q2; | |||
| q2.push_front(2); | |||
| q2.push_front(1); | |||
| q2.push_back(3); | |||
| q2.push_back(4); | |||
| q2.push_back(5); | |||
| check_it =1; | |||
| for (auto& it : q2) | |||
| EXPECT_EQ(it, check_it++); | |||
| EXPECT_EQ(6, check_it); // run through all | |||
| } | |||
| } | |||