External/yaml-cpp
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Finished the main iterator stuff, now have to hook it to the nodes/values

Browse Source
This commit is contained in:
Jesse Beder 2011-09-10 14:06:49 -05:00
parent 3865d37bc7
commit b1730ea3da
3 changed files with 61 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
include/yaml-cpp/value/detail/iterator.h
View File

@ -16,30 +16,42 @@ namespace YAML
{ {
namespace detail namespace detail
{ {
template<typename V> struct iterator_value; struct iterator_value;
template<typename V> template<typename V>
class iterator_base: public boost::iterator_adaptor< class iterator_base: public boost::iterator_adaptor<
iterator_base<V>, iterator_base<V>,
node_iterator_base<V, typename node_iterator<V>::seq, typename node_iterator<V>::map>, node_iterator,
iterator_value<V>, V,
std::bidirectional_iterator_tag> std::bidirectional_iterator_tag>
{ {
private: private:
template<typename W> friend class iterator_base<W>; template<typename> friend class iterator_base;
struct enabler {};
typedef typename iterator_base::iterator_adaptor_::base_type base_type;
typedef typename iterator_base::iterator_adaptor_::value_type value_type;
public: public:
iterator_base() {} iterator_base() {}
explicit iterator_base(base_type rhs, shared_memory_holder pMemory): iterator_base::iterator_adaptor_(rhs), m_pMemory(pMemory) {} explicit iterator_base(base_type rhs, shared_memory_holder pMemory): iterator_base::iterator_adaptor_(rhs), m_pMemory(pMemory) {}
template<class W> template<class W>
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) {} 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) {}
private: private:
friend class boost::iterator_core_access; friend class boost::iterator_core_access;
void increment() { this->base_reference() = this->base()->next(); } void increment() { this->base_reference() = this->base()->next(); }
void decrement() { this->base_reference() = this->base()->previous(); } void decrement() { this->base_reference() = this->base()->previous(); }
value_type dereference() {
const typename base_type::value_type& v = *this->base();
if(v.pNode)
return value_type(Value(*v.pNode, m_pMemory));
if(v.pKey && v.pValue)
return value_type(Value(*v.pKey, m_pMemory), Value(*v.pValue, m_pMemory));
return value_type();
}
private: private:
shared_memory_holder m_pMemory; shared_memory_holder m_pMemory;

24
include/yaml-cpp/value/detail/iterator_fwd.h
View File

@ -14,24 +14,14 @@
namespace YAML namespace YAML
{ {
class node; class node;
namespace detail {
struct iterator_value;
typedef std::vector<node *> node_seq;
typedef std::pair<node *, node *> kv_pair;
typedef std::list<kv_pair> node_map;
typedef node_seq::iterator node_seq_iterator;
typedef node_seq::const_iterator node_seq_const_iterator;
typedef node_map::iterator node_map_iterator;
typedef node_map::const_iterator node_map_const_iterator;
template<typename V, typename SeqIter, typename MapIter> class iterator_base;
}
typedef detail::iterator_base<detail::iterator_value, detail::node_seq_iterator, detail::node_map_iterator> iterator; namespace detail {
typedef detail::iterator_base<const detail::iterator_value, detail::node_seq_const_iterator, detail::node_map_const_iterator> const_iterator; class iterator_value;
template<typename V> class iterator_base;
}
typedef detail::iterator_base<detail::iterator_value> iterator;
typedef detail::iterator_base<const detail::iterator_value> const_iterator;
} }
#endif // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66

67
include/yaml-cpp/value/detail/node_iterator.h
View File

@ -22,37 +22,60 @@ namespace YAML
template<typename V> template<typename V>
struct node_iterator_value { struct node_iterator_value {
iterator_value(): pNode(0), pKey(0), pValue(0) {} node_iterator_value(): pNode(0), pKey(0), pValue(0) {}
explicit iterator_value(V& rhs): pNode(&rhs), pKey(0), pValue(0) {} explicit node_iterator_value(V& rhs): pNode(&rhs), pKey(0), pValue(0) {}
explicit iterator_value(V& key, V& value): pNode(0), pKey(&key), pValue(&value) {} explicit node_iterator_value(V& key, V& value): pNode(0), pKey(&key), pValue(&value) {}
V *pNode; V *pNode;
V *pKey, *pValue; V *pKey, *pValue;
}; };
template<typename V, typename SeqIter, typename MapIter> typedef std::vector<node *> node_seq;
class node_iterator_base: public boost::iterator_facade<node_iterator_base<V, SeqIter, MapIter>, node_iterator_value<V>, std::bidirectional_iterator_tag> typedef std::pair<node *, node *> kv_pair;
typedef std::list<kv_pair> node_map;
template<typename V>
struct node_iterator_type {
typedef node_seq::iterator seq;
typedef node_map::iterator map;
};
template<typename V>
struct node_iterator_type<const V> {
typedef node_seq::const_iterator seq;
typedef node_map::const_iterator map;
};
template<typename V>
class node_iterator_base: public boost::iterator_facade<
node_iterator_base<V>,
node_iterator_value<V>,
std::bidirectional_iterator_tag,
node_iterator_value<V> >
{ {
private: private:
struct enabler {}; struct enabler {};
public: public:
typedef typename node_iterator_type<V>::seq SeqIter;
typedef typename node_iterator_type<V>::map MapIter;
typedef node_iterator_value<V> value_type; typedef node_iterator_value<V> value_type;
iterator_base(): m_type(iterator_type::None) {} node_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(SeqIter seqIt): m_type(iterator_type::Sequence), m_seqIt(seqIt) {}
explicit node_iterator_base(MapIter mapIt): m_type(iterator_type::Map), m_mapIt(mapIt) {} explicit node_iterator_base(MapIter mapIt): m_type(iterator_type::Map), m_mapIt(mapIt) {}
template<typename W, typename I, typename J> template<typename W>
node_iterator_base(const node_iterator_base<W, I, J>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler()) node_iterator_base(const node_iterator_base<W>& 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) {} : m_type(rhs.m_type), 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 node_iterator_base; template<typename> friend class node_iterator_base;
template<typename W, typename I, typename J> template<typename W>
bool equal(const node_iterator_base<W, I, J>& rhs) const { bool equal(const node_iterator_base<W>& rhs) const {
if(m_type != rhs.m_type) if(m_type != rhs.m_type)
return false; return false;
@ -83,7 +106,7 @@ namespace YAML
value_type dereference() const { value_type dereference() const {
switch(m_type) { switch(m_type) {
case iterator_type::None: return value_type(); case iterator_type::None: return value_type();
case iterator_type::Sequence: return value_type(**m_seqIt)); case iterator_type::Sequence: return value_type(**m_seqIt);
case iterator_type::Map: return value_type(*m_mapIt->first, *m_mapIt->second); case iterator_type::Map: return value_type(*m_mapIt->first, *m_mapIt->second);
} }
return V(); return V();
@ -95,25 +118,9 @@ namespace YAML
SeqIter m_seqIt; SeqIter m_seqIt;
MapIter m_mapIt; 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<node> node_iterator;
typedef node_iterator_base<const node, node_seq_const_iterator, node_map_const_iterator> const_node_iterator; typedef node_iterator_base<const node> const_node_iterator;
} }
} }