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,24 +16,27 @@ namespace YAML
{
namespace detail
{
template<typename V> struct iterator_value;
struct iterator_value;
template<typename V>
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>,
node_iterator,
V,
std::bidirectional_iterator_tag>
{
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:
iterator_base() {}
explicit iterator_base(base_type rhs, shared_memory_holder pMemory): iterator_base::iterator_adaptor_(rhs), m_pMemory(pMemory) {}
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:
friend class boost::iterator_core_access;
@ -41,6 +44,15 @@ namespace YAML
void increment() { this->base_reference() = this->base()->next(); }
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:
shared_memory_holder m_pMemory;
};

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

@ -16,22 +16,12 @@ namespace YAML
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;
class iterator_value;
template<typename V> class iterator_base;
}
typedef detail::iterator_base<detail::iterator_value, detail::node_seq_iterator, detail::node_map_iterator> iterator;
typedef detail::iterator_base<const detail::iterator_value, detail::node_seq_const_iterator, detail::node_map_const_iterator> const_iterator;
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

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

@ -22,37 +22,60 @@ namespace YAML
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) {}
node_iterator_value(): pNode(0), pKey(0), pValue(0) {}
explicit node_iterator_value(V& rhs): pNode(&rhs), pKey(0), pValue(0) {}
explicit node_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>
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_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:
struct enabler {};
public:
typedef typename node_iterator_type<V>::seq SeqIter;
typedef typename node_iterator_type<V>::map MapIter;
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(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())
template<typename W>
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) {}
private:
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>
bool equal(const node_iterator_base<W, I, J>& rhs) const {
template<typename W>
bool equal(const node_iterator_base<W>& rhs) const {
if(m_type != rhs.m_type)
return false;
@ -83,7 +106,7 @@ namespace YAML
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::Sequence: return value_type(**m_seqIt);
case iterator_type::Map: return value_type(*m_mapIt->first, *m_mapIt->second);
}
return V();
@ -96,24 +119,8 @@ namespace YAML
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;
typedef node_iterator_base<node> node_iterator;
typedef node_iterator_base<const node> const_node_iterator;
}
}