Skip to content

GitLab

Commit 3355bbb3 authored by Jesse Beder's avatar Jesse Beder
Browse files

Merge clang-format from core

parents 5b889311 9b4db068
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 3213 additions and 3245 deletions
src/contrib/graphbuilderadapter.h
View file @ 3355bbb3
#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 @ 3355bbb3
#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 @ 3355bbb3
#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 @ 3355bbb3
...@@ -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 @ 3355bbb3
This diff is collapsed.
src/emitterstate.cpp
View file @ 3355bbb3
This diff is collapsed.
src/emitterstate.h
View file @ 3355bbb3
#ifndef EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #ifndef EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #define EMITTERSTATE_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 "ptr_stack.h" #include "ptr_stack.h"
#include "setting.h" #include "setting.h"
#include "yaml-cpp/emitterdef.h" #include "yaml-cpp/emitterdef.h"
...@@ -16,175 +17,198 @@ ...@@ -16,175 +17,198 @@
#include <memory> #include <memory>
#include <stdexcept> #include <stdexcept>
namespace YAML namespace YAML {
{ struct FmtScope {
struct FmtScope { enum value { Local, Global }; }; enum value {
struct GroupType { enum value { None, Seq, Map }; }; Local,
struct FlowType { enum value { None, Flow, Block }; }; Global
};
class EmitterState };
{ struct GroupType {
public: enum value {
EmitterState(); None,
~EmitterState(); Seq,
Map
// basic state checking };
bool good() const { return m_isGood; } };
const std::string GetLastError() const { return m_lastError; } struct FlowType {
void SetError(const std::string& error) { m_isGood = false; m_lastError = error; } enum value {
None,
// node handling Flow,
void SetAnchor(); Block
void SetTag(); };
void SetNonContent(); };
void SetLongKey();
void ForceFlow(); class EmitterState {
void StartedDoc(); public:
void EndedDoc(); EmitterState();
void StartedScalar(); ~EmitterState();
void StartedGroup(GroupType::value type);
void EndedGroup(GroupType::value type); // basic state checking
bool good() const { return m_isGood; }
EmitterNodeType::value NextGroupType(GroupType::value type) const; const std::string GetLastError() const { return m_lastError; }
EmitterNodeType::value CurGroupNodeType() const; void SetError(const std::string& error) {
m_isGood = false;
GroupType::value CurGroupType() const; m_lastError = error;
FlowType::value CurGroupFlowType() const; }
int CurGroupIndent() const;
std::size_t CurGroupChildCount() const; // node handling
bool CurGroupLongKey() const; void SetAnchor();
void SetTag();
int LastIndent() const; void SetNonContent();
int CurIndent() const { return m_curIndent; } void SetLongKey();
bool HasAnchor() const { return m_hasAnchor; } void ForceFlow();
bool HasTag() const { return m_hasTag; } void StartedDoc();
bool HasBegunNode() const { return m_hasAnchor || m_hasTag || m_hasNonContent; } void EndedDoc();
bool HasBegunContent() const { return m_hasAnchor || m_hasTag; } void StartedScalar();
void StartedGroup(GroupType::value type);
void ClearModifiedSettings(); void EndedGroup(GroupType::value type);
// formatters EmitterNodeType::value NextGroupType(GroupType::value type) const;
void SetLocalValue(EMITTER_MANIP value); EmitterNodeType::value CurGroupNodeType() const;
bool SetOutputCharset(EMITTER_MANIP value, FmtScope::value scope); GroupType::value CurGroupType() const;
EMITTER_MANIP GetOutputCharset() const { return m_charset.get(); } FlowType::value CurGroupFlowType() const;
int CurGroupIndent() const;
bool SetStringFormat(EMITTER_MANIP value, FmtScope::value scope); std::size_t CurGroupChildCount() const;
EMITTER_MANIP GetStringFormat() const { return m_strFmt.get(); } bool CurGroupLongKey() const;
bool SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope); int LastIndent() const;
EMITTER_MANIP GetBoolFormat() const { return m_boolFmt.get(); } int CurIndent() const { return m_curIndent; }
bool HasAnchor() const { return m_hasAnchor; }
bool SetBoolLengthFormat(EMITTER_MANIP value, FmtScope::value scope); bool HasTag() const { return m_hasTag; }
EMITTER_MANIP GetBoolLengthFormat() const { return m_boolLengthFmt.get(); } bool HasBegunNode() const {
return m_hasAnchor || m_hasTag || m_hasNonContent;
bool SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope); }
EMITTER_MANIP GetBoolCaseFormat() const { return m_boolCaseFmt.get(); } bool HasBegunContent() const { return m_hasAnchor || m_hasTag; }
bool SetIntFormat(EMITTER_MANIP value, FmtScope::value scope); void ClearModifiedSettings();
EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); }
// formatters
bool SetIndent(unsigned value, FmtScope::value scope); void SetLocalValue(EMITTER_MANIP value);
int GetIndent() const { return m_indent.get(); }
bool SetOutputCharset(EMITTER_MANIP value, FmtScope::value scope);
bool SetPreCommentIndent(unsigned value, FmtScope::value scope); EMITTER_MANIP GetOutputCharset() const { return m_charset.get(); }
int GetPreCommentIndent() const { return m_preCommentIndent.get(); }
bool SetPostCommentIndent(unsigned value, FmtScope::value scope); bool SetStringFormat(EMITTER_MANIP value, FmtScope::value scope);
int GetPostCommentIndent() const { return m_postCommentIndent.get(); } EMITTER_MANIP GetStringFormat() const { return m_strFmt.get(); }
bool SetFlowType(GroupType::value groupType, EMITTER_MANIP value, FmtScope::value scope); bool SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope);
EMITTER_MANIP GetFlowType(GroupType::value groupType) const; EMITTER_MANIP GetBoolFormat() const { return m_boolFmt.get(); }
bool SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope); bool SetBoolLengthFormat(EMITTER_MANIP value, FmtScope::value scope);
EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); } EMITTER_MANIP GetBoolLengthFormat() const { return m_boolLengthFmt.get(); }
bool SetFloatPrecision(int value, FmtScope::value scope); bool SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope);
unsigned GetFloatPrecision() const { return m_floatPrecision.get(); } EMITTER_MANIP GetBoolCaseFormat() const { return m_boolCaseFmt.get(); }
bool SetDoublePrecision(int value, FmtScope::value scope);
unsigned GetDoublePrecision() const { return m_doublePrecision.get(); } bool SetIntFormat(EMITTER_MANIP value, FmtScope::value scope);
EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); }
private:
template <typename T> bool SetIndent(unsigned value, FmtScope::value scope);
void _Set(Setting<T>& fmt, T value, FmtScope::value scope); int GetIndent() const { return m_indent.get(); }
void StartedNode(); bool SetPreCommentIndent(unsigned value, FmtScope::value scope);
int GetPreCommentIndent() const { return m_preCommentIndent.get(); }
private: bool SetPostCommentIndent(unsigned value, FmtScope::value scope);
// basic state ok? int GetPostCommentIndent() const { return m_postCommentIndent.get(); }
bool m_isGood;
std::string m_lastError; bool SetFlowType(GroupType::value groupType, EMITTER_MANIP value,
FmtScope::value scope);
// other state EMITTER_MANIP GetFlowType(GroupType::value groupType) const;
Setting<EMITTER_MANIP> m_charset;
Setting<EMITTER_MANIP> m_strFmt; bool SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope);
Setting<EMITTER_MANIP> m_boolFmt; EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); }
Setting<EMITTER_MANIP> m_boolLengthFmt;
Setting<EMITTER_MANIP> m_boolCaseFmt; bool SetFloatPrecision(int value, FmtScope::value scope);
Setting<EMITTER_MANIP> m_intFmt; unsigned GetFloatPrecision() const { return m_floatPrecision.get(); }
Setting<unsigned> m_indent; bool SetDoublePrecision(int value, FmtScope::value scope);
Setting<unsigned> m_preCommentIndent, m_postCommentIndent; unsigned GetDoublePrecision() const { return m_doublePrecision.get(); }
Setting<EMITTER_MANIP> m_seqFmt;
Setting<EMITTER_MANIP> m_mapFmt; private:
Setting<EMITTER_MANIP> m_mapKeyFmt; template <typename T>
Setting<int> m_floatPrecision; void _Set(Setting<T>& fmt, T value, FmtScope::value scope);
Setting<int> m_doublePrecision;
void StartedNode();
SettingChanges m_modifiedSettings;
SettingChanges m_globalModifiedSettings; private:
// basic state ok?
struct Group { bool m_isGood;
explicit Group(GroupType::value type_): type(type_), indent(0), childCount(0), longKey(false) {} std::string m_lastError;
GroupType::value type; // other state
FlowType::value flowType; Setting<EMITTER_MANIP> m_charset;
int indent; Setting<EMITTER_MANIP> m_strFmt;
std::size_t childCount; Setting<EMITTER_MANIP> m_boolFmt;
bool longKey; Setting<EMITTER_MANIP> m_boolLengthFmt;
Setting<EMITTER_MANIP> m_boolCaseFmt;
SettingChanges modifiedSettings; Setting<EMITTER_MANIP> m_intFmt;
Setting<unsigned> m_indent;
EmitterNodeType::value NodeType() const { Setting<unsigned> m_preCommentIndent, m_postCommentIndent;
if(type == GroupType::Seq) { Setting<EMITTER_MANIP> m_seqFmt;
if(flowType == FlowType::Flow) Setting<EMITTER_MANIP> m_mapFmt;
return EmitterNodeType::FlowSeq; Setting<EMITTER_MANIP> m_mapKeyFmt;
else Setting<int> m_floatPrecision;
return EmitterNodeType::BlockSeq; Setting<int> m_doublePrecision;
} else {
if(flowType == FlowType::Flow) SettingChanges m_modifiedSettings;
return EmitterNodeType::FlowMap; SettingChanges m_globalModifiedSettings;
else
return EmitterNodeType::BlockMap; struct Group {
} explicit Group(GroupType::value type_)
: type(type_), indent(0), childCount(0), longKey(false) {}
// can't get here
assert(false); GroupType::value type;
return EmitterNodeType::None; FlowType::value flowType;
} int indent;
}; std::size_t childCount;
bool longKey;
ptr_stack<Group> m_groups;
unsigned m_curIndent; SettingChanges modifiedSettings;
bool m_hasAnchor;
bool m_hasTag; EmitterNodeType::value NodeType() const {
bool m_hasNonContent; if (type == GroupType::Seq) {
std::size_t m_docCount; if (flowType == FlowType::Flow)
}; return EmitterNodeType::FlowSeq;
else
template <typename T> return EmitterNodeType::BlockSeq;
void EmitterState::_Set(Setting<T>& fmt, T value, FmtScope::value scope) { } else {
switch(scope) { if (flowType == FlowType::Flow)
case FmtScope::Local: return EmitterNodeType::FlowMap;
m_modifiedSettings.push(fmt.set(value)); else
break; return EmitterNodeType::BlockMap;
case FmtScope::Global: }
fmt.set(value);
m_globalModifiedSettings.push(fmt.set(value)); // this pushes an identity set, so when we restore, // can't get here
// it restores to the value here, and not the previous one assert(false);
break; return EmitterNodeType::None;
default: }
assert(false); };
}
} ptr_stack<Group> m_groups;
unsigned m_curIndent;
bool m_hasAnchor;
bool m_hasTag;
bool m_hasNonContent;
std::size_t m_docCount;
};
template <typename T>
void EmitterState::_Set(Setting<T>& fmt, T value, FmtScope::value scope) {
switch (scope) {
case FmtScope::Local:
m_modifiedSettings.push(fmt.set(value));
break;
case FmtScope::Global:
fmt.set(value);
m_globalModifiedSettings.push(
fmt.set(value)); // this pushes an identity set, so when we restore,
// it restores to the value here, and not the previous one
break;
default:
assert(false);
}
}
} }
#endif // EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 #endif // EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
src/emitterutils.cpp
View file @ 3355bbb3
This diff is collapsed.
src/emitterutils.h
View file @ 3355bbb3
This diff is collapsed.
src/exp.cpp
View file @ 3355bbb3
This diff is collapsed.
src/exp.h
View file @ 3355bbb3
This diff is collapsed.
src/indentation.h
View file @ 3355bbb3
This diff is collapsed.
src/null.cpp
View file @ 3355bbb3
#include "yaml-cpp/null.h" #include "yaml-cpp/null.h"
namespace YAML namespace YAML {
{ _Null Null;
_Null Null;
} }
src/parser.cpp
View file @ 3355bbb3
This diff is collapsed.
src/ptr_stack.h
View file @ 3355bbb3
This diff is collapsed.
src/ptr_vector.h
View file @ 3355bbb3
This diff is collapsed.
src/regex.cpp
View file @ 3355bbb3
This diff is collapsed.
src/regex.h
View file @ 3355bbb3
This diff is collapsed.
src/regeximpl.h
View file @ 3355bbb3
This diff is collapsed.
src/scanner.cpp
View file @ 3355bbb3
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