node/detail/iterator.h

0001 #ifndef VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
0002 #define VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
0003
0004 #if defined(_MSC_VER) ||                                            \
0005     (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
0006      (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
0007 #pragma once
0008 #endif
0009
0010 #include "ATOOLS/YAML/yaml-cpp/dll.h"
0011 #include "ATOOLS/YAML/yaml-cpp/node/detail/node_iterator.h"
0012 #include "ATOOLS/YAML/yaml-cpp/node/node.h"
0013 #include "ATOOLS/YAML/yaml-cpp/node/ptr.h"
0014 #include <cstddef>
0015 #include <iterator>
0016
0017
0018 namespace SHERPA_YAML {
0019 namespace detail {
0020 struct iterator_value;
0021
0022 template <typename V>
0023 class iterator_base {
0024
0025  private:
0026   template <typename>
0027   friend class iterator_base;
0028   struct enabler {};
0029   using base_type = node_iterator;
0030
0031   struct proxy {
0032     explicit proxy(const V& x) : m_ref(x) {}
0033     V* operator->() { return std::addressof(m_ref); }
0034     operator V*() { return std::addressof(m_ref); }
0035
0036     V m_ref;
0037   };
0038
0039  public:
0040   using iterator_category = std::forward_iterator_tag;
0041   using value_type = V;
0042   using difference_type = std::ptrdiff_t;
0043   using pointer = V*;
0044   using reference = V;
0045
0046  public:
0047   iterator_base() : m_iterator(), m_pMemory() {}
0048   explicit iterator_base(base_type rhs, shared_memory_holder pMemory)
0049       : m_iterator(rhs), m_pMemory(pMemory) {}
0050
0051   template <class W>
0052   iterator_base(const iterator_base<W>& rhs,
0053                 typename std::enable_if<std::is_convertible<W*, V*>::value,
0054                                         enabler>::type = enabler())
0055       : m_iterator(rhs.m_iterator), m_pMemory(rhs.m_pMemory) {}
0056
0057   iterator_base<V>& operator++() {
0058     ++m_iterator;
0059     return *this;
0060   }
0061
0062   iterator_base<V> operator++(int) {
0063     iterator_base<V> iterator_pre(*this);
0064     ++(*this);
0065     return iterator_pre;
0066   }
0067
0068   template <typename W>
0069   bool operator==(const iterator_base<W>& rhs) const {
0070     return m_iterator == rhs.m_iterator;
0071   }
0072
0073   template <typename W>
0074   bool operator!=(const iterator_base<W>& rhs) const {
0075     return m_iterator != rhs.m_iterator;
0076   }
0077
0078   value_type operator*() const {
0079     const typename base_type::value_type& v = *m_iterator;
0080     if (v.pNode)
0081       return value_type(Node(*v, m_pMemory));
0082     if (v.first && v.second)
0083       return value_type(Node(*v.first, m_pMemory), Node(*v.second, m_pMemory));
0084     return value_type();
0085   }
0086
0087   proxy operator->() const { return proxy(**this); }
0088
0089  private:
0090   base_type m_iterator;
0091   shared_memory_holder m_pMemory;
0092 };
0093 }  // namespace detail
0094 }  // namespace SHERPA_YAML
0095
0096 #endif  // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66