a lot of code but not sure about state iterator needs for in order traversal

Map.hpp

@@ -18,6 +18,9 @@ private:
   std::vector<std::optional<ValueType>> store;
 
 public:
+  class Iterator;
+  class ConstIterator;
+  class ReverseIterator;
   // TODO: Iterator functionality
   class Iterator {
   public:
@@ -29,11 +32,43 @@ public:
   public:
     Iterator() = delete;
     Iterator(underlying iter) : store_iter{iter} {}
+    ConstIterator to_const() const { return ConstIterator(this); }
+    Iterator &operator++() { return *this; }
+    Iterator operator++(int) {
+      Iterator tmp = *this;
+      ++(*this);
+      return tmp;
+    }
+    Iterator &operator--() {}
+    Iterator operator--(int) {
+      Iterator tmp = *this;
+      --(*this);
+      return tmp;
+    }
+    ValueType &operator*() const { return this->store_iter->value(); }
+    ValueType *operator->() const { return &this->store_iter->value(); }
+    friend bool operator==(Iterator const &lhs, Iterator const &rhs) {
+      return lhs.store_iter == rhs.store_iter;
+    }
+    friend bool operator!=(Iterator const &lhs, Iterator const &rhs) {
+      return lhs.store_iter != rhs.store_iter;
+    }
+    friend bool operator==(ConstIterator const &lhs, Iterator const &rhs) {
+      return lhs == rhs.to_const();
+    }
+    friend bool operator!=(ConstIterator const &lhs, Iterator const &rhs) {
+      return lhs != rhs.to_const();
+    }
+    friend bool operator==(Iterator const &lhs, ConstIterator const &rhs) {
+      return lhs.to_const() == rhs;
+    }
+    friend bool operator!=(Iterator const &lhs, ConstIterator const &rhs) {
+      return lhs.to_const() != rhs;
+    }
   };
   class ConstIterator {
   public:
-    using underlying =
+    using underlying = Iterator;
-        typename std::vector<std::optional<ValueType>>::const_iterator;
 
   private:
     underlying store_iter;
@@ -41,6 +76,35 @@ public:
   public:
     ConstIterator() = delete;
     ConstIterator(underlying iter) : store_iter{iter} {}
+    friend bool operator==(ConstIterator const &lhs, ConstIterator const &rhs) {
+      return lhs.store_iter == rhs.store_iter;
+    }
+    ConstIterator &operator++() {
+      ++this->store_iter;
+      return *this;
+    }
+    ConstIterator operator++(int) {
+      ConstIterator tmp = *this;
+      this->store_iter++;
+      return tmp;
+    }
+    ConstIterator &operator--() {
+      --this->store_iter;
+      return *this;
+    }
+    ConstIterator operator--(int) {
+      ConstIterator tmp = *this;
+      this->store_iter--;
+      return tmp;
+    }
+    const ValueType &operator*() const { return *this->store_iter; }
+    const ValueType *operator->() const {
+      // I find this rather funny
+      return this->store_iter.operator->();
+    }
+    friend bool operator!=(ConstIterator const &lhs, ConstIterator const &rhs) {
+      return lhs.store_iter != rhs.store_iter;
+    }
   };
   class ReverseIterator {
   public:
@@ -52,6 +116,19 @@ public:
   public:
     ReverseIterator() = delete;
     ReverseIterator(underlying store_iter) : store_iter{store_iter} {}
+    ReverseIterator &operator++() {}
+    ReverseIterator operator++(int) {}
+    ReverseIterator &operator--() {}
+    ReverseIterator operator--(int) {}
+    ValueType &operator*() const {}
+    ValueType *operator->() const {}
+    friend bool operator==(ReverseIterator const &lhs,
+                           ReverseIterator const &rhs) {
+      return lhs.store_iter == rhs.store_iter;
+    }
+    friend bool operator!=(ConstIterator const &lhs, ConstIterator const &rhs) {
+      return lhs.store_iter != rhs.store_iter;
+    }
   };
   Map() : store{} {}
   Map(const Map &rhs) : store{rhs.store} {}