Skip to content

GitLab

"...git@developer.sourcefind.cn:modelzoo/solov2-pytorch.git" did not exist on "d268e93dc5b5622b2ff5064808f6ddd3aee65be0"
Commit f809206b authored by beder's avatar beder
Browse files

Halfway towards factoring out a node_iterator, and then building iterator on top of it

parent dcf9309e
Show whitespace changes
Inline Side-by-side
Showing with 139 additions and 57 deletions
include/yaml-cpp/value/detail/iterator.h
View file @ f809206b
...@@ -8,79 +8,41 @@ ...@@ -8,79 +8,41 @@
#include "yaml-cpp/dll.h" #include "yaml-cpp/dll.h"
#include "yaml-cpp/value/ptr.h" #include "yaml-cpp/value/ptr.h"
#include <boost/iterator/iterator_facade.hpp> #include "yaml-cpp/value/detail/node_iterator.h"
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/utility/enable_if.hpp> #include <boost/utility/enable_if.hpp>
namespace YAML namespace YAML
{ {
namespace detail namespace detail
{ {
struct iterator_type { enum value { None, Sequence, Map }; }; template<typename V> struct iterator_value;
template<typename V, typename SeqIter, typename MapIter> template<typename V>
class iterator_base: public boost::iterator_facade<iterator_base<V, SeqIter, MapIter>, V, std::bidirectional_iterator_tag> class iterator_base: public boost::iterator_adaptor<
iterator_base<V>,
node_iterator_base<V, typename node_iterator<V>::seq, typename node_iterator<V>::map>,
iterator_value<V>,
std::bidirectional_iterator_tag>
{ {
private: private:
struct enabler {}; template<typename W> friend class iterator_base<W>;
public: public:
iterator_base(): m_type(iterator_type::None) {} iterator_base() {}
explicit iterator_base(shared_memory_holder pMemory, SeqIter seqIt): m_type(iterator_type::Sequence), m_pMemory(pMemory), m_seqIt(seqIt) {} explicit iterator_base(base_type rhs, shared_memory_holder pMemory): iterator_base::iterator_adaptor_(rhs), m_pMemory(pMemory) {}
explicit iterator_base(shared_memory_holder pMemory, MapIter mapIt): m_type(iterator_type::Map), m_pMemory(pMemory), m_mapIt(mapIt) {}
template<typename W, typename I, typename J> template<class W>
iterator_base(const iterator_base<W, I, J>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler()) iterator_base(const iterator_Base<W>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler()): iterator_Base::iterator_adaptor_(rhs.base()), m_pMemory(rhs.m_pMemory) {}
: m_type(rhs.m_type), m_pMemory(rhs.m_pMemory), m_seqIt(rhs.m_seqIt), m_mapIt(rhs.m_mapIt) {}
private: private:
friend class boost::iterator_core_access; friend class boost::iterator_core_access;
template<typename, typename, typename> friend class iterator_base;
template<typename W, typename I, typename J>
bool equal(const iterator_base<W, I, J>& rhs) const {
if(m_type != rhs.m_type || m_pMemory != rhs.m_pMemory)
return false;
switch(m_type) {
case iterator_type::None: return true;
case iterator_type::Sequence: return m_seqIt == rhs.m_seqIt;
case iterator_type::Map: return m_mapIt == rhs.m_mapIt;
}
return true;
}
void increment() { void increment() { this->base_reference() = this->base()->next(); }
switch(m_type) { void decrement() { this->base_reference() = this->base()->previous(); }
case iterator_type::None: break;
case iterator_type::Sequence: ++m_seqIt; break;
case iterator_type::Map: ++m_mapIt; break;
}
}
void decrement() {
switch(m_type) {
case iterator_type::None: break;
case iterator_type::Sequence: --m_seqIt; break;
case iterator_type::Map: --m_mapIt; break;
}
}
V dereference() const {
switch(m_type) {
case iterator_type::None: return V();
case iterator_type::Sequence: return V(Value(**m_seqIt, m_pMemory));
case iterator_type::Map: return V(Value(*m_mapIt->first, m_pMemory), Value(*m_mapIt->second, m_pMemory));
}
return V();
}
private: private:
typename iterator_type::value m_type;
shared_memory_holder m_pMemory; shared_memory_holder m_pMemory;
SeqIter m_seqIt;
MapIter m_mapIt;
}; };
} }
} }
......
include/yaml-cpp/value/detail/node_iterator.h 0 → 100644
View file @ f809206b
#ifndef VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once
#endif
#include "yaml-cpp/dll.h"
#include "yaml-cpp/value/ptr.h"
#include <boost/iterator/iterator_facade.hpp>
#include <boost/utility/enable_if.hpp>
#include <list>
#include <utility>
#include <vector>
namespace YAML
{
namespace detail
{
struct iterator_type { enum value { None, Sequence, Map }; };
template<typename V>
struct node_iterator_value {
iterator_value(): pNode(0), pKey(0), pValue(0) {}
explicit iterator_value(V& rhs): pNode(&rhs), pKey(0), pValue(0) {}
explicit iterator_value(V& key, V& value): pNode(0), pKey(&key), pValue(&value) {}
V *pNode;
V *pKey, *pValue;
};
template<typename V, typename SeqIter, typename MapIter>
class node_iterator_base: public boost::iterator_facade<node_iterator_base<V, SeqIter, MapIter>, node_iterator_value<V>, std::bidirectional_iterator_tag>
{
private:
struct enabler {};
public:
typedef node_iterator_value<V> value_type;
iterator_base(): m_type(iterator_type::None) {}
explicit node_iterator_base(SeqIter seqIt): m_type(iterator_type::Sequence), m_seqIt(seqIt) {}
explicit node_iterator_base(MapIter mapIt): m_type(iterator_type::Map), m_mapIt(mapIt) {}
template<typename W, typename I, typename J>
node_iterator_base(const node_iterator_base<W, I, J>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler())
: m_type(rhs.m_type), m_seqIt(rhs.m_seqIt), m_mapIt(rhs.m_mapIt) {}
private:
friend class boost::iterator_core_access;
template<typename, typename, typename> friend class node_iterator_base;
template<typename W, typename I, typename J>
bool equal(const node_iterator_base<W, I, J>& rhs) const {
if(m_type != rhs.m_type)
return false;
switch(m_type) {
case iterator_type::None: return true;
case iterator_type::Sequence: return m_seqIt == rhs.m_seqIt;
case iterator_type::Map: return m_mapIt == rhs.m_mapIt;
}
return true;
}
void increment() {
switch(m_type) {
case iterator_type::None: break;
case iterator_type::Sequence: ++m_seqIt; break;
case iterator_type::Map: ++m_mapIt; break;
}
}
void decrement() {
switch(m_type) {
case iterator_type::None: break;
case iterator_type::Sequence: --m_seqIt; break;
case iterator_type::Map: --m_mapIt; break;
}
}
value_type dereference() const {
switch(m_type) {
case iterator_type::None: return value_type();
case iterator_type::Sequence: return value_type(**m_seqIt));
case iterator_type::Map: return value_type(*m_mapIt->first, *m_mapIt->second);
}
return V();
}
private:
typename iterator_type::value m_type;
SeqIter m_seqIt;
MapIter m_mapIt;
};
typedef std::vector<node *> node_seq;
typedef std::pair<node *, node *> kv_pair;
typedef std::list<kv_pair> node_map;
template<typename V>
struct node_iterator {
typedef node_seq::iterator seq;
typedef node_map::iterator map;
};
template<typename V>
struct node_iterator<const V> {
typedef node_seq::const_iterator seq;
typedef node_map::const_iterator map;
};
typedef node_iterator_base<node, detail::node_seq_iterator,node_map_iterator> node_iterator;
typedef node_iterator_base<const node, node_seq_const_iterator, node_map_const_iterator> const_node_iterator;
}
}
#endif // VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment