[new-core-alignment] ecal_expmap not using std::iterator anymore

ecal/core/src/util/ecal_expmap.h

@@ -5,9 +5,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -23,13 +23,14 @@
 
 #pragma once
 
+#include <chrono>
 #include <functional>
+#include <iterator>
 #include <list>
 #include <map>
 #include <memory>
 #include <utility>
 #include <vector>
-#include <chrono>
 
 namespace eCAL
 {
@@ -41,32 +42,37 @@ namespace eCAL
     template<class Key,
       class T,
       class Compare = std::less<Key>,
-      class Alloc = std::allocator<std::pair<const Key, T> > >
-      class CExpMap
+      class Alloc   = std::allocator<std::pair<const Key, T> > >
+    class CExpMap
     {
     public:
       using clock_type = std::chrono::steady_clock;
 
       // Key access history, most recent at back 
       using key_tracker_type = std::list<std::pair<clock_type::time_point, Key>>;
+
       // Key to value and key history iterator 
       using key_to_value_type = std::map<Key, std::pair<T, typename key_tracker_type::iterator>>;
 
-      using allocator_type = Alloc;
-      using value_type = std::pair<const Key, T>;
-      using reference = typename Alloc::reference;
-      using const_reference = typename Alloc::const_reference;
-      using difference_type = typename Alloc::difference_type;
-      using size_type = typename Alloc::size_type;
-      using key_type = Key;
-      using mapped_type = T;
+      using allocator_type  = Alloc;
+      using value_type      = std::pair<const Key, T>;
+      using reference       = typename Alloc::reference;
+      using size_type       = typename Alloc::size_type;
+      using key_type        = Key;
+      using mapped_type     = T;
 
-      class iterator : public std::iterator<std::bidirectional_iterator_tag, std::pair<Key, T>>
+      class iterator
       {
         friend class const_iterator;
 
       public:
-        iterator(const typename key_to_value_type::iterator _it)
+        using iterator_category = std::bidirectional_iterator_tag;
+        using value_type        = std::pair<Key, T>;
+        using difference_type   = std::ptrdiff_t;
+        using pointer           = std::pair<Key, T>*;
+        using reference         = std::pair<Key, T>&;
+
+        explicit iterator(const typename key_to_value_type::iterator _it)
           : it(_it)
         {}
 
@@ -86,44 +92,50 @@ namespace eCAL
         {
           return std::make_pair(it->first, it->second.first);
         }
-        
+
         //friend void swap(iterator& lhs, iterator& rhs); //C++11 I think
         bool operator==(const iterator& rhs) const { return it == rhs.it; }
         bool operator!=(const iterator& rhs) const { return it != rhs.it; }
 
       private:
         typename key_to_value_type::iterator it;
-       };
+      };
 
-      class const_iterator : public std::iterator<std::bidirectional_iterator_tag, const std::pair<Key, T>>
+      class const_iterator
       {
       public:
-        const_iterator(const iterator& other)
+        using iterator_category = std::bidirectional_iterator_tag;
+        using value_type        = std::pair<Key, T>;
+        using difference_type   = std::ptrdiff_t;
+        using pointer           = std::pair<Key, T>*;
+        using reference         = std::pair<Key, T>&;
+
+        explicit const_iterator(const iterator& other)
           : it(other.it)
         {}
 
-        const_iterator(const typename key_to_value_type::const_iterator _it)
+        explicit const_iterator(const typename key_to_value_type::const_iterator _it)
           : it(_it)
         {}
-        
+
         const_iterator& operator++()
         {
           it++;
           return *this;
         } //prefix increment
-        
+
         const_iterator& operator--()
         {
           it--;
           return *this;
         } //prefix decrement
           //reference operator*() const
-        
+
         std::pair<Key, T> operator*() const
         {
           return std::make_pair(it->first, it->second.first);
         }
-        
+
         //friend void swap(iterator& lhs, iterator& rhs); //C++11 I think
         bool operator==(const const_iterator& rhs) const { return it == rhs.it; }
         bool operator!=(const const_iterator& rhs) const { return it != rhs.it; }
@@ -135,7 +147,7 @@ namespace eCAL
 
       // Constructor specifies the timeout of the map
       CExpMap() : _timeout(std::chrono::milliseconds(5000)) {};
-      CExpMap(clock_type::duration t) : _timeout(t) {};
+      explicit CExpMap(clock_type::duration t) : _timeout(t) {};
 
       /**
       * @brief  set expiration time