peisongxiao/yaml-cpp
1
0
Fork 0
mirror of https://github.com/jbeder/yaml-cpp.git synced 2025-09-09 12:41:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Major switch from Value -> Node. The library compiles with the new API, but tests are still oldies, and don't compile

Browse Source
This commit is contained in:
Jesse Beder
2011-09-10 17:57:23 -05:00
parent ac81d7c883
commit 0d1b5224c8
30 changed files with 387 additions and 364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/node/convert.cpp
View File

@@ -1,4 +1,4 @@
#include "yaml-cpp/value/convert.h"
#include "yaml-cpp/node/convert.h"
namespace YAML
{

4
src/node/detail/memory.cpp
View File

@@ -1,5 +1,5 @@
#include "yaml-cpp/value/detail/memory.h"
#include "yaml-cpp/value/detail/node.h"
#include "yaml-cpp/node/detail/memory.h"
#include "yaml-cpp/node/detail/node.h"
namespace YAML
{

66
src/node/detail/node_data.cpp
View File

@@ -1,6 +1,6 @@
#include "yaml-cpp/value/detail/node_data.h"
#include "yaml-cpp/value/detail/memory.h"
#include "yaml-cpp/value/detail/node.h"
#include "yaml-cpp/node/detail/node_data.h"
#include "yaml-cpp/node/detail/memory.h"
#include "yaml-cpp/node/detail/node.h"
#include <sstream>
#include <stdexcept>
@@ -10,13 +10,13 @@ namespace YAML
{
std::string node_data::empty_scalar;
node_data::node_data(): m_isDefined(false), m_type(ValueType::Null)
node_data::node_data(): m_isDefined(false), m_type(NodeType::Null)
{
}
void node_data::set_type(ValueType::value type)
void node_data::set_type(NodeType::value type)
{
if(type == ValueType::Undefined) {
if(type == NodeType::Undefined) {
m_type = type;
m_isDefined = false;
return;
@@ -30,18 +30,18 @@ namespace YAML
m_type = type;
switch(m_type) {
case ValueType::Null:
case NodeType::Null:
break;
case ValueType::Scalar:
case NodeType::Scalar:
m_scalar.clear();
break;
case ValueType::Sequence:
case NodeType::Sequence:
m_sequence.clear();
break;
case ValueType::Map:
case NodeType::Map:
m_map.clear();
break;
case ValueType::Undefined:
case NodeType::Undefined:
assert(false);
break;
}
@@ -50,13 +50,13 @@ namespace YAML
void node_data::set_null()
{
m_isDefined = true;
m_type = ValueType::Null;
m_type = NodeType::Null;
}
void node_data::set_scalar(const std::string& scalar)
{
m_isDefined = true;
m_type = ValueType::Scalar;
m_type = NodeType::Scalar;
m_scalar = scalar;
}
@@ -69,8 +69,8 @@ namespace YAML
const_node_iterator node_data::begin() const
{
switch(m_type) {
case ValueType::Sequence: return const_node_iterator(m_sequence.begin());
case ValueType::Map: return const_node_iterator(m_map.begin());
case NodeType::Sequence: return const_node_iterator(m_sequence.begin());
case NodeType::Map: return const_node_iterator(m_map.begin());
default: return const_node_iterator();
}
}
@@ -78,8 +78,8 @@ namespace YAML
node_iterator node_data::begin()
{
switch(m_type) {
case ValueType::Sequence: return node_iterator(m_sequence.begin());
case ValueType::Map: return node_iterator(m_map.begin());
case NodeType::Sequence: return node_iterator(m_sequence.begin());
case NodeType::Map: return node_iterator(m_map.begin());
default: return node_iterator();
}
}
@@ -87,8 +87,8 @@ namespace YAML
const_node_iterator node_data::end() const
{
switch(m_type) {
case ValueType::Sequence: return const_node_iterator(m_sequence.end());
case ValueType::Map: return const_node_iterator(m_map.end());
case NodeType::Sequence: return const_node_iterator(m_sequence.end());
case NodeType::Map: return const_node_iterator(m_map.end());
default: return const_node_iterator();
}
}
@@ -96,8 +96,8 @@ namespace YAML
node_iterator node_data::end()
{
switch(m_type) {
case ValueType::Sequence: return node_iterator(m_sequence.end());
case ValueType::Map: return node_iterator(m_map.end());
case NodeType::Sequence: return node_iterator(m_sequence.end());
case NodeType::Map: return node_iterator(m_map.end());
default: return node_iterator();
}
}
@@ -105,7 +105,7 @@ namespace YAML
// sequence
void node_data::append(node& node, shared_memory_holder /* pMemory */)
{
if(m_type != ValueType::Sequence)
if(m_type != NodeType::Sequence)
throw std::runtime_error("Can't append to a non-sequence node");
m_sequence.push_back(&node);
@@ -113,7 +113,7 @@ namespace YAML
void node_data::insert(node& key, node& value, shared_memory_holder /* pMemory */)
{
if(m_type != ValueType::Map)
if(m_type != NodeType::Map)
throw std::runtime_error("Can't insert into a non-map node");
m_map.push_back(kv_pair(&key, &value));
@@ -122,7 +122,7 @@ namespace YAML
// indexing
node& node_data::get(node& key, shared_memory_holder pMemory) const
{
if(m_type != ValueType::Map)
if(m_type != NodeType::Map)
return pMemory->create_node();
for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
@@ -136,16 +136,16 @@ namespace YAML
node& node_data::get(node& key, shared_memory_holder pMemory)
{
switch(m_type) {
case ValueType::Undefined:
case ValueType::Null:
case ValueType::Scalar:
m_type = ValueType::Map;
case NodeType::Undefined:
case NodeType::Null:
case NodeType::Scalar:
m_type = NodeType::Map;
m_map.clear();
break;
case ValueType::Sequence:
case NodeType::Sequence:
convert_sequence_to_map(pMemory);
break;
case ValueType::Map:
case NodeType::Map:
break;
}
@@ -161,7 +161,7 @@ namespace YAML
bool node_data::remove(node& key, shared_memory_holder /* pMemory */)
{
if(m_type != ValueType::Map)
if(m_type != NodeType::Map)
return false;
for(node_map::iterator it=m_map.begin();it!=m_map.end();++it) {
@@ -176,7 +176,7 @@ namespace YAML
void node_data::convert_sequence_to_map(shared_memory_holder pMemory)
{
assert(m_type == ValueType::Sequence);
assert(m_type == NodeType::Sequence);
m_map.clear();
for(std::size_t i=0;i<m_sequence.size();i++) {
@@ -189,7 +189,7 @@ namespace YAML
}
m_sequence.clear();
m_type = ValueType::Map;
m_type = NodeType::Map;
}
}
}

12
src/node/emit.cpp
View File

@@ -1,22 +1,22 @@
#include "yaml-cpp/value/emit.h"
#include "yaml-cpp/node/emit.h"
#include "yaml-cpp/emitfromevents.h"
#include "yaml-cpp/emitter.h"
#include "valueevents.h"
#include "nodeevents.h"
namespace YAML
{
Emitter& operator << (Emitter& out, const Value& value)
Emitter& operator << (Emitter& out, const Node& node)
{
EmitFromEvents emitFromEvents(out);
ValueEvents events(value);
NodeEvents events(node);
events.Emit(emitFromEvents);
return out;
}
std::ostream& operator << (std::ostream& out, const Value& value)
std::ostream& operator << (std::ostream& out, const Node& node)
{
Emitter emitter;
emitter << value;
emitter << node;
out << emitter.c_str();
return out;
}

49
src/node/valuebuilder.cpp → src/node/nodebuilder.cpp
View File

@@ -1,84 +1,85 @@
#include "valuebuilder.h"
#include "nodebuilder.h"
#include "yaml-cpp/mark.h"
#include "yaml-cpp/value.h"
#include "yaml-cpp/node/node.h"
#include "yaml-cpp/node/impl.h"
#include <cassert>
namespace YAML
{
ValueBuilder::ValueBuilder(): m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0)
NodeBuilder::NodeBuilder(): m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0)
{
m_anchors.push_back(0); // since the anchors start at 1
}
ValueBuilder::~ValueBuilder()
NodeBuilder::~NodeBuilder()
{
}
Value ValueBuilder::Root()
Node NodeBuilder::Root()
{
if(!m_pRoot)
return Value();
return Node();
return Value(*m_pRoot, m_pMemory);
return Node(*m_pRoot, m_pMemory);
}
void ValueBuilder::OnDocumentStart(const Mark&)
void NodeBuilder::OnDocumentStart(const Mark&)
{
}
void ValueBuilder::OnDocumentEnd()
void NodeBuilder::OnDocumentEnd()
{
}
void ValueBuilder::OnNull(const Mark& mark, anchor_t anchor)
void NodeBuilder::OnNull(const Mark& mark, anchor_t anchor)
{
detail::node& node = Push(anchor);
node.set_null();
Pop();
}
void ValueBuilder::OnAlias(const Mark& /*mark*/, anchor_t anchor)
void NodeBuilder::OnAlias(const Mark& /*mark*/, anchor_t anchor)
{
detail::node& node = *m_anchors[anchor];
m_stack.push_back(&node);
Pop();
}
void ValueBuilder::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);
node.set_scalar(value);
Pop();
}
void ValueBuilder::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);
node.set_type(ValueType::Sequence);
node.set_type(NodeType::Sequence);
}
void ValueBuilder::OnSequenceEnd()
void NodeBuilder::OnSequenceEnd()
{
Pop();
}
void ValueBuilder::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);
node.set_type(ValueType::Map);
node.set_type(NodeType::Map);
m_mapDepth++;
}
void ValueBuilder::OnMapEnd()
void NodeBuilder::OnMapEnd()
{
assert(m_mapDepth > 0);
m_mapDepth--;
Pop();
}
detail::node& ValueBuilder::Push(anchor_t anchor)
detail::node& NodeBuilder::Push(anchor_t anchor)
{
const bool needsKey = (!m_stack.empty() && m_stack.back()->type() == ValueType::Map && m_keys.size() < m_mapDepth);
const bool needsKey = (!m_stack.empty() && m_stack.back()->type() == NodeType::Map && m_keys.size() < m_mapDepth);
detail::node& node = m_pMemory->create_node();
m_stack.push_back(&node);
@@ -90,7 +91,7 @@ namespace YAML
return node;
}
void ValueBuilder::Pop()
void NodeBuilder::Pop()
{
assert(!m_stack.empty());
if(m_stack.size() == 1) {
@@ -104,9 +105,9 @@ namespace YAML
detail::node& collection = *m_stack.back();
if(collection.type() == ValueType::Sequence) {
if(collection.type() == NodeType::Sequence) {
collection.append(node, m_pMemory);
} else if(collection.type() == ValueType::Map) {
} else if(collection.type() == NodeType::Map) {
detail::node& key = *m_keys.back();
if(&key != &node) {
m_keys.pop_back();
@@ -118,7 +119,7 @@ namespace YAML
}
}
void ValueBuilder::RegisterAnchor(anchor_t anchor, detail::node& node)
void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node)
{
if(anchor) {
assert(anchor == m_anchors.size());

18
src/node/valuebuilder.h → src/node/nodebuilder.h
View File

@@ -1,25 +1,25 @@
#ifndef VALUE_VALUEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define VALUE_VALUEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#ifndef 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
#pragma once
#endif
#include "yaml-cpp/eventhandler.h"
#include "yaml-cpp/value/ptr.h"
#include "yaml-cpp/node/ptr.h"
#include <vector>
namespace YAML
{
class Value;
class Node;
class ValueBuilder: public EventHandler
class NodeBuilder: public EventHandler
{
public:
ValueBuilder();
virtual ~ValueBuilder();
NodeBuilder();
virtual ~NodeBuilder();
Value Root();
Node Root();
virtual void OnDocumentStart(const Mark& mark);
virtual void OnDocumentEnd();
@@ -52,5 +52,5 @@ namespace YAML
};
}
#endif // VALUE_VALUEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#endif // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

33
src/node/valueevents.cpp → src/node/nodeevents.cpp
View File

@@ -1,16 +1,17 @@
#include "valueevents.h"
#include "yaml-cpp/value.h"
#include "nodeevents.h"
#include "yaml-cpp/node/node.h"
#include "yaml-cpp/node/impl.h"
#include "yaml-cpp/eventhandler.h"
#include "yaml-cpp/mark.h"
namespace YAML
{
void ValueEvents::AliasManager::RegisterReference(const detail::node& node)
void NodeEvents::AliasManager::RegisterReference(const detail::node& node)
{
m_anchorByIdentity.insert(std::make_pair(node.ref(), _CreateNewAnchor()));
}
anchor_t ValueEvents::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());
if(it == m_anchorByIdentity.end())
@@ -18,22 +19,22 @@ namespace YAML
return it->second;
}
ValueEvents::ValueEvents(const Value& value): m_pMemory(value.m_pMemory), m_root(*value.m_pNode)
NodeEvents::NodeEvents(const Node& node): m_pMemory(node.m_pMemory), m_root(*node.m_pNode)
{
Setup(m_root);
}
void ValueEvents::Setup(const detail::node& node)
void NodeEvents::Setup(const detail::node& node)
{
int& refCount = m_refCount[node.ref()];
refCount++;
if(refCount > 1)
return;
if(node.type() == ValueType::Sequence) {
if(node.type() == NodeType::Sequence) {
for(detail::const_node_iterator it=node.begin();it!=node.end();++it)
Setup(**it);
} else if(node.type() == ValueType::Map) {
} else if(node.type() == NodeType::Map) {
for(detail::const_node_iterator it=node.begin();it!=node.end();++it) {
Setup(*it->first);
Setup(*it->second);
@@ -41,7 +42,7 @@ namespace YAML
}
}
void ValueEvents::Emit(EventHandler& handler)
void NodeEvents::Emit(EventHandler& handler)
{
AliasManager am;
@@ -50,7 +51,7 @@ namespace YAML
handler.OnDocumentEnd();
}
void ValueEvents::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;
if(IsAliased(node)) {
@@ -65,21 +66,21 @@ namespace YAML
}
switch(node.type()) {
case ValueType::Undefined:
case NodeType::Undefined:
break;
case ValueType::Null:
case NodeType::Null:
handler.OnNull(Mark(), anchor);
break;
case ValueType::Scalar:
case NodeType::Scalar:
handler.OnScalar(Mark(), "", anchor, node.scalar());
break;
case ValueType::Sequence:
case NodeType::Sequence:
handler.OnSequenceStart(Mark(), "", anchor);
for(detail::const_node_iterator it=node.begin();it!=node.end();++it)
Emit(**it, handler, am);
handler.OnSequenceEnd();
break;
case ValueType::Map:
case NodeType::Map:
handler.OnMapStart(Mark(), "", anchor);
for(detail::const_node_iterator it=node.begin();it!=node.end();++it) {
Emit(*it->first, handler, am);
@@ -90,7 +91,7 @@ namespace YAML
}
}
bool ValueEvents::IsAliased(const detail::node& node) const
bool NodeEvents::IsAliased(const detail::node& node) const
{
RefCount::const_iterator it = m_refCount.find(node.ref());
return it != m_refCount.end() && it->second > 1;

14
src/node/valueevents.h → src/node/nodeevents.h
View File

@@ -1,24 +1,24 @@
#ifndef VALUE_VALUEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define VALUE_VALUEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#ifndef 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
#pragma once
#endif
#include "yaml-cpp/anchor.h"
#include "yaml-cpp/value/ptr.h"
#include "yaml-cpp/node/ptr.h"
#include <map>
#include <vector>
namespace YAML
{
class Value;
class EventHandler;
class Node;
class ValueEvents
class NodeEvents
{
public:
explicit ValueEvents(const Value& value);
explicit NodeEvents(const Node& node);
void Emit(EventHandler& handler);
@@ -53,5 +53,5 @@ namespace YAML
};
}
#endif // VALUE_VALUEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#endif // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

18
src/node/parse.cpp
View File

@@ -1,28 +1,28 @@
#include "yaml-cpp/value/parse.h"
#include "yaml-cpp/value/value.h"
#include "yaml-cpp/value/impl.h"
#include "yaml-cpp/node/parse.h"
#include "yaml-cpp/node/node.h"
#include "yaml-cpp/node/impl.h"
#include "yaml-cpp/parser.h"
#include "valuebuilder.h"
#include "nodebuilder.h"
#include <sstream>
namespace YAML
{
Value Parse(const std::string& input) {
Node Parse(const std::string& input) {
std::stringstream stream(input);
return Parse(stream);
}
Value Parse(const char *input) {
Node Parse(const char *input) {
std::stringstream stream(input);
return Parse(stream);
}
Value Parse(std::istream& input) {
Node Parse(std::istream& input) {
Parser parser(input);
ValueBuilder builder;
NodeBuilder builder;
if(!parser.HandleNextDocument(builder))
return Value();
return Node();
return builder.Root();
}

7
src/parser.cpp
View File

@@ -3,7 +3,6 @@
#include "yaml-cpp/eventhandler.h"
#include "yaml-cpp/exceptions.h"
#include "yaml-cpp/node.h"
#include "nodebuilder.h"
#include "scanner.h"
#include "singledocparser.h"
#include "tag.h"
@@ -11,6 +10,10 @@
#include <sstream>
#include <cstdio>
#if YAML_CPP_OLD_API
#include "old-api/nodebuilder.h"
#endif
namespace YAML
{
Parser::Parser()
@@ -55,6 +58,7 @@ namespace YAML
return true;
}
#if YAML_CPP_OLD_API
// GetNextDocument
// . Reads the next document in the queue (of tokens).
// . Throws a ParserException on error.
@@ -63,6 +67,7 @@ namespace YAML
NodeBuilder builder(document);
return HandleNextDocument(builder);
}
#endif
// ParseDirectives
// . Reads any directives that are next in the queue.