Line data    Source code

       1             : #ifndef VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
       2             : #define VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
       3             : 
       4             : #if defined(_MSC_VER) ||                                            \
       5             :     (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
       6             :      (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
       7             : #pragma once
       8             : #endif
       9             : 
      10             : #include "yaml-cpp/dll.h"
      11             : #include "yaml-cpp/node/detail/node_iterator.h"
      12             : #include "yaml-cpp/node/node.h"
      13             : #include "yaml-cpp/node/ptr.h"
      14             : #include <cstddef>
      15             : #include <iterator>
      16             : 
      17             : 
      18             : namespace YAML {
      19             : namespace detail {
      20             : struct iterator_value;
      21             : 
      22             : template <typename V>
      23             : class iterator_base {
      24             : 
      25             :  private:
      26             :   template <typename>
      27             :   friend class iterator_base;
      28             :   struct enabler {};
      29             :   using base_type = node_iterator;
      30             : 
      31             :   struct proxy {
      32             :     explicit proxy(const V& x) : m_ref(x) {}
      33             :     V* operator->() { return std::addressof(m_ref); }
      34             :     operator V*() { return std::addressof(m_ref); }
      35             : 
      36             :     V m_ref;
      37             :   };
      38             : 
      39             :  public:
      40             :   using iterator_category = std::forward_iterator_tag;
      41             :   using value_type = V;
      42             :   using difference_type = std::ptrdiff_t;
      43             :   using pointer = V*;
      44             :   using reference = V;
      45             : 
      46             :  public:
      47          12 :   iterator_base() : m_iterator(), m_pMemory() {}
      48        2226 :   explicit iterator_base(base_type rhs, shared_memory_holder pMemory)
      49        2226 :       : m_iterator(rhs), m_pMemory(pMemory) {}
      50             : 
      51             :   template <class W>
      52             :   iterator_base(const iterator_base<W>& rhs,
      53             :                 typename std::enable_if<std::is_convertible<W*, V*>::value,
      54             :                                         enabler>::type = enabler())
      55             :       : m_iterator(rhs.m_iterator), m_pMemory(rhs.m_pMemory) {}
      56             : 
      57        2844 :   iterator_base<V>& operator++() {
      58        2844 :     ++m_iterator;
      59        2844 :     return *this;
      60             :   }
      61             : 
      62             :   iterator_base<V> operator++(int) {
      63             :     iterator_base<V> iterator_pre(*this);
      64             :     ++(*this);
      65             :     return iterator_pre;
      66             :   }
      67             : 
      68             :   template <typename W>
      69             :   bool operator==(const iterator_base<W>& rhs) const {
      70             :     return m_iterator == rhs.m_iterator;
      71             :   }
      72             : 
      73             :   template <typename W>
      74        3963 :   bool operator!=(const iterator_base<W>& rhs) const {
      75        3963 :     return m_iterator != rhs.m_iterator;
      76             :   }
      77             : 
      78        2844 :   value_type operator*() const {
      79        2844 :     const typename base_type::value_type& v = *m_iterator;
      80        2844 :     if (v.pNode)
      81          60 :       return value_type(Node(*v, m_pMemory));
      82        2814 :     if (v.first && v.second)
      83        5628 :       return value_type(Node(*v.first, m_pMemory), Node(*v.second, m_pMemory));
      84           0 :     return value_type();
      85             :   }
      86             : 
      87             :   proxy operator->() const { return proxy(**this); }
      88             : 
      89             :  private:
      90             :   base_type m_iterator;
      91             :   shared_memory_holder m_pMemory;
      92             : };
      93             : }  // namespace detail
      94             : }  // namespace YAML
      95             : 
      96             : #endif  // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66