diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..13566b8 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..53624c9 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,18 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..35eb1dd --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Demo.cpp b/Demo.cpp index 0b7cfe6..b3f8212 100644 --- a/Demo.cpp +++ b/Demo.cpp @@ -33,7 +33,7 @@ int main() { std::cout << "Prime numbers:\n"; MagicalContainer::PrimeIterator primeIter(container); for (auto it = primeIter.begin(); it != primeIter.end(); ++it) { - std::cout << *it << ' '; // 2 3 17 + std::cout << *it << ' '; // 2 3 17 } std::cout << std::endl; @@ -42,4 +42,4 @@ int main() { std::cout << "Size of container after removing an element: " << container.size() << std::endl; return 0; -} +} \ No newline at end of file diff --git a/Test.cpp b/Test.cpp new file mode 100644 index 0000000..f8152e0 --- /dev/null +++ b/Test.cpp @@ -0,0 +1,415 @@ +#include "doctest.h" +#include "sources/MagicalContainer.hpp" + +using namespace ariel; +using namespace std; + + +TEST_SUITE("MagicalContainer PrimeIterator") { + TEST_CASE("Prime numbers") { + MagicalContainer container; + container.addElement(17); + container.addElement(2); + container.addElement(25); + container.addElement(9); + container.addElement(3); + + MagicalContainer::PrimeIterator primeIter(container); + + std::vector primes = {2, 3, 17}; + std::vector::size_type index = 0; + for (auto it = primeIter.begin(); it != primeIter.end(); ++it) { + CHECK(*it == primes[index]); + ++index; + } + } + + TEST_CASE("Remove non-prime number") { + MagicalContainer container; + container.addElement(17); + container.addElement(2); + container.addElement(25); + container.addElement(9); + container.addElement(3); + + container.removeElement(9); + + MagicalContainer::PrimeIterator primeIter(container); + + std::vector primes = {2, 3, 17}; + std::vector::size_type index = 0; + for (auto it = primeIter.begin(); it != primeIter.end(); ++it) { + CHECK(*it == primes[index]); + ++index; + } + } + + TEST_CASE("Empty container") { + MagicalContainer emptyContainer; + + MagicalContainer::PrimeIterator primeIter(emptyContainer); + CHECK(primeIter.begin() == primeIter.end()); + } +} + +TEST_SUITE("MagicalContainer AscendingIterator") { + TEST_CASE("Ascending order") { + MagicalContainer container; + container.addElement(17); + container.addElement(2); + container.addElement(25); + container.addElement(9); + container.addElement(3); + + MagicalContainer::AscendingIterator ascIter(container); + + std::vector ascending = {2, 3, 9, 17, 25}; + std::vector::size_type index = 0; + for (auto it = ascIter.begin(); it != ascIter.end(); ++it) { + CHECK(*it == ascending[index]); + ++index; + } + } + + TEST_CASE("Remove element in ascending order") { + MagicalContainer container; + container.addElement(17); + container.addElement(2); + container.addElement(25); + container.addElement(9); + container.addElement(3); + + container.removeElement(9); + + MagicalContainer::AscendingIterator ascIter(container); + + std::vector ascending = {2, 3, 17, 25}; + std::vector::size_type index = 0; + for (auto it = ascIter.begin(); it != ascIter.end(); ++it) { + CHECK(*it == ascending[index]); + ++index; + } + } +} + +TEST_SUITE("MagicalContainer SideCrossIterator") { + TEST_CASE("Side-cross order") { + MagicalContainer container; + container.addElement(17); + container.addElement(2); + container.addElement(25); + container.addElement(9); + container.addElement(3); + + MagicalContainer::SideCrossIterator sideCrossIter(container); + + std::vector sideCross = {17, 3, 2, 9, 25}; + std::vector::size_type index = 0; + for (auto it = sideCrossIter.begin(); it != sideCrossIter.end(); ++it) { + CHECK(*it == sideCross[index]); + ++index; + } + } + + TEST_CASE("Remove element in side-cross order") { + MagicalContainer container; + container.addElement(17); + container.addElement(2); + container.addElement(25); + container.addElement(9); + container.addElement(3); + + container.removeElement(2); + + MagicalContainer::SideCrossIterator sideCrossIter(container); + + std::vector sideCross = {17, 3, 9, 25}; + std::vector::size_type index = 0; + for (auto it = sideCrossIter.begin(); it != sideCrossIter.end(); ++it) { + CHECK(*it == sideCross[index]); + ++index; + } + } +} + +TEST_SUITE("Adding and Removing Elements Simultaneously") { + MagicalContainer container; + + TEST_CASE("Adding and removing single element") { + container.addElement(10); + container.removeElement(10); + CHECK(container.size() == 0); + } + + TEST_CASE("Adding and removing multiple elements") { + container.addElement(10); + container.addElement(20); + container.removeElement(10); + container.addElement(30); + container.removeElement(20); + CHECK(container.size() == 1); + } +} + +TEST_SUITE("Test AscendingIterator class ") { + + TEST_CASE("Test * operator returns the correct element") { + // Setup + MagicalContainer container; + container.addElement(4); + container.addElement(1); + container.addElement(9); + MagicalContainer::AscendingIterator ascIter(container); + auto first_asc_iterator = ascIter.begin(); + auto second_asc_iterator = ascIter.begin(); + // Assertion + CHECK_EQ(*first_asc_iterator, 1); + CHECK_EQ(*second_asc_iterator, 1); + } + + TEST_CASE("Test ++ operator") { + // Setup + MagicalContainer container; + container.addElement(5); + container.addElement(2); + container.addElement(8); + MagicalContainer::AscendingIterator ascIter(container); + auto first_asc_iterator = ascIter.begin(); + auto second_asc_iterator = ascIter.begin(); + // Action + ++first_asc_iterator; + + // Assertions + CHECK_EQ(*first_asc_iterator, 5); + CHECK_NE(first_asc_iterator, second_asc_iterator); + CHECK_FALSE(first_asc_iterator == second_asc_iterator); + + // Action + ++second_asc_iterator; + + // Assertions + CHECK_EQ(*second_asc_iterator, 5); + CHECK_EQ(first_asc_iterator, second_asc_iterator); + + // Action + ++second_asc_iterator; + + // Assertions + CHECK_EQ(*second_asc_iterator, 8); + + // Action + ++first_asc_iterator; + + // Assertions + CHECK_EQ(*first_asc_iterator, 8); + CHECK_EQ(first_asc_iterator, second_asc_iterator); + } +} + +TEST_SUITE("Test SideCrossIterator class") { + + TEST_CASE("Test * operator returns the correct element") { + // Setup + MagicalContainer container; + container.addElement(4); + container.addElement(1); + container.addElement(9); + MagicalContainer::SideCrossIterator sideCrossIter(container); + auto first_sideCross_iterator = sideCrossIter.begin(); + auto second_sideCross_iterator = sideCrossIter.begin(); + // Assertion + CHECK_EQ(*first_sideCross_iterator, 1); + CHECK_EQ(*second_sideCross_iterator, 1); + } + + TEST_CASE("Test ++ operator") { + // Setup + MagicalContainer container; + container.addElement(5); + container.addElement(2); + container.addElement(8); + MagicalContainer::SideCrossIterator sideCrossIter(container); + auto first_sideCross_iterator = sideCrossIter.begin(); + auto second_sideCross_iterator = sideCrossIter.begin(); + // Action + ++first_sideCross_iterator; + + // Assertions + CHECK_EQ(*first_sideCross_iterator, 5); + CHECK_NE(first_sideCross_iterator, second_sideCross_iterator); + CHECK_FALSE(first_sideCross_iterator == second_sideCross_iterator); + + // Action + ++second_sideCross_iterator; + + // Assertions + CHECK_EQ(*second_sideCross_iterator, 5); + CHECK_EQ(first_sideCross_iterator, second_sideCross_iterator); + + // Action + ++second_sideCross_iterator; + + // Assertions + CHECK_EQ(*second_sideCross_iterator, 8); + + // Action + ++first_sideCross_iterator; + + // Assertions + CHECK_EQ(*first_sideCross_iterator, 8); + CHECK_EQ(first_sideCross_iterator, second_sideCross_iterator); + } +} + +TEST_SUITE("Test PrimeIterator class") { + + TEST_CASE("Test * operator returns the correct element") { + // Setup + MagicalContainer container; + container.addElement(4); + container.addElement(1); + container.addElement(9); + MagicalContainer::PrimeIterator primeIter(container); + auto first_prime_iterator = primeIter.begin(); + auto second_prime_iterator = primeIter.begin(); + // Assertion + CHECK_EQ(*first_prime_iterator, 2); + CHECK_EQ(*second_prime_iterator, 2); + } + + TEST_CASE("Test ++ operator") { + // Setup + MagicalContainer container; + container.addElement(5); + container.addElement(2); + container.addElement(8); + MagicalContainer::PrimeIterator primeIter(container); + auto first_prime_iterator = primeIter.begin(); + auto second_prime_iterator = primeIter.begin(); + // Action + ++first_prime_iterator; + + // Assertions + CHECK_EQ(*first_prime_iterator, 5); + CHECK_NE(first_prime_iterator, second_prime_iterator); + CHECK_FALSE(first_prime_iterator == second_prime_iterator); + + // Action + ++second_prime_iterator; + + // Assertions + CHECK_EQ(*second_prime_iterator, 5); + CHECK_EQ(first_prime_iterator, second_prime_iterator); + + // Action + ++second_prime_iterator; + + // Assertions + CHECK_EQ(*second_prime_iterator, 8); + + // Action + ++first_prime_iterator; + + // Assertions + CHECK_EQ(*first_prime_iterator, 8); + CHECK_EQ(first_prime_iterator, second_prime_iterator); + } +} + +TEST_SUITE("PrimeIterator move over prime numbers only") { + + TEST_CASE("Iterating over elements") { + MagicalContainer container; + container.addElement(100); + container.addElement(200); + container.addElement(36); + container.addElement(99); + container.addElement(102); + container.addElement(4); + + MagicalContainer::PrimeIterator prime_it(container); + CHECK_EQ(prime_it, prime_it.end()); + CHECK_THROWS_AS(++prime_it, runtime_error); + } +} + +TEST_SUITE("PrimeIterator") { + + TEST_CASE("Test first prime element") { + // Setup + MagicalContainer container; + container.addElement(3); + container.addElement(7); + container.addElement(9); + container.addElement(23); + container.addElement(11); + MagicalContainer::PrimeIterator primeIter(container); + // Action + auto begin = primeIter.begin(); + + // Assertion + CHECK_EQ(*begin, 3); + } + + TEST_CASE("Test second prime element") { + // Setup + MagicalContainer container; + container.addElement(3); + container.addElement(7); + container.addElement(9); + container.addElement(23); + container.addElement(11); + MagicalContainer::PrimeIterator primeIter(container); + // Action + auto begin = primeIter.begin(); + ++begin; + + // Assertion + CHECK_EQ(*begin, 7); + } + + TEST_CASE("go over the prime numbers") { + // Setup + MagicalContainer container; + container.addElement(3); + container.addElement(7); + container.addElement(9); + container.addElement(23); + container.addElement(11); + MagicalContainer::PrimeIterator primeIter(container); + // Action + auto begin = primeIter.begin(); + ++begin; + ++begin; + + // Assertion + CHECK_EQ(*begin, 11); + } +} + +TEST_SUITE(" AscendingIterator") { + + TEST_CASE("Iterating in ascending order") { + // Setup + MagicalContainer container; + container.addElement(3); + container.addElement(6); + container.addElement(9); + container.addElement(12); + container.addElement(15); + // Action + MagicalContainer::AscendingIterator it(container); + // Assertions + CHECK_EQ(*it, 3); + ++it; + CHECK_EQ(*it, 6); + ++it; + CHECK_EQ(*it, 9); + ++it; + CHECK_EQ(*it, 12); + ++it; + CHECK_EQ(*it, 15); + ++it; + CHECK(it == it.end()); + } +} \ No newline at end of file diff --git a/objects/MagicalContainer-5dba0281.o.tmp b/objects/MagicalContainer-5dba0281.o.tmp new file mode 100644 index 0000000..e69de29 diff --git a/objects/MagicalContainer-6303aa5c.o.tmp b/objects/MagicalContainer-6303aa5c.o.tmp new file mode 100644 index 0000000..e69de29 diff --git a/objects/MagicalContainer-aeda053d.o.tmp b/objects/MagicalContainer-aeda053d.o.tmp new file mode 100644 index 0000000..e69de29 diff --git a/sources/AscendingIterator.cpp b/sources/AscendingIterator.cpp new file mode 100644 index 0000000..2142900 --- /dev/null +++ b/sources/AscendingIterator.cpp @@ -0,0 +1,64 @@ +// +// Created by renana on 6/1/23. +// +#include "MagicalContainer.hpp" +using namespace std; +using namespace ariel; +// AscendingIterator implementation + +MagicalContainer& MagicalContainer::AscendingIterator::getContainer() const { + return container; +} + +int MagicalContainer::AscendingIterator::getCurrentIndex() const { + return index; +} + + +MagicalContainer::AscendingIterator::AscendingIterator(const AscendingIterator& copy_container) + : container(copy_container.container), index(copy_container.index) {} + +MagicalContainer::AscendingIterator::~AscendingIterator() = default; // Destructor + +MagicalContainer::AscendingIterator::AscendingIterator(MagicalContainer& container) + : container(container), index(0) { + std::vector sortedElements = container.getElements(); + std::sort(sortedElements.begin(), sortedElements.end()); + container.setElements(sortedElements); +} + +int& MagicalContainer::AscendingIterator::operator*() const { + return container.getElements()[static_cast::size_type>(index)]; +} + +MagicalContainer::AscendingIterator& MagicalContainer::AscendingIterator::operator++() { + ++index; + return *this; +} + +bool MagicalContainer::AscendingIterator::operator==(const AscendingIterator& other_iterator) const { + return index == other_iterator.index; +} + +bool MagicalContainer::AscendingIterator::operator!=(const AscendingIterator& other_iterator) const { + return index != other_iterator.index; +} + +MagicalContainer::AscendingIterator MagicalContainer::AscendingIterator::begin() const { + return AscendingIterator(container); +} + +MagicalContainer::AscendingIterator MagicalContainer::AscendingIterator::end() const { + AscendingIterator it(container); + it.index = container.size(); + return it; +} + +MagicalContainer::AscendingIterator &MagicalContainer::AscendingIterator::operator=(const AscendingIterator &other){ + return *this; +} + +// Move assignment operator +MagicalContainer::AscendingIterator &MagicalContainer::AscendingIterator::operator=(AscendingIterator &&other) noexcept { +return *this; +} diff --git a/sources/MagicalContainer.cpp b/sources/MagicalContainer.cpp new file mode 100644 index 0000000..fcabd99 --- /dev/null +++ b/sources/MagicalContainer.cpp @@ -0,0 +1,37 @@ +#include "MagicalContainer.hpp" +using namespace std; +using namespace ariel; +// MagicalContainer implementation + +MagicalContainer::MagicalContainer() = default; // Default constructor + +MagicalContainer::MagicalContainer(const MagicalContainer& other) = default; // Copy constructor + +MagicalContainer::~MagicalContainer() = default; // Destructor + +std::vector& MagicalContainer::getElements() { + return elements; +} + +void MagicalContainer::setElements(std::vector elements) { + this->elements = std::move(elements); +} + +void MagicalContainer::addElement(int element) { + elements.push_back(element); +} + +void MagicalContainer::removeElement(int element) { + auto it = std::find(elements.begin(), elements.end(), element); + if (it != elements.end()) { + elements.erase(it); + } +// else { +// throw std::invalid_argument("Element not found in the container."); +// } +} + +int MagicalContainer::size() const { + return elements.size(); +} + diff --git a/sources/MagicalContainer.hpp b/sources/MagicalContainer.hpp new file mode 100644 index 0000000..45a12b0 --- /dev/null +++ b/sources/MagicalContainer.hpp @@ -0,0 +1,128 @@ +#ifndef MAGICAL_ITERATORS_MAGICALCONTAINER_H +#define MAGICAL_ITERATORS_MAGICALCONTAINER_H + +#include +#include +#include + +namespace ariel{ + + class MagicalContainer { + + private: + std::vector elements; + public: + MagicalContainer(); // Default constructor + MagicalContainer(const MagicalContainer& other); // Copy constructor + ~MagicalContainer(); // Destructor + + std::vector& getElements(); + void setElements(std::vector elements); + void addElement(int element); + void removeElement(int element); + int size() const; + + + class AscendingIterator { + + private: + MagicalContainer& container; + int index; + + public: + + AscendingIterator(const AscendingIterator& copy_container); + AscendingIterator() = delete; + ~AscendingIterator(); + + AscendingIterator(MagicalContainer& container); + + int& operator*() const; + AscendingIterator& operator++(); + bool operator==(const AscendingIterator& other_iterator) const; + bool operator!=(const AscendingIterator& other_iterator) const; + // Assignment operator + AscendingIterator &operator=(const AscendingIterator &other); + + // Move assignment operator + AscendingIterator &operator=(AscendingIterator &&other) noexcept; + AscendingIterator begin() const; + AscendingIterator end() const; + int getCurrentIndex() const; + + MagicalContainer& getContainer() const; + }; + + class SideCrossIterator { + + private: + MagicalContainer& container; + int index; + + public: + + SideCrossIterator(const SideCrossIterator& other_container); + SideCrossIterator(const SideCrossIterator&& other_container) noexcept; + SideCrossIterator() =delete; + ~SideCrossIterator(); + SideCrossIterator(MagicalContainer& container); + + int& operator*() const; + SideCrossIterator& operator++(); + bool operator==(const SideCrossIterator& other_iterator) const; + bool operator!=(const SideCrossIterator& other_iterator) const; + bool operator>(const SideCrossIterator& other_iterator) const; + bool operator<(const SideCrossIterator& other_iterator) const; + // Assignment operator + SideCrossIterator &operator=(const SideCrossIterator &other); + + // Move assignment operator + SideCrossIterator &operator=(SideCrossIterator &&other) noexcept; + SideCrossIterator begin() const; + SideCrossIterator end() const; + MagicalContainer& getContainer() const; + int getCurrentIndex() const; + + + }; + + class PrimeIterator { + + private: + + MagicalContainer& container; + int index; + bool isPrime(int n); + + public: + + PrimeIterator(const PrimeIterator& other_container); + ~PrimeIterator(); + + PrimeIterator(MagicalContainer& container); + PrimeIterator(PrimeIterator &&other) noexcept; + int operator*() const; + PrimeIterator& operator++(); + bool operator==(const PrimeIterator& other_iterator) const; + bool operator!=(const PrimeIterator& other_iterator) const; + bool operator>(const PrimeIterator& other_iterator) const; + bool operator<(const PrimeIterator& other_iterator) const; + // Assignment operator + PrimeIterator &operator=(const PrimeIterator &other); + MagicalContainer& getContainer() const; + int getCurrentIndex() const; + + + // Move assignment operator + PrimeIterator &operator=(PrimeIterator &&other) noexcept; + PrimeIterator begin() const; + PrimeIterator end() const; + + }; + };//magical + +} + + + +#endif // MAGICAL_ITERATORS_MAGICALCONTAINER_H \ No newline at end of file diff --git a/sources/PrimeIterator.cpp b/sources/PrimeIterator.cpp new file mode 100644 index 0000000..4476c4a --- /dev/null +++ b/sources/PrimeIterator.cpp @@ -0,0 +1,101 @@ +#include "MagicalContainer.hpp" +using namespace std; +using namespace ariel; + +MagicalContainer::PrimeIterator::PrimeIterator(const PrimeIterator& other_container) + : container(other_container.container), index(other_container.index) {} + +MagicalContainer::PrimeIterator::~PrimeIterator() {} + +MagicalContainer::PrimeIterator::PrimeIterator(MagicalContainer& container) + : container(container), index(0) { + // Skip non-prime elements +// while (index < container.size() && !isPrime(container.getElements()[index])) { +// ++index; +// } +} + +MagicalContainer::PrimeIterator::PrimeIterator(PrimeIterator&& other) noexcept +: container(other.container), index(other.index) {} + +int MagicalContainer::PrimeIterator::operator*() const { + return 0; +} + +ariel::MagicalContainer::PrimeIterator& MagicalContainer::PrimeIterator::operator++() { + // Move to the next prime element +// do { +// ++index; +// } while (index < container.size() && !isPrime(container.getElements()[index])); + return *this; +} + +bool MagicalContainer::PrimeIterator::operator==(const PrimeIterator& other_iterator) const { +// return index == other_iterator.index; + return false; +} + +bool MagicalContainer::PrimeIterator::operator!=(const PrimeIterator& other_iterator) const { +// return index != other_iterator.index; + return false; +} + +bool MagicalContainer::PrimeIterator::operator>(const PrimeIterator& other_iterator) const { +// return index > other_iterator.index; + return false; +} + +bool MagicalContainer::PrimeIterator::operator<(const PrimeIterator& other_iterator) const { +// return index < other_iterator.index; + return false; +} + +ariel::MagicalContainer::PrimeIterator& MagicalContainer::PrimeIterator::operator=(const PrimeIterator& other) { +// if (this != &other) { +// container = other.container; +// index = other.index; +// } + return *this; +} + +MagicalContainer& MagicalContainer::PrimeIterator::getContainer() const { + return container; +} + +int MagicalContainer::PrimeIterator::getCurrentIndex() const { + return 1; +} + +ariel::MagicalContainer::PrimeIterator& MagicalContainer::PrimeIterator::operator=(PrimeIterator&& other) noexcept { +// if (this != &other) { +// container = std::move(other.container); +// index = other.index; +// } + return *this; +} + +ariel::MagicalContainer::PrimeIterator MagicalContainer::PrimeIterator::begin() const { +// PrimeIterator iter(container); +// return iter; + return *this; + +} + +ariel::MagicalContainer::PrimeIterator MagicalContainer::PrimeIterator::end() const { +// PrimeIterator iter(container); +// iter.index = container.size(); +// return iter; + return *this; +} + +bool MagicalContainer::PrimeIterator::isPrime(int n) { + if (n <= 1) { + return false; + } + for (int i = 2; i * i <= n; ++i) { + if (n % i == 0) { + return false; + } + } + return true; +} diff --git a/sources/SideCrossIterator.cpp b/sources/SideCrossIterator.cpp new file mode 100644 index 0000000..d63e93a --- /dev/null +++ b/sources/SideCrossIterator.cpp @@ -0,0 +1,86 @@ +// +// Created by renana on 6/1/23. +// + +#include "MagicalContainer.hpp" +using namespace std; +using namespace ariel; + + +// Move constructor +MagicalContainer::SideCrossIterator::SideCrossIterator(const SideCrossIterator &&other) noexcept : container(other.getContainer()), index(other.getCurrentIndex()) { +} + +MagicalContainer::SideCrossIterator &MagicalContainer::SideCrossIterator::operator=(const SideCrossIterator &other){ + return *this; +} + +// Move assignment operator +MagicalContainer::SideCrossIterator &MagicalContainer::SideCrossIterator::operator=(SideCrossIterator &&other) noexcept { +return *this; +} +MagicalContainer::SideCrossIterator::SideCrossIterator(const SideCrossIterator& other_container) + : container(other_container.container), index(other_container.index) {} + +MagicalContainer::SideCrossIterator::~SideCrossIterator() = default; // Destructor + +MagicalContainer::SideCrossIterator::SideCrossIterator(MagicalContainer& container) + : container(container), index(0) { + std::vector sortedElements = container.getElements(); + std::sort(sortedElements.begin(), sortedElements.end()); + + std::vector crossElements(sortedElements.size()); + size_t start = 0; + size_t end = sortedElements.size() - 1; + for (size_t i = 0; i < crossElements.size(); i += 2) { + crossElements[i] = sortedElements[start]; + crossElements[i + 1] = sortedElements[end]; + start++; + end--; + } + + container.setElements(crossElements); +} + +int& MagicalContainer::SideCrossIterator::operator*() const { + return container.getElements()[static_cast::size_type>(index)]; +} + +MagicalContainer::SideCrossIterator& MagicalContainer::SideCrossIterator::operator++() { + ++index; + return *this; +} + +bool MagicalContainer::SideCrossIterator::operator==(const SideCrossIterator& other) const { + return index == other.index; +} + +bool MagicalContainer::SideCrossIterator::operator!=(const SideCrossIterator& other) const { + return index != other.index; +} + +bool MagicalContainer::SideCrossIterator::operator>(const SideCrossIterator& other) const { + return index > other.index; +} + +bool MagicalContainer::SideCrossIterator::operator<(const SideCrossIterator& other) const { + return index < other.index; +} + +MagicalContainer& MagicalContainer::SideCrossIterator::getContainer() const { + return container; +} + +int MagicalContainer::SideCrossIterator::getCurrentIndex() const { + return index; +} + +MagicalContainer::SideCrossIterator MagicalContainer::SideCrossIterator::begin() const { + return SideCrossIterator(container); +} + +MagicalContainer::SideCrossIterator MagicalContainer::SideCrossIterator::end() const { + SideCrossIterator it(container); + it.index = container.size(); + return it; +}