Skip to content

GitLab

"vscode:/vscode.git/clone" did not exist on "5266ab7935dd9e9aec596cdc2464badf1eacd99a"
Commit 9b4db068 authored by Jesse Beder's avatar Jesse Beder
Browse files

Run clang-format

parent e40ed4f9
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 2733 additions and 2763 deletions
src/collectionstack.h
View file @ 9b4db068
#ifndef COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define COLLECTIONSTACK_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 <stack> #include <stack>
#include <cassert> #include <cassert>
namespace YAML namespace YAML {
{ struct CollectionType {
struct CollectionType { enum value {
enum value { None, BlockMap, BlockSeq, FlowMap, FlowSeq, CompactMap }; None,
}; BlockMap,
BlockSeq,
FlowMap,
FlowSeq,
CompactMap
};
};
class CollectionStack {
public:
CollectionType::value GetCurCollectionType() const {
if (collectionStack.empty())
return CollectionType::None;
return collectionStack.top();
}
void PushCollectionType(CollectionType::value type) {
collectionStack.push(type);
}
void PopCollectionType(CollectionType::value type) {
assert(type == GetCurCollectionType());
collectionStack.pop();
}
class CollectionStack private:
{ std::stack<CollectionType::value> collectionStack;
public: };
CollectionType::value GetCurCollectionType() const {
if(collectionStack.empty())
return CollectionType::None;
return collectionStack.top();
}
void PushCollectionType(CollectionType::value type) { collectionStack.push(type); }
void PopCollectionType(CollectionType::value type) { assert(type == GetCurCollectionType()); collectionStack.pop(); }
private:
std::stack<CollectionType::value> collectionStack;
};
} }
#endif // COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
src/contrib/graphbuilder.cpp
View file @ 9b4db068
...@@ -2,15 +2,14 @@ ...@@ -2,15 +2,14 @@
#include "yaml-cpp/contrib/graphbuilder.h" #include "yaml-cpp/contrib/graphbuilder.h"
#include "graphbuilderadapter.h" #include "graphbuilderadapter.h"
namespace YAML namespace YAML {
{ void* BuildGraphOfNextDocument(Parser& parser,
void *BuildGraphOfNextDocument(Parser& parser, GraphBuilderInterface& graphBuilder) GraphBuilderInterface& graphBuilder) {
{ GraphBuilderAdapter eventHandler(graphBuilder);
GraphBuilderAdapter eventHandler(graphBuilder); if (parser.HandleNextDocument(eventHandler)) {
if (parser.HandleNextDocument(eventHandler)) { return eventHandler.RootNode();
return eventHandler.RootNode(); } else {
} else { return NULL;
return NULL;
}
} }
} }
}
src/contrib/graphbuilderadapter.cpp
View file @ 9b4db068
#include "graphbuilderadapter.h" #include "graphbuilderadapter.h"
namespace YAML namespace YAML {
{ int GraphBuilderAdapter::ContainerFrame::sequenceMarker;
int GraphBuilderAdapter::ContainerFrame::sequenceMarker;
void GraphBuilderAdapter::OnNull(const Mark &mark, anchor_t anchor) {
void GraphBuilderAdapter::OnNull(const Mark& mark, anchor_t anchor) void *pParent = GetCurrentParent();
{ void *pNode = m_builder.NewNull(mark, pParent);
void *pParent = GetCurrentParent(); RegisterAnchor(anchor, pNode);
void *pNode = m_builder.NewNull(mark, pParent);
RegisterAnchor(anchor, pNode); DispositionNode(pNode);
}
DispositionNode(pNode);
} void GraphBuilderAdapter::OnAlias(const Mark &mark, anchor_t anchor) {
void *pReffedNode = m_anchors.Get(anchor);
void GraphBuilderAdapter::OnAlias(const Mark& mark, anchor_t anchor) DispositionNode(m_builder.AnchorReference(mark, pReffedNode));
{ }
void *pReffedNode = m_anchors.Get(anchor);
DispositionNode(m_builder.AnchorReference(mark, pReffedNode)); void GraphBuilderAdapter::OnScalar(const Mark &mark, const std::string &tag,
} anchor_t anchor, const std::string &value) {
void *pParent = GetCurrentParent();
void GraphBuilderAdapter::OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value) void *pNode = m_builder.NewScalar(mark, tag, pParent, value);
{ RegisterAnchor(anchor, pNode);
void *pParent = GetCurrentParent();
void *pNode = m_builder.NewScalar(mark, tag, pParent, value); DispositionNode(pNode);
RegisterAnchor(anchor, pNode); }
DispositionNode(pNode); void GraphBuilderAdapter::OnSequenceStart(const Mark &mark,
} const std::string &tag,
anchor_t anchor) {
void GraphBuilderAdapter::OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor) void *pNode = m_builder.NewSequence(mark, tag, GetCurrentParent());
{ m_containers.push(ContainerFrame(pNode));
void *pNode = m_builder.NewSequence(mark, tag, GetCurrentParent()); RegisterAnchor(anchor, pNode);
m_containers.push(ContainerFrame(pNode)); }
RegisterAnchor(anchor, pNode);
} void GraphBuilderAdapter::OnSequenceEnd() {
void *pSequence = m_containers.top().pContainer;
void GraphBuilderAdapter::OnSequenceEnd() m_containers.pop();
{
void *pSequence = m_containers.top().pContainer; DispositionNode(pSequence);
m_containers.pop(); }
DispositionNode(pSequence); void GraphBuilderAdapter::OnMapStart(const Mark &mark, const std::string &tag,
} anchor_t anchor) {
void *pNode = m_builder.NewMap(mark, tag, GetCurrentParent());
void GraphBuilderAdapter::OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor) m_containers.push(ContainerFrame(pNode, m_pKeyNode));
{ m_pKeyNode = NULL;
void *pNode = m_builder.NewMap(mark, tag, GetCurrentParent()); RegisterAnchor(anchor, pNode);
m_containers.push(ContainerFrame(pNode, m_pKeyNode)); }
m_pKeyNode = NULL;
RegisterAnchor(anchor, pNode); void GraphBuilderAdapter::OnMapEnd() {
} void *pMap = m_containers.top().pContainer;
m_pKeyNode = m_containers.top().pPrevKeyNode;
void GraphBuilderAdapter::OnMapEnd() m_containers.pop();
{ DispositionNode(pMap);
void *pMap = m_containers.top().pContainer; }
m_pKeyNode = m_containers.top().pPrevKeyNode;
m_containers.pop(); void *GraphBuilderAdapter::GetCurrentParent() const {
DispositionNode(pMap); if (m_containers.empty()) {
return NULL;
} }
return m_containers.top().pContainer;
void *GraphBuilderAdapter::GetCurrentParent() const }
{
if (m_containers.empty()) { void GraphBuilderAdapter::RegisterAnchor(anchor_t anchor, void *pNode) {
return NULL; if (anchor) {
} m_anchors.Register(anchor, pNode);
return m_containers.top().pContainer;
} }
}
void GraphBuilderAdapter::RegisterAnchor(anchor_t anchor, void *pNode)
{ void GraphBuilderAdapter::DispositionNode(void *pNode) {
if (anchor) { if (m_containers.empty()) {
m_anchors.Register(anchor, pNode); m_pRootNode = pNode;
} return;
} }
void GraphBuilderAdapter::DispositionNode(void *pNode) void *pContainer = m_containers.top().pContainer;
{ if (m_containers.top().isMap()) {
if (m_containers.empty()) { if (m_pKeyNode) {
m_pRootNode = pNode; m_builder.AssignInMap(pContainer, m_pKeyNode, pNode);
return; m_pKeyNode = NULL;
}
void *pContainer = m_containers.top().pContainer;
if (m_containers.top().isMap()) {
if (m_pKeyNode) {
m_builder.AssignInMap(pContainer, m_pKeyNode, pNode);
m_pKeyNode = NULL;
} else {
m_pKeyNode = pNode;
}
} else { } else {
m_builder.AppendToSequence(pContainer, pNode); m_pKeyNode = pNode;
} }
} else {
m_builder.AppendToSequence(pContainer, pNode);
} }
} }
}
src/contrib/graphbuilderadapter.h
View file @ 9b4db068
#ifndef GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define GRAPHBUILDERADAPTER_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
...@@ -12,62 +14,58 @@ ...@@ -12,62 +14,58 @@
#include "yaml-cpp/contrib/anchordict.h" #include "yaml-cpp/contrib/anchordict.h"
#include "yaml-cpp/contrib/graphbuilder.h" #include "yaml-cpp/contrib/graphbuilder.h"
namespace YAML namespace YAML {
{ class GraphBuilderAdapter : public EventHandler {
class GraphBuilderAdapter : public EventHandler public:
{ GraphBuilderAdapter(GraphBuilderInterface& builder)
public: : m_builder(builder), m_pRootNode(NULL), m_pKeyNode(NULL) {}
GraphBuilderAdapter(GraphBuilderInterface& builder)
: m_builder(builder), m_pRootNode(NULL), m_pKeyNode(NULL) virtual void OnDocumentStart(const Mark& mark) { (void)mark; }
{ virtual void OnDocumentEnd() {}
}
virtual void OnNull(const Mark& mark, anchor_t anchor);
virtual void OnDocumentStart(const Mark& mark) {(void)mark;} virtual void OnAlias(const Mark& mark, anchor_t anchor);
virtual void OnDocumentEnd() {} virtual void OnScalar(const Mark& mark, const std::string& tag,
anchor_t anchor, const std::string& value);
virtual void OnNull(const Mark& mark, anchor_t anchor);
virtual void OnAlias(const Mark& mark, anchor_t anchor); virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value); anchor_t anchor);
virtual void OnSequenceEnd();
virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor);
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();
void* RootNode() const { return m_pRootNode; }
void *RootNode() const {return m_pRootNode;}
private:
private: struct ContainerFrame {
struct ContainerFrame ContainerFrame(void* pSequence)
{ : pContainer(pSequence), pPrevKeyNode(&sequenceMarker) {}
ContainerFrame(void *pSequence) ContainerFrame(void* pMap, void* pPrevKeyNode)
: pContainer(pSequence), pPrevKeyNode(&sequenceMarker) : pContainer(pMap), pPrevKeyNode(pPrevKeyNode) {}
{}
ContainerFrame(void *pMap, void* pPrevKeyNode) void* pContainer;
: pContainer(pMap), pPrevKeyNode(pPrevKeyNode) void* pPrevKeyNode;
{}
bool isMap() const { return pPrevKeyNode != &sequenceMarker; }
void *pContainer;
void *pPrevKeyNode; private:
static int sequenceMarker;
bool isMap() const {return pPrevKeyNode != &sequenceMarker;}
private:
static int sequenceMarker;
};
typedef std::stack<ContainerFrame> ContainerStack;
typedef AnchorDict<void*> AnchorMap;
GraphBuilderInterface& m_builder;
ContainerStack m_containers;
AnchorMap m_anchors;
void *m_pRootNode;
void *m_pKeyNode;
void *GetCurrentParent() const;
void RegisterAnchor(anchor_t anchor, void *pNode);
void DispositionNode(void *pNode);
}; };
typedef std::stack<ContainerFrame> ContainerStack;
typedef AnchorDict<void*> AnchorMap;
GraphBuilderInterface& m_builder;
ContainerStack m_containers;
AnchorMap m_anchors;
void* m_pRootNode;
void* m_pKeyNode;
void* GetCurrentParent() const;
void RegisterAnchor(anchor_t anchor, void* pNode);
void DispositionNode(void* pNode);
};
} }
#endif // GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
src/directives.cpp
View file @ 9b4db068
#include "directives.h" #include "directives.h"
namespace YAML namespace YAML {
{ Directives::Directives() {
Directives::Directives() // version
{ version.isDefault = true;
// version version.major = 1;
version.isDefault = true; version.minor = 2;
version.major = 1; }
version.minor = 2;
} const std::string Directives::TranslateTagHandle(const std::string& handle)
const {
const std::string Directives::TranslateTagHandle(const std::string& handle) const std::map<std::string, std::string>::const_iterator it = tags.find(handle);
{ if (it == tags.end()) {
std::map <std::string, std::string>::const_iterator it = tags.find(handle); if (handle == "!!")
if(it == tags.end()) { return "tag:yaml.org,2002:";
if(handle == "!!") return handle;
return "tag:yaml.org,2002:"; }
return handle;
} return it->second;
}
return it->second;
}
} }
src/directives.h
View file @ 9b4db068
#ifndef DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define DIRECTIVES_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 <map> #include <map>
namespace YAML namespace YAML {
{ struct Version {
struct Version { bool isDefault;
bool isDefault; int major, minor;
int major, minor; };
};
struct Directives {
struct Directives { Directives();
Directives();
const std::string TranslateTagHandle(const std::string& handle) const;
const std::string TranslateTagHandle(const std::string& handle) const;
Version version; Version version;
std::map<std::string, std::string> tags; std::map<std::string, std::string> tags;
}; };
} }
#endif // DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
src/emitfromevents.cpp
View file @ 9b4db068
...@@ -5,101 +5,88 @@ ...@@ -5,101 +5,88 @@
#include <sstream> #include <sstream>
namespace { namespace {
std::string ToString(YAML::anchor_t anchor) { std::string ToString(YAML::anchor_t anchor) {
std::stringstream stream; std::stringstream stream;
stream << anchor; stream << anchor;
return stream.str(); return stream.str();
} }
}
namespace YAML {
EmitFromEvents::EmitFromEvents(Emitter& emitter) : m_emitter(emitter) {}
void EmitFromEvents::OnDocumentStart(const Mark&) {}
void EmitFromEvents::OnDocumentEnd() {}
void EmitFromEvents::OnNull(const Mark&, anchor_t anchor) {
BeginNode();
EmitProps("", anchor);
m_emitter << Null;
}
void EmitFromEvents::OnAlias(const Mark&, anchor_t anchor) {
BeginNode();
m_emitter << Alias(ToString(anchor));
}
void EmitFromEvents::OnScalar(const Mark&, const std::string& tag,
anchor_t anchor, const std::string& value) {
BeginNode();
EmitProps(tag, anchor);
m_emitter << value;
} }
namespace YAML void EmitFromEvents::OnSequenceStart(const Mark&, const std::string& tag,
{ anchor_t anchor) {
EmitFromEvents::EmitFromEvents(Emitter& emitter): m_emitter(emitter) BeginNode();
{ EmitProps(tag, anchor);
} m_emitter << BeginSeq;
m_stateStack.push(State::WaitingForSequenceEntry);
void EmitFromEvents::OnDocumentStart(const Mark&) }
{
} void EmitFromEvents::OnSequenceEnd() {
m_emitter << EndSeq;
void EmitFromEvents::OnDocumentEnd() assert(m_stateStack.top() == State::WaitingForSequenceEntry);
{ m_stateStack.pop();
} }
void EmitFromEvents::OnNull(const Mark&, anchor_t anchor) void EmitFromEvents::OnMapStart(const Mark&, const std::string& tag,
{ anchor_t anchor) {
BeginNode(); BeginNode();
EmitProps("", anchor); EmitProps(tag, anchor);
m_emitter << Null; m_emitter << BeginMap;
} m_stateStack.push(State::WaitingForKey);
}
void EmitFromEvents::OnAlias(const Mark&, anchor_t anchor)
{
BeginNode();
m_emitter << Alias(ToString(anchor));
}
void EmitFromEvents::OnScalar(const Mark&, const std::string& tag, anchor_t anchor, const std::string& value)
{
BeginNode();
EmitProps(tag, anchor);
m_emitter << value;
}
void EmitFromEvents::OnSequenceStart(const Mark&, const std::string& tag, anchor_t anchor)
{
BeginNode();
EmitProps(tag, anchor);
m_emitter << BeginSeq;
m_stateStack.push(State::WaitingForSequenceEntry);
}
void EmitFromEvents::OnSequenceEnd()
{
m_emitter << EndSeq;
assert(m_stateStack.top() == State::WaitingForSequenceEntry);
m_stateStack.pop();
}
void EmitFromEvents::OnMapStart(const Mark&, const std::string& tag, anchor_t anchor)
{
BeginNode();
EmitProps(tag, anchor);
m_emitter << BeginMap;
m_stateStack.push(State::WaitingForKey);
}
void EmitFromEvents::OnMapEnd() void EmitFromEvents::OnMapEnd() {
{ m_emitter << EndMap;
m_emitter << EndMap; assert(m_stateStack.top() == State::WaitingForKey);
assert(m_stateStack.top() == State::WaitingForKey); m_stateStack.pop();
m_stateStack.pop(); }
}
void EmitFromEvents::BeginNode() {
if (m_stateStack.empty())
return;
void EmitFromEvents::BeginNode() switch (m_stateStack.top()) {
{ case State::WaitingForKey:
if(m_stateStack.empty()) m_emitter << Key;
return; m_stateStack.top() = State::WaitingForValue;
break;
switch(m_stateStack.top()) { case State::WaitingForValue:
case State::WaitingForKey: m_emitter << Value;
m_emitter << Key; m_stateStack.top() = State::WaitingForKey;
m_stateStack.top() = State::WaitingForValue; break;
break; default:
case State::WaitingForValue: break;
m_emitter << Value; }
m_stateStack.top() = State::WaitingForKey; }
break;
default: void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) {
break; if (!tag.empty() && tag != "?")
} m_emitter << VerbatimTag(tag);
} if (anchor)
m_emitter << Anchor(ToString(anchor));
void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) }
{
if(!tag.empty() && tag != "?")
m_emitter << VerbatimTag(tag);
if(anchor)
m_emitter << Anchor(ToString(anchor));
}
} }
src/emitter.cpp
View file @ 9b4db068
This diff is collapsed.
src/emitterstate.cpp
View file @ 9b4db068
This diff is collapsed.
src/emitterstate.h
View file @ 9b4db068
This diff is collapsed.
src/emitterutils.cpp
View file @ 9b4db068
This diff is collapsed.
src/emitterutils.h
View file @ 9b4db068
#ifndef EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define EMITTERUTILS_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 "emitterstate.h" #include "emitterstate.h"
#include "yaml-cpp/ostream_wrapper.h" #include "yaml-cpp/ostream_wrapper.h"
#include <string> #include <string>
namespace YAML namespace YAML {
{ class Binary;
class Binary;
struct StringFormat {
struct StringFormat { enum value { Plain, SingleQuoted, DoubleQuoted, Literal }; }; enum value {
Plain,
SingleQuoted,
DoubleQuoted,
Literal
};
};
namespace Utils namespace Utils {
{ StringFormat::value ComputeStringFormat(const std::string& str,
StringFormat::value ComputeStringFormat(const std::string& str, EMITTER_MANIP strFormat, FlowType::value flowType, bool escapeNonAscii); EMITTER_MANIP strFormat,
FlowType::value flowType,
bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str); bool escapeNonAscii);
bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, bool escapeNonAscii);
bool WriteLiteralString(ostream_wrapper& out, const std::string& str, int indent); bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str);
bool WriteChar(ostream_wrapper& out, char ch); bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
bool WriteComment(ostream_wrapper& out, const std::string& str, int postCommentIndent); bool escapeNonAscii);
bool WriteAlias(ostream_wrapper& out, const std::string& str); bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
bool WriteAnchor(ostream_wrapper& out, const std::string& str); int indent);
bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim); bool WriteChar(ostream_wrapper& out, char ch);
bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix, const std::string& tag); bool WriteComment(ostream_wrapper& out, const std::string& str,
bool WriteBinary(ostream_wrapper& out, const Binary& binary); int postCommentIndent);
} bool WriteAlias(ostream_wrapper& out, const std::string& str);
bool WriteAnchor(ostream_wrapper& out, const std::string& str);
bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim);
bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix,
const std::string& tag);
bool WriteBinary(ostream_wrapper& out, const Binary& binary);
}
} }
#endif // EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
src/exp.cpp
View file @ 9b4db068
This diff is collapsed.
src/exp.h
View file @ 9b4db068
This diff is collapsed.
src/indentation.h
View file @ 9b4db068
This diff is collapsed.
src/null.cpp
View file @ 9b4db068
#include "yaml-cpp/null.h" #include "yaml-cpp/null.h"
namespace YAML namespace YAML {
{ _Null Null;
_Null Null;
} }
src/ostream_wrapper.cpp
View file @ 9b4db068
This diff is collapsed.
src/parser.cpp
View file @ 9b4db068
This diff is collapsed.
src/ptr_stack.h
View file @ 9b4db068
This diff is collapsed.
src/ptr_vector.h
View file @ 9b4db068
This diff is collapsed.
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