Skip to content

Y
yaml-cpp
Commit d63ec48c by Jesse Beder
Options

Run clang-format

parent 3355bbb3
Showing with 795 additions and 754 deletions
include/yaml-cpp/node/detail/bool_type.h
#ifndef NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define NODE_DETAIL_BOOL_TYPE_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
namespace YAML namespace YAML {
{ namespace detail {
namespace detail struct unspecified_bool {
{
struct unspecified_bool {
struct NOT_ALLOWED; struct NOT_ALLOWED;
static void true_value(NOT_ALLOWED*) {} static void true_value(NOT_ALLOWED*) {}
}; };
typedef void (*unspecified_bool_type)(unspecified_bool::NOT_ALLOWED*); typedef void (*unspecified_bool_type)(unspecified_bool::NOT_ALLOWED*);
}
} }
#define YAML_CPP_OPERATOR_BOOL()\
operator YAML::detail::unspecified_bool_type() const\
{\
return this->operator!() ? 0 : &YAML::detail::unspecified_bool::true_value;\
} }
#define YAML_CPP_OPERATOR_BOOL() \
operator YAML::detail::unspecified_bool_type() const { \
return this->operator!() ? 0 \
: &YAML::detail::unspecified_bool::true_value; \
}
#endif // NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/node/detail/impl.h
#ifndef NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define NODE_DETAIL_IMPL_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
#include "yaml-cpp/node/detail/node.h" #include "yaml-cpp/node/detail/node.h"
#include "yaml-cpp/node/detail/node_data.h" #include "yaml-cpp/node/detail/node_data.h"
#include <boost/type_traits.hpp> #include <boost/type_traits.hpp>
namespace YAML namespace YAML {
{ namespace detail {
namespace detail template <typename Key, typename Enable = void>
{ struct get_idx {
template<typename Key, typename Enable = void> static node* get(const std::vector<node*>& /* sequence */,
struct get_idx { const Key& /* key */, shared_memory_holder /* pMemory */) {
static node *get(const std::vector<node *>& /* sequence */, const Key& /* key */, shared_memory_holder /* pMemory */) {
return 0; return 0;
} }
}; };
template<typename Key> template <typename Key>
struct get_idx<Key, typename boost::enable_if_c<boost::is_unsigned<Key>::value && !boost::is_same<Key, bool>::value>::type> { struct get_idx<
static node *get(const std::vector<node *>& sequence, const Key& key, shared_memory_holder /* pMemory */) { Key, typename boost::enable_if_c<boost::is_unsigned<Key>::value &&
!boost::is_same<Key, bool>::value>::type> {
static node* get(const std::vector<node*>& sequence, const Key& key,
shared_memory_holder /* pMemory */) {
return key < sequence.size() ? sequence[key] : 0; return key < sequence.size() ? sequence[key] : 0;
} }
static node *get(std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) { static node* get(std::vector<node*>& sequence, const Key& key,
if(key > sequence.size()) shared_memory_holder pMemory) {
if (key > sequence.size())
return 0; return 0;
if(key == sequence.size()) if (key == sequence.size())
sequence.push_back(&pMemory->create_node()); sequence.push_back(&pMemory->create_node());
return sequence[key]; return sequence[key];
} }
}; };
template<typename Key> template <typename Key>
struct get_idx<Key, typename boost::enable_if<boost::is_signed<Key> >::type> { struct get_idx<Key, typename boost::enable_if<boost::is_signed<Key> >::type> {
static node *get(const std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) { static node* get(const std::vector<node*>& sequence, const Key& key,
return key >= 0 ? get_idx<std::size_t>::get(sequence, static_cast<std::size_t>(key), pMemory) : 0; shared_memory_holder pMemory) {
} return key >= 0 ? get_idx<std::size_t>::get(
static node *get(std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) { sequence, static_cast<std::size_t>(key), pMemory)
return key >= 0 ? get_idx<std::size_t>::get(sequence, static_cast<std::size_t>(key), pMemory) : 0; : 0;
} }
}; static node* get(std::vector<node*>& sequence, const Key& key,
shared_memory_holder pMemory) {
// indexing return key >= 0 ? get_idx<std::size_t>::get(
template<typename Key> sequence, static_cast<std::size_t>(key), pMemory)
inline node& node_data::get(const Key& key, shared_memory_holder pMemory) const : 0;
{ }
switch(m_type) { };
// indexing
template <typename Key>
inline node& node_data::get(const Key& key,
shared_memory_holder pMemory) const {
switch (m_type) {
case NodeType::Map: case NodeType::Map:
break; break;
case NodeType::Undefined: case NodeType::Undefined:
case NodeType::Null: case NodeType::Null:
return pMemory->create_node(); return pMemory->create_node();
case NodeType::Sequence: case NodeType::Sequence:
if(node *pNode = get_idx<Key>::get(m_sequence, key, pMemory)) if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory))
return *pNode; return *pNode;
return pMemory->create_node(); return pMemory->create_node();
case NodeType::Scalar: case NodeType::Scalar:
throw BadSubscript(); throw BadSubscript();
} }
for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) { for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
if(equals(*it->first, key, pMemory)) if (equals(*it->first, key, pMemory))
return *it->second; return *it->second;
} }
return pMemory->create_node(); return pMemory->create_node();
} }
template<typename Key> template <typename Key>
inline node& node_data::get(const Key& key, shared_memory_holder pMemory) inline node& node_data::get(const Key& key, shared_memory_holder pMemory) {
{ switch (m_type) {
switch(m_type) {
case NodeType::Map: case NodeType::Map:
break; break;
case NodeType::Undefined: case NodeType::Undefined:
case NodeType::Null: case NodeType::Null:
case NodeType::Sequence: case NodeType::Sequence:
if(node *pNode = get_idx<Key>::get(m_sequence, key, pMemory)) { if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory)) {
m_type = NodeType::Sequence; m_type = NodeType::Sequence;
return *pNode; return *pNode;
} }
...@@ -92,8 +101,8 @@ namespace YAML ...@@ -92,8 +101,8 @@ namespace YAML
throw BadSubscript(); throw BadSubscript();
} }
for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) { for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
if(equals(*it->first, key, pMemory)) if (equals(*it->first, key, pMemory))
return *it->second; return *it->second;
} }
...@@ -101,29 +110,28 @@ namespace YAML ...@@ -101,29 +110,28 @@ namespace YAML
node& v = pMemory->create_node(); node& v = pMemory->create_node();
insert_map_pair(k, v); insert_map_pair(k, v);
return v; return v;
} }
template<typename Key> template <typename Key>
inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) {
{ if (m_type != NodeType::Map)
if(m_type != NodeType::Map)
return false; return false;
for(node_map::iterator it=m_map.begin();it!=m_map.end();++it) { for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) {
if(equals(*it->first, key, pMemory)) { if (equals(*it->first, key, pMemory)) {
m_map.erase(it); m_map.erase(it);
return true; return true;
} }
} }
return false; return false;
} }
// map // map
template<typename Key, typename Value> template <typename Key, typename Value>
inline void node_data::force_insert(const Key& key, const Value& value, shared_memory_holder pMemory) inline void node_data::force_insert(const Key& key, const Value& value,
{ shared_memory_holder pMemory) {
switch(m_type) { switch (m_type) {
case NodeType::Map: case NodeType::Map:
break; break;
case NodeType::Undefined: case NodeType::Undefined:
...@@ -138,31 +146,31 @@ namespace YAML ...@@ -138,31 +146,31 @@ namespace YAML
node& k = convert_to_node(key, pMemory); node& k = convert_to_node(key, pMemory);
node& v = convert_to_node(value, pMemory); node& v = convert_to_node(value, pMemory);
insert_map_pair(k, v); insert_map_pair(k, v);
} }
template<typename T> template <typename T>
inline bool node_data::equals(node& node, const T& rhs, shared_memory_holder pMemory) inline bool node_data::equals(node& node, const T& rhs,
{ shared_memory_holder pMemory) {
T lhs; T lhs;
if(convert<T>::decode(Node(node, pMemory), lhs)) if (convert<T>::decode(Node(node, pMemory), lhs))
return lhs == rhs; return lhs == rhs;
return false; return false;
} }
inline bool node_data::equals(node& node, const char *rhs, shared_memory_holder pMemory) inline bool node_data::equals(node& node, const char* rhs,
{ shared_memory_holder pMemory) {
return equals<std::string>(node, rhs, pMemory); return equals<std::string>(node, rhs, pMemory);
} }
template<typename T> template <typename T>
inline node& node_data::convert_to_node(const T& rhs, shared_memory_holder pMemory) inline node& node_data::convert_to_node(const T& rhs,
{ shared_memory_holder pMemory) {
Node value = convert<T>::encode(rhs); Node value = convert<T>::encode(rhs);
value.EnsureNodeExists(); value.EnsureNodeExists();
pMemory->merge(*value.m_pMemory); pMemory->merge(*value.m_pMemory);
return *value.m_pNode; return *value.m_pNode;
} }
} }
} }
#endif // NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/node/detail/iterator.h
#ifndef VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define VALUE_DETAIL_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
#include "yaml-cpp/dll.h" #include "yaml-cpp/dll.h"
#include "yaml-cpp/node/ptr.h" #include "yaml-cpp/node/ptr.h"
#include "yaml-cpp/node/detail/node_iterator.h" #include "yaml-cpp/node/detail/node_iterator.h"
#include <boost/iterator/iterator_adaptor.hpp> #include <boost/iterator/iterator_adaptor.hpp>
#include <boost/utility.hpp> #include <boost/utility.hpp>
namespace YAML namespace YAML {
{ namespace detail {
namespace detail struct iterator_value;
{
struct iterator_value;
template<typename V> template <typename V>
class iterator_base: public boost::iterator_adaptor< class iterator_base
iterator_base<V>, : public boost::iterator_adaptor<iterator_base<V>, node_iterator, V,
node_iterator, std::forward_iterator_tag, V> {
V,
std::forward_iterator_tag,
V>
{
private: private:
template<typename> friend class iterator_base; template <typename>
friend class iterator_base;
struct enabler {}; struct enabler {};
typedef typename iterator_base::base_type base_type; typedef typename iterator_base::base_type base_type;
...@@ -36,10 +32,16 @@ namespace YAML ...@@ -36,10 +32,16 @@ namespace YAML
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;
...@@ -48,17 +50,17 @@ namespace YAML ...@@ -48,17 +50,17 @@ namespace YAML
value_type dereference() const { value_type dereference() const {
const typename base_type::value_type& v = *this->base(); const typename base_type::value_type& v = *this->base();
if(v.pNode) if (v.pNode)
return value_type(Node(*v, m_pMemory)); return value_type(Node(*v, m_pMemory));
if(v.first && v.second) if (v.first && v.second)
return value_type(Node(*v.first, m_pMemory), Node(*v.second, m_pMemory)); return value_type(Node(*v.first, m_pMemory), Node(*v.second, m_pMemory));
return value_type(); return value_type();
} }
private: private:
shared_memory_holder m_pMemory; shared_memory_holder m_pMemory;
}; };
} }
} }
#endif // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/node/detail/iterator_fwd.h
#ifndef VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define VALUE_DETAIL_ITERATOR_FWD_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
#include "yaml-cpp/dll.h" #include "yaml-cpp/dll.h"
#include <list> #include <list>
#include <utility> #include <utility>
#include <vector> #include <vector>
namespace YAML namespace YAML {
{ class node;
class node;
namespace detail { namespace detail {
struct iterator_value; struct iterator_value;
template<typename V> class iterator_base; template <typename V>
} class iterator_base;
}
typedef detail::iterator_base<detail::iterator_value> iterator; typedef detail::iterator_base<detail::iterator_value> iterator;
typedef detail::iterator_base<const detail::iterator_value> const_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
include/yaml-cpp/node/detail/memory.h
#ifndef VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define VALUE_DETAIL_MEMORY_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
...@@ -9,11 +11,9 @@ ...@@ -9,11 +11,9 @@
#include <set> #include <set>
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
namespace YAML namespace YAML {
{ namespace detail {
namespace detail class memory {
{
class memory {
public: public:
node& create_node(); node& create_node();
void merge(const memory& rhs); void merge(const memory& rhs);
...@@ -21,19 +21,19 @@ namespace YAML ...@@ -21,19 +21,19 @@ namespace YAML
private: private:
typedef std::set<shared_node> Nodes; typedef std::set<shared_node> Nodes;
Nodes m_nodes; Nodes m_nodes;
}; };
class memory_holder { class memory_holder {
public: public:
memory_holder(): m_pMemory(new memory) {} memory_holder() : m_pMemory(new memory) {}
node& create_node() { return m_pMemory->create_node(); } node& create_node() { return m_pMemory->create_node(); }
void merge(memory_holder& rhs); void merge(memory_holder& rhs);
private: private:
boost::shared_ptr<memory> m_pMemory; boost::shared_ptr<memory> m_pMemory;
}; };
} }
} }
#endif // VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/node/detail/node.h
#ifndef NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define NODE_DETAIL_NODE_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
#include "yaml-cpp/dll.h" #include "yaml-cpp/dll.h"
#include "yaml-cpp/node/type.h" #include "yaml-cpp/node/type.h"
#include "yaml-cpp/node/ptr.h" #include "yaml-cpp/node/ptr.h"
...@@ -13,17 +14,14 @@ ...@@ -13,17 +14,14 @@
#include <set> #include <set>
#include <boost/utility.hpp> #include <boost/utility.hpp>
namespace YAML namespace YAML {
{ namespace detail {
namespace detail class node : private boost::noncopyable {
{
class node: private boost::noncopyable
{
public: public:
node(): m_pRef(new node_ref) {} node() : m_pRef(new node_ref) {}
bool is(const node& rhs) const { return m_pRef == rhs.m_pRef; } bool is(const node& rhs) const { return m_pRef == rhs.m_pRef; }
const node_ref *ref() const { return m_pRef.get(); } const node_ref* ref() const { return m_pRef.get(); }
bool is_defined() const { return m_pRef->is_defined(); } bool is_defined() const { return m_pRef->is_defined(); }
NodeType::value type() const { return m_pRef->type(); } NodeType::value type() const { return m_pRef->type(); }
...@@ -32,35 +30,36 @@ namespace YAML ...@@ -32,35 +30,36 @@ namespace YAML
const std::string& tag() const { return m_pRef->tag(); } const std::string& tag() const { return m_pRef->tag(); }
void mark_defined() { void mark_defined() {
if(is_defined()) if (is_defined())
return; return;
m_pRef->mark_defined(); m_pRef->mark_defined();
for(nodes::iterator it=m_dependencies.begin();it!=m_dependencies.end();++it) for (nodes::iterator it = m_dependencies.begin();
it != m_dependencies.end(); ++it)
(*it)->mark_defined(); (*it)->mark_defined();
m_dependencies.clear(); m_dependencies.clear();
} }
void add_dependency(node& rhs) { void add_dependency(node& rhs) {
if(is_defined()) if (is_defined())
rhs.mark_defined(); rhs.mark_defined();
else else
m_dependencies.insert(&rhs); m_dependencies.insert(&rhs);
} }
void set_ref(const node& rhs) { void set_ref(const node& rhs) {
if(rhs.is_defined()) if (rhs.is_defined())
mark_defined(); mark_defined();
m_pRef = rhs.m_pRef; m_pRef = rhs.m_pRef;
} }
void set_data(const node& rhs) { void set_data(const node& rhs) {
if(rhs.is_defined()) if (rhs.is_defined())
mark_defined(); mark_defined();
m_pRef->set_data(*rhs.m_pRef); m_pRef->set_data(*rhs.m_pRef);
} }
void set_type(NodeType::value type) { void set_type(NodeType::value type) {
if(type != NodeType::Undefined) if (type != NodeType::Undefined)
mark_defined(); mark_defined();
m_pRef->set_type(type); m_pRef->set_type(type);
} }
...@@ -80,10 +79,14 @@ namespace YAML ...@@ -80,10 +79,14 @@ namespace YAML
// size/iterator // size/iterator
std::size_t size() const { return m_pRef->size(); } std::size_t size() const { return m_pRef->size(); }
const_node_iterator begin() const { return static_cast<const node_ref&>(*m_pRef).begin(); } const_node_iterator begin() const {
return static_cast<const node_ref&>(*m_pRef).begin();
}
node_iterator begin() { return m_pRef->begin(); } node_iterator begin() { return m_pRef->begin(); }
const_node_iterator end() const { return static_cast<const node_ref&>(*m_pRef).end(); } const_node_iterator end() const {
return static_cast<const node_ref&>(*m_pRef).end();
}
node_iterator end() { return m_pRef->end(); } node_iterator end() { return m_pRef->end(); }
// sequence // sequence
...@@ -98,33 +101,47 @@ namespace YAML ...@@ -98,33 +101,47 @@ namespace YAML
} }
// indexing // indexing
template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const { return static_cast<const node_ref&>(*m_pRef).get(key, pMemory); } template <typename Key>
template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) { node& get(const Key& key, shared_memory_holder pMemory) const {
return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
}
template <typename Key>
node& get(const Key& key, shared_memory_holder pMemory) {
node& value = m_pRef->get(key, pMemory); node& value = m_pRef->get(key, pMemory);
value.add_dependency(*this); value.add_dependency(*this);
return value; return value;
} }
template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory) { return m_pRef->remove(key, pMemory); } template <typename Key>
bool remove(const Key& key, shared_memory_holder pMemory) {
return m_pRef->remove(key, pMemory);
}
node& get(node& key, shared_memory_holder pMemory) const { return static_cast<const node_ref&>(*m_pRef).get(key, pMemory); } node& get(node& key, shared_memory_holder pMemory) const {
return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
}
node& get(node& key, shared_memory_holder pMemory) { node& get(node& key, shared_memory_holder pMemory) {
node& value = m_pRef->get(key, pMemory); node& value = m_pRef->get(key, pMemory);
key.add_dependency(*this); key.add_dependency(*this);
value.add_dependency(*this); value.add_dependency(*this);
return value; return value;
} }
bool remove(node& key, shared_memory_holder pMemory) { return m_pRef->remove(key, pMemory); } bool remove(node& key, shared_memory_holder pMemory) {
return m_pRef->remove(key, pMemory);
}
// map // map
template<typename Key, typename Value> template <typename Key, typename Value>
void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory){ m_pRef->force_insert(key, value, pMemory); } void force_insert(const Key& key, const Value& value,
shared_memory_holder pMemory) {
m_pRef->force_insert(key, value, pMemory);
}
private: private:
shared_node_ref m_pRef; shared_node_ref m_pRef;
typedef std::set<node *> nodes; typedef std::set<node*> nodes;
nodes m_dependencies; nodes m_dependencies;
}; };
} }
} }
#endif // NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/node/detail/node_data.h
#ifndef VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define VALUE_DETAIL_NODE_DATA_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
#include "yaml-cpp/dll.h" #include "yaml-cpp/dll.h"
#include "yaml-cpp/node/iterator.h" #include "yaml-cpp/node/iterator.h"
#include "yaml-cpp/node/ptr.h" #include "yaml-cpp/node/ptr.h"
...@@ -15,12 +16,9 @@ ...@@ -15,12 +16,9 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
namespace YAML namespace YAML {
{ namespace detail {
namespace detail class node_data : private boost::noncopyable {
{
class node_data: private boost::noncopyable
{
public: public:
node_data(); node_data();
...@@ -31,7 +29,9 @@ namespace YAML ...@@ -31,7 +29,9 @@ namespace YAML
void set_scalar(const std::string& scalar); void set_scalar(const std::string& scalar);
bool is_defined() const { return m_isDefined; } bool is_defined() const { return m_isDefined; }
NodeType::value type() const { return m_isDefined ? m_type : NodeType::Undefined; } NodeType::value type() const {
return m_isDefined ? m_type : NodeType::Undefined;
}
const std::string& scalar() const { return m_scalar; } const std::string& scalar() const { return m_scalar; }
const std::string& tag() const { return m_tag; } const std::string& tag() const { return m_tag; }
...@@ -49,17 +49,21 @@ namespace YAML ...@@ -49,17 +49,21 @@ namespace YAML
void insert(node& key, node& value, shared_memory_holder pMemory); void insert(node& key, node& value, shared_memory_holder pMemory);
// indexing // indexing
template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const; template <typename Key>
template<typename Key> node& get(const Key& key, shared_memory_holder pMemory); node& get(const Key& key, shared_memory_holder pMemory) const;
template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory); template <typename Key>
node& get(const Key& key, shared_memory_holder pMemory);
template <typename Key>
bool remove(const Key& key, shared_memory_holder pMemory);
node& get(node& key, shared_memory_holder pMemory) const; node& get(node& key, shared_memory_holder pMemory) const;
node& get(node& key, shared_memory_holder pMemory); node& get(node& key, shared_memory_holder pMemory);
bool remove(node& key, shared_memory_holder pMemory); bool remove(node& key, shared_memory_holder pMemory);
// map // map
template<typename Key, typename Value> template <typename Key, typename Value>
void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory); void force_insert(const Key& key, const Value& value,
shared_memory_holder pMemory);
public: public:
static std::string empty_scalar; static std::string empty_scalar;
...@@ -75,11 +79,11 @@ namespace YAML ...@@ -75,11 +79,11 @@ namespace YAML
void convert_to_map(shared_memory_holder pMemory); void convert_to_map(shared_memory_holder pMemory);
void convert_sequence_to_map(shared_memory_holder pMemory); void convert_sequence_to_map(shared_memory_holder pMemory);
template<typename T> template <typename T>
static bool equals(node& node, const T& rhs, shared_memory_holder pMemory); static bool equals(node& node, const T& rhs, shared_memory_holder pMemory);
static bool equals(node& node, const char *rhs, shared_memory_holder pMemory); static bool equals(node& node, const char* rhs, shared_memory_holder pMemory);
template<typename T> template <typename T>
static node& convert_to_node(const T& rhs, shared_memory_holder pMemory); static node& convert_to_node(const T& rhs, shared_memory_holder pMemory);
private: private:
...@@ -91,20 +95,20 @@ namespace YAML ...@@ -91,20 +95,20 @@ namespace YAML
std::string m_scalar; std::string m_scalar;
// sequence // sequence
typedef std::vector<node *> node_seq; typedef std::vector<node*> node_seq;
node_seq m_sequence; node_seq m_sequence;
mutable std::size_t m_seqSize; mutable std::size_t m_seqSize;
// map // map
typedef std::map<node *, node *> node_map; typedef std::map<node*, node*> node_map;
node_map m_map; node_map m_map;
typedef std::pair<node *, node *> kv_pair; typedef std::pair<node*, node*> kv_pair;
typedef std::list<kv_pair> kv_pairs; typedef std::list<kv_pair> kv_pairs;
mutable kv_pairs m_undefinedPairs; mutable kv_pairs m_undefinedPairs;
}; };
} }
} }
#endif // VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/node/detail/node_iterator.h
#ifndef VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define 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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
#include "yaml-cpp/dll.h" #include "yaml-cpp/dll.h"
#include "yaml-cpp/node/ptr.h" #include "yaml-cpp/node/ptr.h"
#include <boost/iterator/iterator_facade.hpp> #include <boost/iterator/iterator_facade.hpp>
...@@ -14,49 +15,50 @@ ...@@ -14,49 +15,50 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
namespace YAML namespace YAML {
{ namespace detail {
namespace detail struct iterator_type {
{ enum value {
struct iterator_type { enum value { None, Sequence, Map }; }; None,
Sequence,
Map
};
};
template<typename V> template <typename V>
struct node_iterator_value: public std::pair<V*, V*> { struct node_iterator_value : public std::pair<V*, V*> {
typedef std::pair<V*, V*> kv; typedef std::pair<V*, V*> kv;
node_iterator_value(): kv(), pNode(0) {} node_iterator_value() : kv(), pNode(0) {}
explicit node_iterator_value(V& rhs): kv(), pNode(&rhs) {} explicit node_iterator_value(V& rhs) : kv(), pNode(&rhs) {}
explicit node_iterator_value(V& key, V& value): kv(&key, &value), pNode(0) {} explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(0) {}
V& operator *() const { return *pNode; } V& operator*() const { return *pNode; }
V& operator ->() const { return *pNode; } V& operator->() const { return *pNode; }
V *pNode; V* pNode;
}; };
typedef std::vector<node *> node_seq; typedef std::vector<node*> node_seq;
typedef std::map<node *, node *> node_map; typedef std::map<node*, node*> node_map;
template<typename V> template <typename V>
struct node_iterator_type { struct node_iterator_type {
typedef node_seq::iterator seq; typedef node_seq::iterator seq;
typedef node_map::iterator map; typedef node_map::iterator map;
}; };
template<typename V> template <typename V>
struct node_iterator_type<const V> { struct node_iterator_type<const V> {
typedef node_seq::const_iterator seq; typedef node_seq::const_iterator seq;
typedef node_map::const_iterator map; typedef node_map::const_iterator map;
}; };
template<typename V> template <typename V>
class node_iterator_base: public boost::iterator_facade< class node_iterator_base
node_iterator_base<V>, : public boost::iterator_facade<
node_iterator_value<V>, node_iterator_base<V>, node_iterator_value<V>,
std::forward_iterator_tag, std::forward_iterator_tag, node_iterator_value<V> > {
node_iterator_value<V> >
{
private: private:
struct enabler {}; struct enabler {};
...@@ -65,36 +67,49 @@ namespace YAML ...@@ -65,36 +67,49 @@ namespace YAML
typedef typename node_iterator_type<V>::map MapIter; typedef typename node_iterator_type<V>::map MapIter;
typedef node_iterator_value<V> value_type; typedef node_iterator_value<V> value_type;
node_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)
explicit node_iterator_base(MapIter mapIt, MapIter mapEnd): m_type(iterator_type::Map), m_mapIt(mapIt), m_mapEnd(mapEnd) { : m_type(iterator_type::Sequence), m_seqIt(seqIt) {}
explicit node_iterator_base(MapIter mapIt, MapIter mapEnd)
: m_type(iterator_type::Map), m_mapIt(mapIt), m_mapEnd(mapEnd) {
m_mapIt = increment_until_defined(m_mapIt); m_mapIt = increment_until_defined(m_mapIt);
} }
template<typename W> template <typename W>
node_iterator_base(const node_iterator_base<W>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler()) node_iterator_base(
: m_type(rhs.m_type), m_seqIt(rhs.m_seqIt), m_mapIt(rhs.m_mapIt), m_mapEnd(rhs.m_mapEnd) {} 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_mapEnd(rhs.m_mapEnd) {}
private: private:
friend class boost::iterator_core_access; friend class boost::iterator_core_access;
template<typename> friend class node_iterator_base; template <typename>
friend class node_iterator_base;
template<typename W> template <typename W>
bool equal(const node_iterator_base<W>& 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;
switch(m_type) { switch (m_type) {
case iterator_type::None: return true; case iterator_type::None:
case iterator_type::Sequence: return m_seqIt == rhs.m_seqIt; return true;
case iterator_type::Map: return m_mapIt == rhs.m_mapIt; case iterator_type::Sequence:
return m_seqIt == rhs.m_seqIt;
case iterator_type::Map:
return m_mapIt == rhs.m_mapIt;
} }
return true; return true;
} }
void increment() { void increment() {
switch(m_type) { switch (m_type) {
case iterator_type::None: break; case iterator_type::None:
break;
case iterator_type::Sequence: case iterator_type::Sequence:
++m_seqIt; ++m_seqIt;
break; break;
...@@ -106,16 +121,19 @@ namespace YAML ...@@ -106,16 +121,19 @@ 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:
case iterator_type::Sequence: return value_type(**m_seqIt); return value_type();
case iterator_type::Map: return value_type(*m_mapIt->first, *m_mapIt->second); case iterator_type::Sequence:
return value_type(**m_seqIt);
case iterator_type::Map:
return value_type(*m_mapIt->first, *m_mapIt->second);
} }
return value_type(); return value_type();
} }
MapIter increment_until_defined(MapIter it) { MapIter increment_until_defined(MapIter it) {
while(it != m_mapEnd && !is_defined(it)) while (it != m_mapEnd && !is_defined(it))
++it; ++it;
return it; return it;
} }
...@@ -129,11 +147,11 @@ namespace YAML ...@@ -129,11 +147,11 @@ namespace YAML
SeqIter m_seqIt; SeqIter m_seqIt;
MapIter m_mapIt, m_mapEnd; MapIter m_mapIt, m_mapEnd;
}; };
typedef node_iterator_base<node> node_iterator; typedef node_iterator_base<node> node_iterator;
typedef node_iterator_base<const node> const_node_iterator; typedef node_iterator_base<const node> const_node_iterator;
} }
} }
#endif // VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/node/detail/node_ref.h
#ifndef VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define VALUE_DETAIL_NODE_REF_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
#include "yaml-cpp/dll.h" #include "yaml-cpp/dll.h"
#include "yaml-cpp/node/type.h" #include "yaml-cpp/node/type.h"
#include "yaml-cpp/node/ptr.h" #include "yaml-cpp/node/ptr.h"
#include "yaml-cpp/node/detail/node_data.h" #include "yaml-cpp/node/detail/node_data.h"
#include <boost/utility.hpp> #include <boost/utility.hpp>
namespace YAML namespace YAML {
{ namespace detail {
namespace detail class node_ref : private boost::noncopyable {
{
class node_ref: private boost::noncopyable
{
public: public:
node_ref(): m_pData(new node_data) {} node_ref() : m_pData(new node_data) {}
bool is_defined() const { return m_pData->is_defined(); } bool is_defined() const { return m_pData->is_defined(); }
NodeType::value type() const { return m_pData->type(); } NodeType::value type() const { return m_pData->type(); }
...@@ -37,33 +35,59 @@ namespace YAML ...@@ -37,33 +35,59 @@ namespace YAML
// size/iterator // size/iterator
std::size_t size() const { return m_pData->size(); } std::size_t size() const { return m_pData->size(); }
const_node_iterator begin() const { return static_cast<const node_data&>(*m_pData).begin(); } const_node_iterator begin() const {
node_iterator begin() {return m_pData->begin(); } return static_cast<const node_data&>(*m_pData).begin();
}
node_iterator begin() { return m_pData->begin(); }
const_node_iterator end() const { return static_cast<const node_data&>(*m_pData).end(); } const_node_iterator end() const {
node_iterator end() {return m_pData->end(); } return static_cast<const node_data&>(*m_pData).end();
}
node_iterator end() { return m_pData->end(); }
// sequence // sequence
void push_back(node& node, shared_memory_holder pMemory) { m_pData->push_back(node, pMemory); } void push_back(node& node, shared_memory_holder pMemory) {
void insert(node& key, node& value, shared_memory_holder pMemory) { m_pData->insert(key, value, pMemory); } m_pData->push_back(node, pMemory);
}
void insert(node& key, node& value, shared_memory_holder pMemory) {
m_pData->insert(key, value, pMemory);
}
// indexing // indexing
template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const { return static_cast<const node_data&>(*m_pData).get(key, pMemory); } template <typename Key>
template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) { return m_pData->get(key, pMemory); } node& get(const Key& key, shared_memory_holder pMemory) const {
template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory) { return m_pData->remove(key, pMemory); } return static_cast<const node_data&>(*m_pData).get(key, pMemory);
}
template <typename Key>
node& get(const Key& key, shared_memory_holder pMemory) {
return m_pData->get(key, pMemory);
}
template <typename Key>
bool remove(const Key& key, shared_memory_holder pMemory) {
return m_pData->remove(key, pMemory);
}
node& get(node& key, shared_memory_holder pMemory) const { return static_cast<const node_data&>(*m_pData).get(key, pMemory); } node& get(node& key, shared_memory_holder pMemory) const {
node& get(node& key, shared_memory_holder pMemory) { return m_pData->get(key, pMemory); } return static_cast<const node_data&>(*m_pData).get(key, pMemory);
bool remove(node& key, shared_memory_holder pMemory) { return m_pData->remove(key, pMemory); } }
node& get(node& key, shared_memory_holder pMemory) {
return m_pData->get(key, pMemory);
}
bool remove(node& key, shared_memory_holder pMemory) {
return m_pData->remove(key, pMemory);
}
// map // map
template<typename Key, typename Value> template <typename Key, typename Value>
void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory) { m_pData->force_insert(key, value, pMemory); } void force_insert(const Key& key, const Value& value,
shared_memory_holder pMemory) {
m_pData->force_insert(key, value, pMemory);
}
private: private:
shared_node_data m_pData; shared_node_data m_pData;
}; };
} }
} }
#endif // VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/node/emit.h
#ifndef NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define NODE_EMIT_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
#include <string> #include <string>
#include <iosfwd> #include <iosfwd>
namespace YAML namespace YAML {
{ class Emitter;
class Emitter; class Node;
class Node;
Emitter& operator << (Emitter& out, const Node& node); Emitter& operator<<(Emitter& out, const Node& node);
std::ostream& operator << (std::ostream& out, const Node& node); std::ostream& operator<<(std::ostream& out, const Node& node);
std::string Dump(const Node& node); std::string Dump(const Node& node);
} }
#endif // NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/node/iterator.h
#ifndef VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define VALUE_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
#include "yaml-cpp/dll.h" #include "yaml-cpp/dll.h"
#include "yaml-cpp/node/node.h" #include "yaml-cpp/node/node.h"
#include "yaml-cpp/node/detail/iterator_fwd.h" #include "yaml-cpp/node/detail/iterator_fwd.h"
...@@ -14,15 +15,17 @@ ...@@ -14,15 +15,17 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
namespace YAML namespace YAML {
{ namespace detail {
namespace detail { struct iterator_value : public Node, std::pair<Node, Node> {
struct iterator_value: public Node, std::pair<Node, Node> {
iterator_value() {} iterator_value() {}
explicit iterator_value(const Node& rhs): Node(rhs), std::pair<Node, Node>(Node(Node::ZombieNode), Node(Node::ZombieNode)) {} explicit iterator_value(const Node& rhs)
explicit iterator_value(const Node& key, const Node& value): Node(Node::ZombieNode), std::pair<Node, Node>(key, value) {} : Node(rhs),
}; std::pair<Node, Node>(Node(Node::ZombieNode), Node(Node::ZombieNode)) {}
} explicit iterator_value(const Node& key, const Node& value)
: Node(Node::ZombieNode), std::pair<Node, Node>(key, value) {}
};
}
} }
#endif // VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/node/node.h
#ifndef NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define NODE_NODE_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
#include "yaml-cpp/dll.h" #include "yaml-cpp/dll.h"
#include "yaml-cpp/node/ptr.h" #include "yaml-cpp/node/ptr.h"
#include "yaml-cpp/node/type.h" #include "yaml-cpp/node/type.h"
...@@ -13,24 +14,25 @@ ...@@ -13,24 +14,25 @@
#include "yaml-cpp/node/detail/bool_type.h" #include "yaml-cpp/node/detail/bool_type.h"
#include <stdexcept> #include <stdexcept>
namespace YAML namespace YAML {
{ class Node {
class Node
{
public: public:
friend class NodeBuilder; friend class NodeBuilder;
friend class NodeEvents; friend class NodeEvents;
friend struct detail::iterator_value; friend struct detail::iterator_value;
friend class detail::node_data; friend class detail::node_data;
template<typename> friend class detail::iterator_base; template <typename>
template<typename T, typename S> friend struct as_if; friend class detail::iterator_base;
template <typename T, typename S>
friend struct as_if;
typedef YAML::iterator iterator; typedef YAML::iterator iterator;
typedef YAML::const_iterator const_iterator; typedef YAML::const_iterator const_iterator;
Node(); Node();
explicit Node(NodeType::value type); explicit Node(NodeType::value type);
template<typename T> explicit Node(const T& rhs); template <typename T>
explicit Node(const T& rhs);
explicit Node(const detail::iterator_value& rhs); explicit Node(const detail::iterator_value& rhs);
Node(const Node& rhs); Node(const Node& rhs);
~Node(); ~Node();
...@@ -47,15 +49,18 @@ namespace YAML ...@@ -47,15 +49,18 @@ namespace YAML
bool operator!() const { return !IsDefined(); } bool operator!() const { return !IsDefined(); }
// access // access
template<typename T> const T as() const; template <typename T>
template<typename T, typename S> const T as(const S& fallback) const; const T as() const;
template <typename T, typename S>
const T as(const S& fallback) const;
const std::string& Scalar() const; const std::string& Scalar() const;
const std::string& Tag() const; const std::string& Tag() const;
void SetTag(const std::string& tag); void SetTag(const std::string& tag);
// assignment // assignment
bool is(const Node& rhs) const; bool is(const Node& rhs) const;
template<typename T> Node& operator=(const T& rhs); template <typename T>
Node& operator=(const T& rhs);
Node& operator=(const Node& rhs); Node& operator=(const Node& rhs);
void reset(const Node& rhs = Node()); void reset(const Node& rhs = Node());
...@@ -69,32 +74,39 @@ namespace YAML ...@@ -69,32 +74,39 @@ namespace YAML
iterator end(); iterator end();
// sequence // sequence
template<typename T> void push_back(const T& rhs); template <typename T>
void push_back(const T& rhs);
void push_back(const Node& rhs); void push_back(const Node& rhs);
// indexing // indexing
template<typename Key> const Node operator[](const Key& key) const; template <typename Key>
template<typename Key> Node operator[](const Key& key); const Node operator[](const Key& key) const;
template<typename Key> bool remove(const Key& key); template <typename Key>
Node operator[](const Key& key);
template <typename Key>
bool remove(const Key& key);
const Node operator[](const Node& key) const; const Node operator[](const Node& key) const;
Node operator[](const Node& key); Node operator[](const Node& key);
bool remove(const Node& key); bool remove(const Node& key);
// map // map
template<typename Key, typename Value> template <typename Key, typename Value>
void force_insert(const Key& key, const Value& value); void force_insert(const Key& key, const Value& value);
private: private:
enum Zombie { ZombieNode }; enum Zombie {
ZombieNode
};
explicit Node(Zombie); explicit Node(Zombie);
explicit Node(detail::node& node, detail::shared_memory_holder pMemory); explicit Node(detail::node& node, detail::shared_memory_holder pMemory);
void EnsureNodeExists() const; void EnsureNodeExists() const;
template<typename T> void Assign(const T& rhs); template <typename T>
void Assign(const char *rhs); void Assign(const T& rhs);
void Assign(char *rhs); void Assign(const char* rhs);
void Assign(char* rhs);
void AssignData(const Node& rhs); void AssignData(const Node& rhs);
void AssignNode(const Node& rhs); void AssignNode(const Node& rhs);
...@@ -102,15 +114,15 @@ namespace YAML ...@@ -102,15 +114,15 @@ namespace YAML
private: private:
bool m_isValid; bool m_isValid;
mutable detail::shared_memory_holder m_pMemory; mutable detail::shared_memory_holder m_pMemory;
mutable detail::node *m_pNode; mutable detail::node* m_pNode;
}; };
bool operator==(const Node& lhs, const Node& rhs); bool operator==(const Node& lhs, const Node& rhs);
Node Clone(const Node& node); Node Clone(const Node& node);
template<typename T> template <typename T>
struct convert; struct convert;
} }
#endif // NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/node/parse.h
#ifndef VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define VALUE_PARSE_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
...@@ -9,20 +11,18 @@ ...@@ -9,20 +11,18 @@
#include <string> #include <string>
#include <vector> #include <vector>
namespace YAML namespace YAML {
{ class Node;
class Node;
Node Load(const std::string& input); Node Load(const std::string& input);
Node Load(const char *input); Node Load(const char* input);
Node Load(std::istream& input); Node Load(std::istream& input);
Node LoadFile(const std::string& filename); Node LoadFile(const std::string& filename);
std::vector<Node> LoadAll(const std::string& input); std::vector<Node> LoadAll(const std::string& input);
std::vector<Node> LoadAll(const char *input); std::vector<Node> LoadAll(const char* input);
std::vector<Node> LoadAll(std::istream& input); std::vector<Node> LoadAll(std::istream& input);
std::vector<Node> LoadAllFromFile(const std::string& filename); std::vector<Node> LoadAllFromFile(const std::string& filename);
} }
#endif // VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/node/ptr.h
#ifndef VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define VALUE_PTR_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
#include "yaml-cpp/dll.h" #include "yaml-cpp/dll.h"
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
namespace YAML namespace YAML {
{ namespace detail {
namespace detail { class node;
class node; class node_ref;
class node_ref; class node_data;
class node_data; class memory;
class memory; class memory_holder;
class memory_holder;
typedef boost::shared_ptr<node> shared_node; typedef boost::shared_ptr<node> shared_node;
typedef boost::shared_ptr<node_ref> shared_node_ref; typedef boost::shared_ptr<node_ref> shared_node_ref;
typedef boost::shared_ptr<node_data> shared_node_data; typedef boost::shared_ptr<node_data> shared_node_data;
typedef boost::shared_ptr<memory_holder> shared_memory_holder; typedef boost::shared_ptr<memory_holder> shared_memory_holder;
typedef boost::shared_ptr<memory> shared_memory; typedef boost::shared_ptr<memory> shared_memory;
} }
} }
#endif // VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/node/type.h
#ifndef VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define VALUE_TYPE_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
namespace YAML {
namespace YAML struct NodeType {
{ enum value {
struct NodeType { enum value { Undefined, Null, Scalar, Sequence, Map }; }; Undefined,
Null,
Scalar,
Sequence,
Map
};
};
} }
#endif // VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/parser.h
#ifndef PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define PARSER_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
#include "yaml-cpp/dll.h" #include "yaml-cpp/dll.h"
#include "yaml-cpp/noncopyable.h" #include "yaml-cpp/noncopyable.h"
#include <ios> #include <ios>
#include <memory> #include <memory>
namespace YAML namespace YAML {
{ struct Directives;
struct Directives; struct Token;
struct Token; class EventHandler;
class EventHandler; class Scanner;
class Scanner;
class YAML_CPP_API Parser: private noncopyable class YAML_CPP_API Parser : private noncopyable {
{
public: public:
Parser(); Parser();
Parser(std::istream& in); Parser(std::istream& in);
...@@ -41,7 +40,7 @@ namespace YAML ...@@ -41,7 +40,7 @@ namespace YAML
private: private:
std::auto_ptr<Scanner> m_pScanner; std::auto_ptr<Scanner> m_pScanner;
std::auto_ptr<Directives> m_pDirectives; std::auto_ptr<Directives> m_pDirectives;
}; };
} }
#endif // PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
include/yaml-cpp/yaml.h
#ifndef YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define YAML_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
......
src/convert.cpp
...@@ -2,53 +2,48 @@ ...@@ -2,53 +2,48 @@
#include "yaml-cpp/node/impl.h" #include "yaml-cpp/node/impl.h"
#include <algorithm> #include <algorithm>
namespace namespace {
{ // we're not gonna mess with the mess that is all the isupper/etc. functions
// we're not gonna mess with the mess that is all the isupper/etc. functions bool IsLower(char ch) { return 'a' <= ch && ch <= 'z'; }
bool IsLower(char ch) { return 'a' <= ch && ch <= 'z'; } bool IsUpper(char ch) { return 'A' <= ch && ch <= 'Z'; }
bool IsUpper(char ch) { return 'A' <= ch && ch <= 'Z'; } char ToLower(char ch) { return IsUpper(ch) ? ch + 'a' - 'A' : ch; }
char ToLower(char ch) { return IsUpper(ch) ? ch + 'a' - 'A' : ch; }
std::string tolower(const std::string& str) std::string tolower(const std::string& str) {
{
std::string s(str); std::string s(str);
std::transform(s.begin(), s.end(), s.begin(), ToLower); std::transform(s.begin(), s.end(), s.begin(), ToLower);
return s; return s;
} }
template <typename T> template <typename T>
bool IsEntirely(const std::string& str, T func) bool IsEntirely(const std::string& str, T func) {
{ for (std::size_t i = 0; i < str.size(); i++)
for(std::size_t i=0;i<str.size();i++) if (!func(str[i]))
if(!func(str[i]))
return false; return false;
return true; return true;
} }
// IsFlexibleCase // IsFlexibleCase
// . Returns true if 'str' is: // . Returns true if 'str' is:
// . UPPERCASE // . UPPERCASE
// . lowercase // . lowercase
// . Capitalized // . Capitalized
bool IsFlexibleCase(const std::string& str) bool IsFlexibleCase(const std::string& str) {
{ if (str.empty())
if(str.empty())
return true; return true;
if(IsEntirely(str, IsLower)) if (IsEntirely(str, IsLower))
return true; return true;
bool firstcaps = IsUpper(str[0]); bool firstcaps = IsUpper(str[0]);
std::string rest = str.substr(1); std::string rest = str.substr(1);
return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper)); return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper));
} }
} }
namespace YAML namespace YAML {
{ bool convert<bool>::decode(const Node& node, bool& rhs) {
bool convert<bool>::decode(const Node& node, bool& rhs) { if (!node.IsScalar())
if(!node.IsScalar())
return false; return false;
// we can't use iostream bool extraction operators as they don't // we can't use iostream bool extraction operators as they don't
...@@ -56,28 +51,23 @@ namespace YAML ...@@ -56,28 +51,23 @@ namespace YAML
// http://yaml.org/type/bool.html) // http://yaml.org/type/bool.html)
static const struct { static const struct {
std::string truename, falsename; std::string truename, falsename;
} names[] = { } names[] = {{"y", "n"}, {"yes", "no"}, {"true", "false"}, {"on", "off"}, };
{ "y", "n" },
{ "yes", "no" },
{ "true", "false" },
{ "on", "off" },
};
if(!IsFlexibleCase(node.Scalar())) if (!IsFlexibleCase(node.Scalar()))
return false; return false;
for(unsigned i=0;i<sizeof(names)/sizeof(names[0]);i++) { for (unsigned i = 0; i < sizeof(names) / sizeof(names[0]); i++) {
if(names[i].truename == tolower(node.Scalar())) { if (names[i].truename == tolower(node.Scalar())) {
rhs = true; rhs = true;
return true; return true;
} }
if(names[i].falsename == tolower(node.Scalar())) { if (names[i].falsename == tolower(node.Scalar())) {
rhs = false; rhs = false;
return true; return true;
} }
} }
return false; return false;
} }
} }
src/emit.cpp
...@@ -3,27 +3,23 @@ ...@@ -3,27 +3,23 @@
#include "yaml-cpp/emitter.h" #include "yaml-cpp/emitter.h"
#include "nodeevents.h" #include "nodeevents.h"
namespace YAML namespace YAML {
{ Emitter& operator<<(Emitter& out, const Node& node) {
Emitter& operator << (Emitter& out, const Node& node)
{
EmitFromEvents emitFromEvents(out); EmitFromEvents emitFromEvents(out);
NodeEvents events(node); NodeEvents events(node);
events.Emit(emitFromEvents); events.Emit(emitFromEvents);
return out; return out;
} }
std::ostream& operator << (std::ostream& out, const Node& node) std::ostream& operator<<(std::ostream& out, const Node& node) {
{
Emitter emitter(out); Emitter emitter(out);
emitter << node; emitter << node;
return out; return out;
} }
std::string Dump(const Node& node) std::string Dump(const Node& node) {
{
Emitter emitter; Emitter emitter;
emitter << node; emitter << node;
return emitter.c_str(); return emitter.c_str();
} }
} }
src/memory.cpp
#include "yaml-cpp/node/detail/memory.h" #include "yaml-cpp/node/detail/memory.h"
#include "yaml-cpp/node/detail/node.h" #include "yaml-cpp/node/detail/node.h"
namespace YAML namespace YAML {
{ namespace detail {
namespace detail void memory_holder::merge(memory_holder& rhs) {
{ if (m_pMemory == rhs.m_pMemory)
void memory_holder::merge(memory_holder& rhs)
{
if(m_pMemory == rhs.m_pMemory)
return; return;
m_pMemory->merge(*rhs.m_pMemory); m_pMemory->merge(*rhs.m_pMemory);
rhs.m_pMemory = m_pMemory; rhs.m_pMemory = m_pMemory;
} }
node& memory::create_node() node& memory::create_node() {
{
shared_node pNode(new node); shared_node pNode(new node);
m_nodes.insert(pNode); m_nodes.insert(pNode);
return *pNode; return *pNode;
} }
void memory::merge(const memory& rhs) void memory::merge(const memory& rhs) {
{
m_nodes.insert(rhs.m_nodes.begin(), rhs.m_nodes.end()); m_nodes.insert(rhs.m_nodes.begin(), rhs.m_nodes.end());
} }
} }
} }
src/node.cpp
...@@ -2,13 +2,11 @@ ...@@ -2,13 +2,11 @@
#include "nodebuilder.h" #include "nodebuilder.h"
#include "nodeevents.h" #include "nodeevents.h"
namespace YAML namespace YAML {
{ Node Clone(const Node& node) {
Node Clone(const Node& node)
{
NodeEvents events(node); NodeEvents events(node);
NodeBuilder builder; NodeBuilder builder;
events.Emit(builder); events.Emit(builder);
return builder.Root(); return builder.Root();
} }
} }
src/node_data.cpp
...@@ -4,39 +4,33 @@ ...@@ -4,39 +4,33 @@
#include "yaml-cpp/exceptions.h" #include "yaml-cpp/exceptions.h"
#include <sstream> #include <sstream>
namespace YAML namespace YAML {
{ namespace detail {
namespace detail std::string node_data::empty_scalar;
{
std::string node_data::empty_scalar; node_data::node_data()
: m_isDefined(false), m_type(NodeType::Null), m_seqSize(0) {}
node_data::node_data(): m_isDefined(false), m_type(NodeType::Null), m_seqSize(0)
{
}
void node_data::mark_defined() void node_data::mark_defined() {
{ if (m_type == NodeType::Undefined)
if(m_type == NodeType::Undefined)
m_type = NodeType::Null; m_type = NodeType::Null;
m_isDefined = true; m_isDefined = true;
} }
void node_data::set_type(NodeType::value type) void node_data::set_type(NodeType::value type) {
{ if (type == NodeType::Undefined) {
if(type == NodeType::Undefined) {
m_type = type; m_type = type;
m_isDefined = false; m_isDefined = false;
return; return;
} }
m_isDefined = true; m_isDefined = true;
if(type == m_type) if (type == m_type)
return; return;
m_type = type; m_type = type;
switch(m_type) { switch (m_type) {
case NodeType::Null: case NodeType::Null:
break; break;
case NodeType::Scalar: case NodeType::Scalar:
...@@ -52,123 +46,125 @@ namespace YAML ...@@ -52,123 +46,125 @@ namespace YAML
assert(false); assert(false);
break; break;
} }
} }
void node_data::set_tag(const std::string& tag) void node_data::set_tag(const std::string& tag) { m_tag = tag; }
{
m_tag = tag;
}
void node_data::set_null() void node_data::set_null() {
{
m_isDefined = true; m_isDefined = true;
m_type = NodeType::Null; m_type = NodeType::Null;
} }
void node_data::set_scalar(const std::string& scalar) void node_data::set_scalar(const std::string& scalar) {
{
m_isDefined = true; m_isDefined = true;
m_type = NodeType::Scalar; m_type = NodeType::Scalar;
m_scalar = scalar; m_scalar = scalar;
} }
// size/iterator // size/iterator
std::size_t node_data::size() const std::size_t node_data::size() const {
{ if (!m_isDefined)
if(!m_isDefined)
return 0; return 0;
switch(m_type) { switch (m_type) {
case NodeType::Sequence: compute_seq_size(); return m_seqSize; case NodeType::Sequence:
case NodeType::Map: compute_map_size(); return m_map.size() - m_undefinedPairs.size(); compute_seq_size();
return m_seqSize;
case NodeType::Map:
compute_map_size();
return m_map.size() - m_undefinedPairs.size();
default: default:
return 0; return 0;
} }
return 0; return 0;
} }
void node_data::compute_seq_size() const void node_data::compute_seq_size() const {
{ while (m_seqSize < m_sequence.size() && m_sequence[m_seqSize]->is_defined())
while(m_seqSize < m_sequence.size() && m_sequence[m_seqSize]->is_defined())
m_seqSize++; m_seqSize++;
} }
void node_data::compute_map_size() const void node_data::compute_map_size() const {
{
kv_pairs::iterator it = m_undefinedPairs.begin(); kv_pairs::iterator it = m_undefinedPairs.begin();
while(it != m_undefinedPairs.end()) { while (it != m_undefinedPairs.end()) {
kv_pairs::iterator jt = boost::next(it); kv_pairs::iterator jt = boost::next(it);
if(it->first->is_defined() && it->second->is_defined()) if (it->first->is_defined() && it->second->is_defined())
m_undefinedPairs.erase(it); m_undefinedPairs.erase(it);
it = jt; it = jt;
} }
} }
const_node_iterator node_data::begin() const const_node_iterator node_data::begin() const {
{ if (!m_isDefined)
if(!m_isDefined)
return const_node_iterator(); return const_node_iterator();
switch(m_type) { switch (m_type) {
case NodeType::Sequence: return const_node_iterator(m_sequence.begin()); case NodeType::Sequence:
case NodeType::Map: return const_node_iterator(m_map.begin(), m_map.end()); return const_node_iterator(m_sequence.begin());
default: return const_node_iterator(); case NodeType::Map:
} return const_node_iterator(m_map.begin(), m_map.end());
default:
return const_node_iterator();
} }
}
node_iterator node_data::begin() node_iterator node_data::begin() {
{ if (!m_isDefined)
if(!m_isDefined)
return node_iterator(); return node_iterator();
switch(m_type) { switch (m_type) {
case NodeType::Sequence: return node_iterator(m_sequence.begin()); case NodeType::Sequence:
case NodeType::Map: return node_iterator(m_map.begin(), m_map.end()); return node_iterator(m_sequence.begin());
default: return node_iterator(); case NodeType::Map:
} return node_iterator(m_map.begin(), m_map.end());
default:
return node_iterator();
} }
}
const_node_iterator node_data::end() const const_node_iterator node_data::end() const {
{ if (!m_isDefined)
if(!m_isDefined)
return const_node_iterator(); return const_node_iterator();
switch(m_type) { switch (m_type) {
case NodeType::Sequence: return const_node_iterator(m_sequence.end()); case NodeType::Sequence:
case NodeType::Map: return const_node_iterator(m_map.end(), m_map.end()); return const_node_iterator(m_sequence.end());
default: return const_node_iterator(); case NodeType::Map:
} return const_node_iterator(m_map.end(), m_map.end());
default:
return const_node_iterator();
} }
}
node_iterator node_data::end() node_iterator node_data::end() {
{ if (!m_isDefined)
if(!m_isDefined)
return node_iterator(); return node_iterator();
switch(m_type) { switch (m_type) {
case NodeType::Sequence: return node_iterator(m_sequence.end()); case NodeType::Sequence:
case NodeType::Map: return node_iterator(m_map.end(), m_map.end()); return node_iterator(m_sequence.end());
default: return node_iterator(); case NodeType::Map:
} return node_iterator(m_map.end(), m_map.end());
default:
return node_iterator();
} }
}
// sequence // sequence
void node_data::push_back(node& node, shared_memory_holder /* pMemory */) void node_data::push_back(node& node, shared_memory_holder /* pMemory */) {
{ if (m_type == NodeType::Undefined || m_type == NodeType::Null) {
if(m_type == NodeType::Undefined || m_type == NodeType::Null) {
m_type = NodeType::Sequence; m_type = NodeType::Sequence;
reset_sequence(); reset_sequence();
} }
if(m_type != NodeType::Sequence) if (m_type != NodeType::Sequence)
throw BadPushback(); throw BadPushback();
m_sequence.push_back(&node); m_sequence.push_back(&node);
} }
void node_data::insert(node& key, node& value, shared_memory_holder pMemory) void node_data::insert(node& key, node& value, shared_memory_holder pMemory) {
{ switch (m_type) {
switch(m_type) {
case NodeType::Map: case NodeType::Map:
break; break;
case NodeType::Undefined: case NodeType::Undefined:
...@@ -181,25 +177,23 @@ namespace YAML ...@@ -181,25 +177,23 @@ namespace YAML
} }
insert_map_pair(key, value); insert_map_pair(key, value);
} }
// indexing // indexing
node& node_data::get(node& key, shared_memory_holder pMemory) const node& node_data::get(node& key, shared_memory_holder pMemory) const {
{ if (m_type != NodeType::Map)
if(m_type != NodeType::Map)
return pMemory->create_node(); return pMemory->create_node();
for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) { for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
if(it->first->is(key)) if (it->first->is(key))
return *it->second; return *it->second;
} }
return pMemory->create_node(); return pMemory->create_node();
} }
node& node_data::get(node& key, shared_memory_holder pMemory) node& node_data::get(node& key, shared_memory_holder pMemory) {
{ switch (m_type) {
switch(m_type) {
case NodeType::Map: case NodeType::Map:
break; break;
case NodeType::Undefined: case NodeType::Undefined:
...@@ -211,53 +205,48 @@ namespace YAML ...@@ -211,53 +205,48 @@ namespace YAML
throw BadSubscript(); throw BadSubscript();
} }
for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) { for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
if(it->first->is(key)) if (it->first->is(key))
return *it->second; return *it->second;
} }
node& value = pMemory->create_node(); node& value = pMemory->create_node();
insert_map_pair(key, value); insert_map_pair(key, value);
return value; return value;
} }
bool node_data::remove(node& key, shared_memory_holder /* pMemory */) bool node_data::remove(node& key, shared_memory_holder /* pMemory */) {
{ if (m_type != NodeType::Map)
if(m_type != NodeType::Map)
return false; return false;
for(node_map::iterator it=m_map.begin();it!=m_map.end();++it) { for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) {
if(it->first->is(key)) { if (it->first->is(key)) {
m_map.erase(it); m_map.erase(it);
return true; return true;
} }
} }
return false; return false;
} }
void node_data::reset_sequence() void node_data::reset_sequence() {
{
m_sequence.clear(); m_sequence.clear();
m_seqSize = 0; m_seqSize = 0;
} }
void node_data::reset_map() void node_data::reset_map() {
{
m_map.clear(); m_map.clear();
m_undefinedPairs.clear(); m_undefinedPairs.clear();
} }
void node_data::insert_map_pair(node& key, node& value) void node_data::insert_map_pair(node& key, node& value) {
{
m_map[&key] = &value; m_map[&key] = &value;
if(!key.is_defined() || !value.is_defined()) if (!key.is_defined() || !value.is_defined())
m_undefinedPairs.push_back(kv_pair(&key, &value)); m_undefinedPairs.push_back(kv_pair(&key, &value));
} }
void node_data::convert_to_map(shared_memory_holder pMemory) void node_data::convert_to_map(shared_memory_holder pMemory) {
{ switch (m_type) {
switch(m_type) {
case NodeType::Undefined: case NodeType::Undefined:
case NodeType::Null: case NodeType::Null:
reset_map(); reset_map();
...@@ -272,14 +261,13 @@ namespace YAML ...@@ -272,14 +261,13 @@ namespace YAML
assert(false); assert(false);
break; break;
} }
} }
void node_data::convert_sequence_to_map(shared_memory_holder pMemory) void node_data::convert_sequence_to_map(shared_memory_holder pMemory) {
{
assert(m_type == NodeType::Sequence); assert(m_type == NodeType::Sequence);
reset_map(); reset_map();
for(std::size_t i=0;i<m_sequence.size();i++) { for (std::size_t i = 0; i < m_sequence.size(); i++) {
std::stringstream stream; std::stringstream stream;
stream << i; stream << i;
...@@ -290,6 +278,6 @@ namespace YAML ...@@ -290,6 +278,6 @@ namespace YAML
reset_sequence(); reset_sequence();
m_type = NodeType::Map; m_type = NodeType::Map;
} }
} }
} }
src/nodebuilder.cpp
...@@ -4,103 +4,88 @@ ...@@ -4,103 +4,88 @@
#include "yaml-cpp/node/impl.h" #include "yaml-cpp/node/impl.h"
#include <cassert> #include <cassert>
namespace YAML namespace YAML {
{ NodeBuilder::NodeBuilder()
NodeBuilder::NodeBuilder(): m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0) : m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0) {
{
m_anchors.push_back(0); // since the anchors start at 1 m_anchors.push_back(0); // since the anchors start at 1
} }
NodeBuilder::~NodeBuilder() NodeBuilder::~NodeBuilder() {}
{
}
Node NodeBuilder::Root() Node NodeBuilder::Root() {
{ if (!m_pRoot)
if(!m_pRoot)
return Node(); return Node();
return Node(*m_pRoot, m_pMemory); return Node(*m_pRoot, m_pMemory);
} }
void NodeBuilder::OnDocumentStart(const Mark&) void NodeBuilder::OnDocumentStart(const Mark&) {}
{
}
void NodeBuilder::OnDocumentEnd() void NodeBuilder::OnDocumentEnd() {}
{
}
void NodeBuilder::OnNull(const Mark& /* mark */, anchor_t anchor) void NodeBuilder::OnNull(const Mark& /* mark */, anchor_t anchor) {
{
detail::node& node = Push(anchor); detail::node& node = Push(anchor);
node.set_null(); node.set_null();
Pop(); Pop();
} }
void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor) void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor) {
{
detail::node& node = *m_anchors[anchor]; detail::node& node = *m_anchors[anchor];
Push(node); Push(node);
Pop(); Pop();
} }
void NodeBuilder::OnScalar(const Mark& /* mark */, const std::string& tag, anchor_t anchor, const std::string& value) void NodeBuilder::OnScalar(const Mark& /* mark */, const std::string& tag,
{ anchor_t anchor, const std::string& value) {
detail::node& node = Push(anchor); detail::node& node = Push(anchor);
node.set_scalar(value); node.set_scalar(value);
node.set_tag(tag); node.set_tag(tag);
Pop(); Pop();
} }
void NodeBuilder::OnSequenceStart(const Mark& /* mark */, const std::string& tag, anchor_t anchor) void NodeBuilder::OnSequenceStart(const Mark& /* mark */,
{ const std::string& tag, anchor_t anchor) {
detail::node& node = Push(anchor); detail::node& node = Push(anchor);
node.set_tag(tag); node.set_tag(tag);
node.set_type(NodeType::Sequence); node.set_type(NodeType::Sequence);
} }
void NodeBuilder::OnSequenceEnd() void NodeBuilder::OnSequenceEnd() { Pop(); }
{
Pop();
}
void NodeBuilder::OnMapStart(const Mark& /* mark */, const std::string& tag, anchor_t anchor) void NodeBuilder::OnMapStart(const Mark& /* mark */, const std::string& tag,
{ anchor_t anchor) {
detail::node& node = Push(anchor); detail::node& node = Push(anchor);
node.set_type(NodeType::Map); node.set_type(NodeType::Map);
node.set_tag(tag); node.set_tag(tag);
m_mapDepth++; m_mapDepth++;
} }
void NodeBuilder::OnMapEnd() void NodeBuilder::OnMapEnd() {
{
assert(m_mapDepth > 0); assert(m_mapDepth > 0);
m_mapDepth--; m_mapDepth--;
Pop(); Pop();
} }
detail::node& NodeBuilder::Push(anchor_t anchor) detail::node& NodeBuilder::Push(anchor_t anchor) {
{
detail::node& node = m_pMemory->create_node(); detail::node& node = m_pMemory->create_node();
RegisterAnchor(anchor, node); RegisterAnchor(anchor, node);
Push(node); Push(node);
return node; return node;
} }
void NodeBuilder::Push(detail::node& node) void NodeBuilder::Push(detail::node& node) {
{ const bool needsKey =
const bool needsKey = (!m_stack.empty() && m_stack.back()->type() == NodeType::Map && m_keys.size() < m_mapDepth); (!m_stack.empty() && m_stack.back()->type() == NodeType::Map &&
m_keys.size() < m_mapDepth);
m_stack.push_back(&node); m_stack.push_back(&node);
if(needsKey) if (needsKey)
m_keys.push_back(PushedKey(&node, false)); m_keys.push_back(PushedKey(&node, false));
} }
void NodeBuilder::Pop() void NodeBuilder::Pop() {
{
assert(!m_stack.empty()); assert(!m_stack.empty());
if(m_stack.size() == 1) { if (m_stack.size() == 1) {
m_pRoot = m_stack[0]; m_pRoot = m_stack[0];
m_stack.pop_back(); m_stack.pop_back();
return; return;
...@@ -111,12 +96,12 @@ namespace YAML ...@@ -111,12 +96,12 @@ namespace YAML
detail::node& collection = *m_stack.back(); detail::node& collection = *m_stack.back();
if(collection.type() == NodeType::Sequence) { if (collection.type() == NodeType::Sequence) {
collection.push_back(node, m_pMemory); collection.push_back(node, m_pMemory);
} else if(collection.type() == NodeType::Map) { } else if (collection.type() == NodeType::Map) {
assert(!m_keys.empty()); assert(!m_keys.empty());
PushedKey& key = m_keys.back(); PushedKey& key = m_keys.back();
if(key.second) { if (key.second) {
collection.insert(*key.first, node, m_pMemory); collection.insert(*key.first, node, m_pMemory);
m_keys.pop_back(); m_keys.pop_back();
} else { } else {
...@@ -126,13 +111,12 @@ namespace YAML ...@@ -126,13 +111,12 @@ namespace YAML
assert(false); assert(false);
m_stack.clear(); m_stack.clear();
} }
} }
void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node) void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node) {
{ if (anchor) {
if(anchor) {
assert(anchor == m_anchors.size()); assert(anchor == m_anchors.size());
m_anchors.push_back(&node); m_anchors.push_back(&node);
} }
} }
} }
src/nodebuilder.h
#ifndef NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define NODE_NODEBUILDER_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
...@@ -9,12 +11,10 @@ ...@@ -9,12 +11,10 @@
#include "yaml-cpp/node/ptr.h" #include "yaml-cpp/node/ptr.h"
#include <vector> #include <vector>
namespace YAML namespace YAML {
{ class Node;
class Node;
class NodeBuilder: public EventHandler class NodeBuilder : public EventHandler {
{
public: public:
NodeBuilder(); NodeBuilder();
virtual ~NodeBuilder(); virtual ~NodeBuilder();
...@@ -26,12 +26,15 @@ namespace YAML ...@@ -26,12 +26,15 @@ namespace YAML
virtual void OnNull(const Mark& mark, anchor_t anchor); virtual void OnNull(const Mark& mark, anchor_t anchor);
virtual void OnAlias(const Mark& mark, anchor_t anchor); virtual void OnAlias(const Mark& mark, anchor_t anchor);
virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value); virtual void OnScalar(const Mark& mark, const std::string& tag,
anchor_t anchor, const std::string& value);
virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor); virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
anchor_t anchor);
virtual void OnSequenceEnd(); virtual void OnSequenceEnd();
virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor); virtual void OnMapStart(const Mark& mark, const std::string& tag,
anchor_t anchor);
virtual void OnMapEnd(); virtual void OnMapEnd();
private: private:
...@@ -42,17 +45,16 @@ namespace YAML ...@@ -42,17 +45,16 @@ namespace YAML
private: private:
detail::shared_memory_holder m_pMemory; detail::shared_memory_holder m_pMemory;
detail::node *m_pRoot; detail::node* m_pRoot;
typedef std::vector<detail::node *> Nodes; typedef std::vector<detail::node*> Nodes;
Nodes m_stack; Nodes m_stack;
Nodes m_anchors; Nodes m_anchors;
typedef std::pair<detail::node *, bool> PushedKey; typedef std::pair<detail::node*, bool> PushedKey;
std::vector<PushedKey> m_keys; std::vector<PushedKey> m_keys;
std::size_t m_mapDepth; std::size_t m_mapDepth;
}; };
} }
#endif // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
src/nodeevents.cpp
...@@ -4,61 +4,58 @@ ...@@ -4,61 +4,58 @@
#include "yaml-cpp/eventhandler.h" #include "yaml-cpp/eventhandler.h"
#include "yaml-cpp/mark.h" #include "yaml-cpp/mark.h"
namespace YAML namespace YAML {
{ void NodeEvents::AliasManager::RegisterReference(const detail::node& node) {
void NodeEvents::AliasManager::RegisterReference(const detail::node& node)
{
m_anchorByIdentity.insert(std::make_pair(node.ref(), _CreateNewAnchor())); m_anchorByIdentity.insert(std::make_pair(node.ref(), _CreateNewAnchor()));
} }
anchor_t NodeEvents::AliasManager::LookupAnchor(const detail::node& node) const anchor_t NodeEvents::AliasManager::LookupAnchor(const detail::node& node)
{ const {
AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(node.ref()); AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(node.ref());
if(it == m_anchorByIdentity.end()) if (it == m_anchorByIdentity.end())
return 0; return 0;
return it->second; return it->second;
} }
NodeEvents::NodeEvents(const Node& node): m_pMemory(node.m_pMemory), m_root(node.m_pNode) NodeEvents::NodeEvents(const Node& node)
{ : m_pMemory(node.m_pMemory), m_root(node.m_pNode) {
if(m_root) if (m_root)
Setup(*m_root); Setup(*m_root);
} }
void NodeEvents::Setup(const detail::node& node) void NodeEvents::Setup(const detail::node& node) {
{
int& refCount = m_refCount[node.ref()]; int& refCount = m_refCount[node.ref()];
refCount++; refCount++;
if(refCount > 1) if (refCount > 1)
return; return;
if(node.type() == NodeType::Sequence) { if (node.type() == NodeType::Sequence) {
for(detail::const_node_iterator it=node.begin();it!=node.end();++it) for (detail::const_node_iterator it = node.begin(); it != node.end(); ++it)
Setup(**it); Setup(**it);
} else if(node.type() == NodeType::Map) { } else if (node.type() == NodeType::Map) {
for(detail::const_node_iterator it=node.begin();it!=node.end();++it) { for (detail::const_node_iterator it = node.begin(); it != node.end();
++it) {
Setup(*it->first); Setup(*it->first);
Setup(*it->second); Setup(*it->second);
} }
} }
} }
void NodeEvents::Emit(EventHandler& handler) void NodeEvents::Emit(EventHandler& handler) {
{
AliasManager am; AliasManager am;
handler.OnDocumentStart(Mark()); handler.OnDocumentStart(Mark());
if(m_root) if (m_root)
Emit(*m_root, handler, am); Emit(*m_root, handler, am);
handler.OnDocumentEnd(); handler.OnDocumentEnd();
} }
void NodeEvents::Emit(const detail::node& node, EventHandler& handler, AliasManager& am) const void NodeEvents::Emit(const detail::node& node, EventHandler& handler,
{ AliasManager& am) const {
anchor_t anchor = NullAnchor; anchor_t anchor = NullAnchor;
if(IsAliased(node)) { if (IsAliased(node)) {
anchor = am.LookupAnchor(node); anchor = am.LookupAnchor(node);
if(anchor) { if (anchor) {
handler.OnAlias(Mark(), anchor); handler.OnAlias(Mark(), anchor);
return; return;
} }
...@@ -67,7 +64,7 @@ namespace YAML ...@@ -67,7 +64,7 @@ namespace YAML
anchor = am.LookupAnchor(node); anchor = am.LookupAnchor(node);
} }
switch(node.type()) { switch (node.type()) {
case NodeType::Undefined: case NodeType::Undefined:
break; break;
case NodeType::Null: case NodeType::Null:
...@@ -78,24 +75,25 @@ namespace YAML ...@@ -78,24 +75,25 @@ namespace YAML
break; break;
case NodeType::Sequence: case NodeType::Sequence:
handler.OnSequenceStart(Mark(), node.tag(), anchor); handler.OnSequenceStart(Mark(), node.tag(), anchor);
for(detail::const_node_iterator it=node.begin();it!=node.end();++it) for (detail::const_node_iterator it = node.begin(); it != node.end();
++it)
Emit(**it, handler, am); Emit(**it, handler, am);
handler.OnSequenceEnd(); handler.OnSequenceEnd();
break; break;
case NodeType::Map: case NodeType::Map:
handler.OnMapStart(Mark(), node.tag(), anchor); handler.OnMapStart(Mark(), node.tag(), anchor);
for(detail::const_node_iterator it=node.begin();it!=node.end();++it) { for (detail::const_node_iterator it = node.begin(); it != node.end();
++it) {
Emit(*it->first, handler, am); Emit(*it->first, handler, am);
Emit(*it->second, handler, am); Emit(*it->second, handler, am);
} }
handler.OnMapEnd(); handler.OnMapEnd();
break; break;
} }
} }
bool NodeEvents::IsAliased(const detail::node& node) const bool NodeEvents::IsAliased(const detail::node& node) const {
{
RefCount::const_iterator it = m_refCount.find(node.ref()); RefCount::const_iterator it = m_refCount.find(node.ref());
return it != m_refCount.end() && it->second > 1; return it != m_refCount.end() && it->second > 1;
} }
} }
src/nodeevents.h
#ifndef NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define NODE_NODEEVENTS_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
...@@ -10,13 +12,11 @@ ...@@ -10,13 +12,11 @@
#include <map> #include <map>
#include <vector> #include <vector>
namespace YAML namespace YAML {
{ class EventHandler;
class EventHandler; class Node;
class Node;
class NodeEvents class NodeEvents {
{
public: public:
explicit NodeEvents(const Node& node); explicit NodeEvents(const Node& node);
...@@ -25,7 +25,7 @@ namespace YAML ...@@ -25,7 +25,7 @@ namespace YAML
private: private:
class AliasManager { class AliasManager {
public: public:
AliasManager(): m_curAnchor(0) {} AliasManager() : m_curAnchor(0) {}
void RegisterReference(const detail::node& node); void RegisterReference(const detail::node& node);
anchor_t LookupAnchor(const detail::node& node) const; anchor_t LookupAnchor(const detail::node& node) const;
...@@ -41,17 +41,17 @@ namespace YAML ...@@ -41,17 +41,17 @@ namespace YAML
}; };
void Setup(const detail::node& node); void Setup(const detail::node& node);
void Emit(const detail::node& node, EventHandler& handler, AliasManager& am) const; void Emit(const detail::node& node, EventHandler& handler,
AliasManager& am) const;
bool IsAliased(const detail::node& node) const; bool IsAliased(const detail::node& node) const;
private: private:
detail::shared_memory_holder m_pMemory; detail::shared_memory_holder m_pMemory;
detail::node* m_root; detail::node* m_root;
typedef std::map<const detail::node_ref *, int> RefCount; typedef std::map<const detail::node_ref*, int> RefCount;
RefCount m_refCount; RefCount m_refCount;
}; };
} }
#endif // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
src/ostream_wrapper.cpp
...@@ -2,55 +2,52 @@ ...@@ -2,55 +2,52 @@
#include <cstring> #include <cstring>
#include <iostream> #include <iostream>
namespace YAML namespace YAML {
{ ostream_wrapper::ostream_wrapper()
ostream_wrapper::ostream_wrapper(): m_buffer(1), m_pStream(0), m_pos(0), m_row(0), m_col(0), m_comment(false) : m_buffer(1),
{ m_pStream(0),
} m_pos(0),
m_row(0),
ostream_wrapper::ostream_wrapper(std::ostream& stream): m_pStream(&stream), m_pos(0), m_row(0), m_col(0), m_comment(false) m_col(0),
{ m_comment(false) {}
}
ostream_wrapper::ostream_wrapper(std::ostream& stream)
ostream_wrapper::~ostream_wrapper() : m_pStream(&stream), m_pos(0), m_row(0), m_col(0), m_comment(false) {}
{
} ostream_wrapper::~ostream_wrapper() {}
void ostream_wrapper::write(const std::string& str) void ostream_wrapper::write(const std::string& str) {
{ if (m_pStream) {
if(m_pStream) {
m_pStream->write(str.c_str(), str.size()); m_pStream->write(str.c_str(), str.size());
} else { } else {
m_buffer.resize(std::max(m_buffer.size(), m_pos + str.size() + 1)); m_buffer.resize(std::max(m_buffer.size(), m_pos + str.size() + 1));
std::copy(str.begin(), str.end(), &m_buffer[m_pos]); std::copy(str.begin(), str.end(), &m_buffer[m_pos]);
} }
for(std::size_t i=0;i<str.size();i++) for (std::size_t i = 0; i < str.size(); i++)
update_pos(str[i]); update_pos(str[i]);
} }
void ostream_wrapper::write(const char *str, std::size_t size) void ostream_wrapper::write(const char* str, std::size_t size) {
{ if (m_pStream) {
if(m_pStream) {
m_pStream->write(str, size); m_pStream->write(str, size);
} else { } else {
m_buffer.resize(std::max(m_buffer.size(), m_pos + size + 1)); m_buffer.resize(std::max(m_buffer.size(), m_pos + size + 1));
std::copy(str, str + size, &m_buffer[m_pos]); std::copy(str, str + size, &m_buffer[m_pos]);
} }
for(std::size_t i=0;i<size;i++) for (std::size_t i = 0; i < size; i++)
update_pos(str[i]); update_pos(str[i]);
} }
void ostream_wrapper::update_pos(char ch) void ostream_wrapper::update_pos(char ch) {
{
m_pos++; m_pos++;
m_col++; m_col++;
if(ch == '\n') { if (ch == '\n') {
m_row++; m_row++;
m_col = 0; m_col = 0;
m_comment = false; m_comment = false;
} }
} }
} }
src/parse.cpp
...@@ -7,62 +7,61 @@ ...@@ -7,62 +7,61 @@
#include <fstream> #include <fstream>
#include <sstream> #include <sstream>
namespace YAML namespace YAML {
{ Node Load(const std::string& input) {
Node Load(const std::string& input) {
std::stringstream stream(input); std::stringstream stream(input);
return Load(stream); return Load(stream);
} }
Node Load(const char *input) { Node Load(const char* input) {
std::stringstream stream(input); std::stringstream stream(input);
return Load(stream); return Load(stream);
} }
Node Load(std::istream& input) { Node Load(std::istream& input) {
Parser parser(input); Parser parser(input);
NodeBuilder builder; NodeBuilder builder;
if(!parser.HandleNextDocument(builder)) if (!parser.HandleNextDocument(builder))
return Node(); return Node();
return builder.Root(); return builder.Root();
} }
Node LoadFile(const std::string& filename) { Node LoadFile(const std::string& filename) {
std::ifstream fin(filename.c_str()); std::ifstream fin(filename.c_str());
if(!fin) if (!fin)
throw BadFile(); throw BadFile();
return Load(fin); return Load(fin);
} }
std::vector<Node> LoadAll(const std::string& input) { std::vector<Node> LoadAll(const std::string& input) {
std::stringstream stream(input); std::stringstream stream(input);
return LoadAll(stream); return LoadAll(stream);
} }
std::vector<Node> LoadAll(const char *input) { std::vector<Node> LoadAll(const char* input) {
std::stringstream stream(input); std::stringstream stream(input);
return LoadAll(stream); return LoadAll(stream);
} }
std::vector<Node> LoadAll(std::istream& input) { std::vector<Node> LoadAll(std::istream& input) {
std::vector<Node> docs; std::vector<Node> docs;
Parser parser(input); Parser parser(input);
while(1) { while (1) {
NodeBuilder builder; NodeBuilder builder;
if(!parser.HandleNextDocument(builder)) if (!parser.HandleNextDocument(builder))
break; break;
docs.push_back(builder.Root()); docs.push_back(builder.Root());
} }
return docs; return docs;
} }
std::vector<Node> LoadAllFromFile(const std::string& filename) { std::vector<Node> LoadAllFromFile(const std::string& filename) {
std::ifstream fin(filename.c_str()); std::ifstream fin(filename.c_str());
if(!fin) if (!fin)
throw BadFile(); throw BadFile();
return LoadAll(fin); return LoadAll(fin);
} }
} }
test/new-api/parsertests.cpp
#include "parsertests.h" #include "parsertests.h"
namespace Test { namespace Test {
bool RunParserTests() bool RunParserTests() { return true; }
{
return true;
}
} }
test/nodetests.h
#ifndef NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define NODETESTS_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 #if defined(_MSC_VER) || \
(defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once #pragma once
#endif #endif
namespace Test { namespace Test {
bool RunNodeTests(); bool RunNodeTests();
} }
#endif // NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A6666 #endif // NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A6666
test/tests.cpp
...@@ -9,25 +9,22 @@ ...@@ -9,25 +9,22 @@
#include <vector> #include <vector>
#include <iostream> #include <iostream>
namespace Test namespace Test {
{ void RunAll() {
void RunAll()
{
bool passed = true; bool passed = true;
if(!RunParserTests()) if (!RunParserTests())
passed = false; passed = false;
if(!RunEmitterTests()) if (!RunEmitterTests())
passed = false; passed = false;
if(!RunSpecTests()) if (!RunSpecTests())
passed = false; passed = false;
if(!RunNodeTests()) if (!RunNodeTests())
passed = false; passed = false;
if(passed) if (passed)
std::cout << "All tests passed!\n"; std::cout << "All tests passed!\n";
}
} }
}
util/parse.cpp
...@@ -9,7 +9,7 @@ struct Params { ...@@ -9,7 +9,7 @@ struct Params {
std::string fileName; std::string fileName;
}; };
Params ParseArgs(int argc, char **argv) { Params ParseArgs(int argc, char** argv) {
Params p; Params p;
std::vector<std::string> args(argv + 1, argv + argc); std::vector<std::string> args(argv + 1, argv + argc);
...@@ -17,38 +17,39 @@ Params ParseArgs(int argc, char **argv) { ...@@ -17,38 +17,39 @@ Params ParseArgs(int argc, char **argv) {
return p; return p;
} }
class NullEventHandler: public YAML::EventHandler class NullEventHandler : public YAML::EventHandler {
{ public:
public:
virtual void OnDocumentStart(const YAML::Mark&) {} virtual void OnDocumentStart(const YAML::Mark&) {}
virtual void OnDocumentEnd() {} virtual void OnDocumentEnd() {}
virtual void OnNull(const YAML::Mark&, YAML::anchor_t) {} virtual void OnNull(const YAML::Mark&, YAML::anchor_t) {}
virtual void OnAlias(const YAML::Mark&, YAML::anchor_t) {} virtual void OnAlias(const YAML::Mark&, YAML::anchor_t) {}
virtual void OnScalar(const YAML::Mark&, const std::string&, YAML::anchor_t, const std::string&) {} virtual void OnScalar(const YAML::Mark&, const std::string&, YAML::anchor_t,
const std::string&) {}
virtual void OnSequenceStart(const YAML::Mark&, const std::string&, YAML::anchor_t) {} virtual void OnSequenceStart(const YAML::Mark&, const std::string&,
YAML::anchor_t) {}
virtual void OnSequenceEnd() {} virtual void OnSequenceEnd() {}
virtual void OnMapStart(const YAML::Mark&, const std::string&, YAML::anchor_t) {} virtual void OnMapStart(const YAML::Mark&, const std::string&,
YAML::anchor_t) {}
virtual void OnMapEnd() {} virtual void OnMapEnd() {}
}; };
void parse(std::istream& input) void parse(std::istream& input) {
{
try { try {
YAML::Node doc = YAML::Load(input); YAML::Node doc = YAML::Load(input);
std::cout << doc << "\n"; std::cout << doc << "\n";
} catch(const YAML::Exception& e) { }
catch (const YAML::Exception& e) {
std::cerr << e.what() << "\n"; std::cerr << e.what() << "\n";
} }
} }
int main(int argc, char **argv) int main(int argc, char** argv) {
{
Params p = ParseArgs(argc, argv); Params p = ParseArgs(argc, argv);
if(argc > 1) { if (argc > 1) {
std::ifstream fin; std::ifstream fin;
fin.open(argv[1]); fin.open(argv[1]);
parse(fin); parse(fin);
......
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