External/yaml-cpp
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix for current version of G++11

Browse Source 
modified:   src/emitter.cpp
	modified:   src/emitterstate.cpp
	modified:   src/emitterstate.h
	modified:   src/emitterutils.cpp
	modified:   src/emitterutils.h
	modified:   test/CMakeLists.txt
This commit is contained in:
Giorgio Zoppi 2021-11-04 16:32:00 +01:00
parent 328d2d85e8
commit 0f536caf54
6 changed files with 128 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
src/emitter.cpp
View File

@ -31,63 +31,63 @@ const std::string Emitter::GetLastError() const {
// global setters // global setters
bool Emitter::SetOutputCharset(EMITTER_MANIP value) { bool Emitter::SetOutputCharset(EMITTER_MANIP value) {
return m_pState->SetOutputCharset(value, FmtScope::Global); return m_pState->SetOutputCharset(value, FmtScopeTypeValue::Global);
} }
bool Emitter::SetStringFormat(EMITTER_MANIP value) { bool Emitter::SetStringFormat(EMITTER_MANIP value) {
return m_pState->SetStringFormat(value, FmtScope::Global); return m_pState->SetStringFormat(value, FmtScopeTypeValue::Global);
} }
bool Emitter::SetBoolFormat(EMITTER_MANIP value) { bool Emitter::SetBoolFormat(EMITTER_MANIP value) {
bool ok = false; bool ok = false;
if (m_pState->SetBoolFormat(value, FmtScope::Global)) if (m_pState->SetBoolFormat(value, FmtScopeTypeValue::Global))
ok = true; ok = true;
if (m_pState->SetBoolCaseFormat(value, FmtScope::Global)) if (m_pState->SetBoolCaseFormat(value, FmtScopeTypeValue::Global))
ok = true; ok = true;
if (m_pState->SetBoolLengthFormat(value, FmtScope::Global)) if (m_pState->SetBoolLengthFormat(value, FmtScopeTypeValue::Global))
ok = true; ok = true;
return ok; return ok;
} }
bool Emitter::SetNullFormat(EMITTER_MANIP value) { bool Emitter::SetNullFormat(EMITTER_MANIP value) {
return m_pState->SetNullFormat(value, FmtScope::Global); return m_pState->SetNullFormat(value, FmtScopeTypeValue::Global);
} }
bool Emitter::SetIntBase(EMITTER_MANIP value) { bool Emitter::SetIntBase(EMITTER_MANIP value) {
return m_pState->SetIntFormat(value, FmtScope::Global); return m_pState->SetIntFormat(value, FmtScopeTypeValue::Global);
} }
bool Emitter::SetSeqFormat(EMITTER_MANIP value) { bool Emitter::SetSeqFormat(EMITTER_MANIP value) {
return m_pState->SetFlowType(GroupType::Seq, value, FmtScope::Global); return m_pState->SetFlowType(GroupTypeValue::Seq, value, FmtScopeTypeValue::Global);
} }
bool Emitter::SetMapFormat(EMITTER_MANIP value) { bool Emitter::SetMapFormat(EMITTER_MANIP value) {
bool ok = false; bool ok = false;
if (m_pState->SetFlowType(GroupType::Map, value, FmtScope::Global)) if (m_pState->SetFlowType(GroupTypeValue::Map, value, FmtScopeTypeValue::Global))
ok = true; ok = true;
if (m_pState->SetMapKeyFormat(value, FmtScope::Global)) if (m_pState->SetMapKeyFormat(value, FmtScopeTypeValue::Global))
ok = true; ok = true;
return ok; return ok;
} }
bool Emitter::SetIndent(std::size_t n) { bool Emitter::SetIndent(std::size_t n) {
return m_pState->SetIndent(n, FmtScope::Global); return m_pState->SetIndent(n, FmtScopeTypeValue::Global);
} }
bool Emitter::SetPreCommentIndent(std::size_t n) { bool Emitter::SetPreCommentIndent(std::size_t n) {
return m_pState->SetPreCommentIndent(n, FmtScope::Global); return m_pState->SetPreCommentIndent(n, FmtScopeTypeValue::Global);
} }
bool Emitter::SetPostCommentIndent(std::size_t n) { bool Emitter::SetPostCommentIndent(std::size_t n) {
return m_pState->SetPostCommentIndent(n, FmtScope::Global); return m_pState->SetPostCommentIndent(n, FmtScopeTypeValue::Global);
} }
bool Emitter::SetFloatPrecision(std::size_t n) { bool Emitter::SetFloatPrecision(std::size_t n) {
return m_pState->SetFloatPrecision(n, FmtScope::Global); return m_pState->SetFloatPrecision(n, FmtScopeTypeValue::Global);
} }
bool Emitter::SetDoublePrecision(std::size_t n) { bool Emitter::SetDoublePrecision(std::size_t n) {
return m_pState->SetDoublePrecision(n, FmtScope::Global); return m_pState->SetDoublePrecision(n, FmtScopeTypeValue::Global);
} }
void Emitter::RestoreGlobalModifiedSettings() { void Emitter::RestoreGlobalModifiedSettings() {
@ -137,15 +137,15 @@ Emitter& Emitter::SetLocalValue(EMITTER_MANIP value) {
} }
Emitter& Emitter::SetLocalIndent(const _Indent& indent) { Emitter& Emitter::SetLocalIndent(const _Indent& indent) {
m_pState->SetIndent(indent.value, FmtScope::Local); m_pState->SetIndent(indent.value, FmtScopeTypeValue::Local);
return *this; return *this;
} }
Emitter& Emitter::SetLocalPrecision(const _Precision& precision) { Emitter& Emitter::SetLocalPrecision(const _Precision& precision) {
if (precision.floatPrecision >= 0) if (precision.floatPrecision >= 0)
m_pState->SetFloatPrecision(precision.floatPrecision, FmtScope::Local); m_pState->SetFloatPrecision(precision.floatPrecision, FmtScopeTypeValue::Local);
if (precision.doublePrecision >= 0) if (precision.doublePrecision >= 0)
m_pState->SetDoublePrecision(precision.doublePrecision, FmtScope::Local); m_pState->SetDoublePrecision(precision.doublePrecision, FmtScopeTypeValue::Local);
return *this; return *this;
} }
@ -154,7 +154,7 @@ void Emitter::EmitBeginDoc() {
if (!good()) if (!good())
return; return;
if (m_pState->CurGroupType() != GroupType::NoType) { if (m_pState->CurGroupType() != GroupTypeValue::NoType) {
m_pState->SetError("Unexpected begin document"); m_pState->SetError("Unexpected begin document");
return; return;
} }
@ -176,7 +176,7 @@ void Emitter::EmitEndDoc() {
if (!good()) if (!good())
return; return;
if (m_pState->CurGroupType() != GroupType::NoType) { if (m_pState->CurGroupType() != GroupTypeValue::NoType) {
m_pState->SetError("Unexpected begin document"); m_pState->SetError("Unexpected begin document");
return; return;
} }
@ -196,25 +196,25 @@ void Emitter::EmitBeginSeq() {
if (!good()) if (!good())
return; return;
PrepareNode(m_pState->NextGroupType(GroupType::Seq)); PrepareNode(m_pState->NextGroupType(GroupTypeValue::Seq));
m_pState->StartedGroup(GroupType::Seq); m_pState->StartedGroup(GroupTypeValue::Seq);
} }
// EmitEndSeq // EmitEndSeq
void Emitter::EmitEndSeq() { void Emitter::EmitEndSeq() {
if (!good()) if (!good())
return; return;
FlowType::value originalType = m_pState->CurGroupFlowType(); FlowTypeValue originalType = m_pState->CurGroupFlowType();
if (m_pState->CurGroupChildCount() == 0) if (m_pState->CurGroupChildCount() == 0)
m_pState->ForceFlow(); m_pState->ForceFlow();
if (m_pState->CurGroupFlowType() == FlowType::Flow) { if (m_pState->CurGroupFlowType() == FlowTypeValue::Flow) {
if (m_stream.comment()) if (m_stream.comment())
m_stream << "\n"; m_stream << "\n";
m_stream << IndentTo(m_pState->CurIndent()); m_stream << IndentTo(m_pState->CurIndent());
if (originalType == FlowType::Block) { if (originalType ==FlowTypeValue::Block) {
m_stream << "["; m_stream << "[";
} else { } else {
if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode()) if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode())
@ -223,7 +223,7 @@ void Emitter::EmitEndSeq() {
m_stream << "]"; m_stream << "]";
} }
m_pState->EndedGroup(GroupType::Seq); m_pState->EndedGroup(GroupTypeValue::Seq);
} }
// EmitBeginMap // EmitBeginMap
@ -231,25 +231,25 @@ void Emitter::EmitBeginMap() {
if (!good()) if (!good())
return; return;
PrepareNode(m_pState->NextGroupType(GroupType::Map)); PrepareNode(m_pState->NextGroupType(GroupTypeValue::Map));
m_pState->StartedGroup(GroupType::Map); m_pState->StartedGroup(GroupTypeValue::Map);
} }
// EmitEndMap // EmitEndMap
void Emitter::EmitEndMap() { void Emitter::EmitEndMap() {
if (!good()) if (!good())
return; return;
FlowType::value originalType = m_pState->CurGroupFlowType(); FlowTypeValue originalType = m_pState->CurGroupFlowType();
if (m_pState->CurGroupChildCount() == 0) if (m_pState->CurGroupChildCount() == 0)
m_pState->ForceFlow(); m_pState->ForceFlow();
if (m_pState->CurGroupFlowType() == FlowType::Flow) { if (m_pState->CurGroupFlowType() == FlowTypeValue::Flow) {
if (m_stream.comment()) if (m_stream.comment())
m_stream << "\n"; m_stream << "\n";
m_stream << IndentTo(m_pState->CurIndent()); m_stream << IndentTo(m_pState->CurIndent());
if (originalType == FlowType::Block) { if (originalType == FlowTypeValue::Block) {
m_stream << "{"; m_stream << "{";
} else { } else {
if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode()) if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode())
@ -258,7 +258,7 @@ void Emitter::EmitEndMap() {
m_stream << "}"; m_stream << "}";
} }
m_pState->EndedGroup(GroupType::Map); m_pState->EndedGroup(GroupTypeValue::Map);
} }
// EmitNewline // EmitNewline
@ -720,12 +720,12 @@ Emitter& Emitter::Write(const std::string& str) {
StringEscaping::value stringEscaping = GetStringEscapingStyle(m_pState->GetOutputCharset()); StringEscaping::value stringEscaping = GetStringEscapingStyle(m_pState->GetOutputCharset());
const StringFormat::value strFormat = const StringFormat strFormat =
Utils::ComputeStringFormat(str, m_pState->GetStringFormat(), Utils::ComputeStringFormat(str, m_pState->GetStringFormat(),
m_pState->CurGroupFlowType(), stringEscaping == StringEscaping::NonAscii); m_pState->CurGroupFlowType(), stringEscaping == StringEscaping::NonAscii);
if (strFormat == StringFormat::Literal || str.size() > 1024) if (strFormat == StringFormat::Literal || str.size() > 1024)
m_pState->SetMapKeyFormat(YAML::LongKey, FmtScope::Local); m_pState->SetMapKeyFormat(YAML::LongKey, FmtScopeTypeValue::Local);
PrepareNode(EmitterNodeType::Scalar); PrepareNode(EmitterNodeType::Scalar);

84
src/emitterstate.cpp
View File

@ -40,16 +40,16 @@ EmitterState::~EmitterState() = default;
// . We blindly tries to set all possible formatters to this value // . We blindly tries to set all possible formatters to this value
// . Only the ones that make sense will be accepted // . Only the ones that make sense will be accepted
void EmitterState::SetLocalValue(EMITTER_MANIP value) { void EmitterState::SetLocalValue(EMITTER_MANIP value) {
SetOutputCharset(value, FmtScope::Local); SetOutputCharset(value, FmtScopeTypeValue::Local);
SetStringFormat(value, FmtScope::Local); SetStringFormat(value, FmtScopeTypeValue::Local);
SetBoolFormat(value, FmtScope::Local); SetBoolFormat(value, FmtScopeTypeValue::Local);
SetBoolCaseFormat(value, FmtScope::Local); SetBoolCaseFormat(value, FmtScopeTypeValue::Local);
SetBoolLengthFormat(value, FmtScope::Local); SetBoolLengthFormat(value, FmtScopeTypeValue::Local);
SetNullFormat(value, FmtScope::Local); SetNullFormat(value, FmtScopeTypeValue::Local);
SetIntFormat(value, FmtScope::Local); SetIntFormat(value, FmtScopeTypeValue::Local);
SetFlowType(GroupType::Seq, value, FmtScope::Local); SetFlowType(GroupTypeValue::Seq, value, FmtScopeTypeValue::Local);
SetFlowType(GroupType::Map, value, FmtScope::Local); SetFlowType(GroupTypeValue::Map, value, FmtScopeTypeValue::Local);
SetMapKeyFormat(value, FmtScope::Local); SetMapKeyFormat(value, FmtScopeTypeValue::Local);
} }
void EmitterState::SetAnchor() { m_hasAnchor = true; } void EmitterState::SetAnchor() { m_hasAnchor = true; }
@ -66,7 +66,7 @@ void EmitterState::SetLongKey() {
return; return;
} }
assert(m_groups.back()->type == GroupType::Map); assert(m_groups.back()->type == GroupTypeValue::Map);
m_groups.back()->longKey = true; m_groups.back()->longKey = true;
} }
@ -76,7 +76,7 @@ void EmitterState::ForceFlow() {
return; return;
} }
m_groups.back()->flowType = FlowType::Flow; m_groups.back()->flowType = FlowTypeValue::Flow;
} }
void EmitterState::StartedNode() { void EmitterState::StartedNode() {
@ -96,8 +96,8 @@ void EmitterState::StartedNode() {
} }
EmitterNodeType::value EmitterState::NextGroupType( EmitterNodeType::value EmitterState::NextGroupType(
GroupType::value type) const { GroupTypeValue type) const {
if (type == GroupType::Seq) { if (type == GroupTypeValue::Seq) {
if (GetFlowType(type) == Block) if (GetFlowType(type) == Block)
return EmitterNodeType::BlockSeq; return EmitterNodeType::BlockSeq;
return EmitterNodeType::FlowSeq; return EmitterNodeType::FlowSeq;
@ -129,7 +129,7 @@ void EmitterState::StartedScalar() {
ClearModifiedSettings(); ClearModifiedSettings();
} }
void EmitterState::StartedGroup(GroupType::value type) { void EmitterState::StartedGroup(GroupTypeValue type) {
StartedNode(); StartedNode();
const std::size_t lastGroupIndent = const std::size_t lastGroupIndent =
@ -147,18 +147,18 @@ void EmitterState::StartedGroup(GroupType::value type) {
// set up group // set up group
if (GetFlowType(type) == Block) { if (GetFlowType(type) == Block) {
pGroup->flowType = FlowType::Block; pGroup->flowType = FlowTypeValue::Block;
} else { } else {
pGroup->flowType = FlowType::Flow; pGroup->flowType = FlowTypeValue::Flow;
} }
pGroup->indent = GetIndent(); pGroup->indent = GetIndent();
m_groups.push_back(std::move(pGroup)); m_groups.push_back(std::move(pGroup));
} }
void EmitterState::EndedGroup(GroupType::value type) { void EmitterState::EndedGroup(GroupTypeValue type) {
if (m_groups.empty()) { if (m_groups.empty()) {
if (type == GroupType::Seq) { if (type == GroupTypeValue::Seq) {
return SetError(ErrorMsg::UNEXPECTED_END_SEQ); return SetError(ErrorMsg::UNEXPECTED_END_SEQ);
} }
return SetError(ErrorMsg::UNEXPECTED_END_MAP); return SetError(ErrorMsg::UNEXPECTED_END_MAP);
@ -203,12 +203,12 @@ EmitterNodeType::value EmitterState::CurGroupNodeType() const {
return m_groups.back()->NodeType(); return m_groups.back()->NodeType();
} }
GroupType::value EmitterState::CurGroupType() const { GroupTypeValue EmitterState::CurGroupType() const {
return m_groups.empty() ? GroupType::NoType : m_groups.back()->type; return m_groups.empty() ? GroupTypeValue::NoType : m_groups.back()->type;
} }
FlowType::value EmitterState::CurGroupFlowType() const { FlowTypeValue EmitterState::CurGroupFlowType() const {
return m_groups.empty() ? FlowType::NoType : m_groups.back()->flowType; return m_groups.empty() ? FlowTypeValue::NoType : m_groups.back()->flowType;
} }
std::size_t EmitterState::CurGroupIndent() const { std::size_t EmitterState::CurGroupIndent() const {
@ -238,7 +238,7 @@ void EmitterState::RestoreGlobalModifiedSettings() {
} }
bool EmitterState::SetOutputCharset(EMITTER_MANIP value, bool EmitterState::SetOutputCharset(EMITTER_MANIP value,
FmtScope::value scope) { FmtScopeTypeValue scope) {
switch (value) { switch (value) {
case EmitNonAscii: case EmitNonAscii:
case EscapeNonAscii: case EscapeNonAscii:
@ -250,7 +250,7 @@ bool EmitterState::SetOutputCharset(EMITTER_MANIP value,
} }
} }
bool EmitterState::SetStringFormat(EMITTER_MANIP value, FmtScope::value scope) { bool EmitterState::SetStringFormat(EMITTER_MANIP value, FmtScopeTypeValue scope) {
switch (value) { switch (value) {
case Auto: case Auto:
case SingleQuoted: case SingleQuoted:
@ -263,7 +263,7 @@ bool EmitterState::SetStringFormat(EMITTER_MANIP value, FmtScope::value scope) {
} }
} }
bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope) { bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FmtScopeTypeValue scope) {
switch (value) { switch (value) {
case OnOffBool: case OnOffBool:
case TrueFalseBool: case TrueFalseBool:
@ -276,7 +276,7 @@ bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope) {
} }
bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value, bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value,
FmtScope::value scope) { FmtScopeTypeValue scope) {
switch (value) { switch (value) {
case LongBool: case LongBool:
case ShortBool: case ShortBool:
@ -288,7 +288,7 @@ bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value,
} }
bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value, bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value,
FmtScope::value scope) { FmtScopeTypeValue scope) {
switch (value) { switch (value) {
case UpperCase: case UpperCase:
case LowerCase: case LowerCase:
@ -300,7 +300,7 @@ bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value,
} }
} }
bool EmitterState::SetNullFormat(EMITTER_MANIP value, FmtScope::value scope) { bool EmitterState::SetNullFormat(EMITTER_MANIP value, FmtScopeTypeValue scope) {
switch (value) { switch (value) {
case LowerNull: case LowerNull:
case UpperNull: case UpperNull:
@ -313,7 +313,7 @@ bool EmitterState::SetNullFormat(EMITTER_MANIP value, FmtScope::value scope) {
} }
} }
bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScope::value scope) { bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScopeTypeValue scope) {
switch (value) { switch (value) {
case Dec: case Dec:
case Hex: case Hex:
@ -325,7 +325,7 @@ bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScope::value scope) {
} }
} }
bool EmitterState::SetIndent(std::size_t value, FmtScope::value scope) { bool EmitterState::SetIndent(std::size_t value, FmtScopeTypeValue scope) {
if (value <= 1) if (value <= 1)
return false; return false;
@ -334,7 +334,7 @@ bool EmitterState::SetIndent(std::size_t value, FmtScope::value scope) {
} }
bool EmitterState::SetPreCommentIndent(std::size_t value, bool EmitterState::SetPreCommentIndent(std::size_t value,
FmtScope::value scope) { FmtScopeTypeValue scope) {
if (value == 0) if (value == 0)
return false; return false;
@ -343,7 +343,7 @@ bool EmitterState::SetPreCommentIndent(std::size_t value,
} }
bool EmitterState::SetPostCommentIndent(std::size_t value, bool EmitterState::SetPostCommentIndent(std::size_t value,
FmtScope::value scope) { FmtScopeTypeValue scope) {
if (value == 0) if (value == 0)
return false; return false;
@ -351,28 +351,28 @@ bool EmitterState::SetPostCommentIndent(std::size_t value,
return true; return true;
} }
bool EmitterState::SetFlowType(GroupType::value groupType, EMITTER_MANIP value, bool EmitterState::SetFlowType(GroupTypeValue groupType, EMITTER_MANIP value,
FmtScope::value scope) { FmtScopeTypeValue scope) {
switch (value) { switch (value) {
case Block: case Block:
case Flow: case Flow:
_Set(groupType == GroupType::Seq ? m_seqFmt : m_mapFmt, value, scope); _Set(groupType == GroupTypeValue::Seq ? m_seqFmt : m_mapFmt, value, scope);
return true; return true;
default: default:
return false; return false;
} }
} }
EMITTER_MANIP EmitterState::GetFlowType(GroupType::value groupType) const { EMITTER_MANIP EmitterState::GetFlowType(GroupTypeValue groupType) const {
// force flow style if we're currently in a flow // force flow style if we're currently in a flow
if (CurGroupFlowType() == FlowType::Flow) if (CurGroupFlowType() == FlowTypeValue::Flow)
return Flow; return Flow;
// otherwise, go with what's asked of us // otherwise, go with what's asked of us
return (groupType == GroupType::Seq ? m_seqFmt.get() : m_mapFmt.get()); return (groupType == GroupTypeValue::Seq ? m_seqFmt.get() : m_mapFmt.get());
} }
bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope) { bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScopeTypeValue scope) {
switch (value) { switch (value) {
case Auto: case Auto:
case LongKey: case LongKey:
@ -383,7 +383,7 @@ bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope) {
} }
} }
bool EmitterState::SetFloatPrecision(std::size_t value, FmtScope::value scope) { bool EmitterState::SetFloatPrecision(std::size_t value, FmtScopeTypeValue scope) {
if (value > std::numeric_limits<float>::max_digits10) if (value > std::numeric_limits<float>::max_digits10)
return false; return false;
_Set(m_floatPrecision, value, scope); _Set(m_floatPrecision, value, scope);
@ -391,7 +391,7 @@ bool EmitterState::SetFloatPrecision(std::size_t value, FmtScope::value scope) {
} }
bool EmitterState::SetDoublePrecision(std::size_t value, bool EmitterState::SetDoublePrecision(std::size_t value,
FmtScope::value scope) { FmtScopeTypeValue scope) {
if (value > std::numeric_limits<double>::max_digits10) if (value > std::numeric_limits<double>::max_digits10)
return false; return false;
_Set(m_doublePrecision, value, scope); _Set(m_doublePrecision, value, scope);

74
src/emitterstate.h
View File

@ -18,15 +18,9 @@
#include <vector> #include <vector>
namespace YAML { namespace YAML {
struct FmtScope { enum class FlowTypeValue { NoType, Flow, Block };
enum value { Local, Global }; enum class GroupTypeValue { NoType, Seq, Map };
}; enum class FmtScopeTypeValue { Local, Global };
struct GroupType {
enum value { NoType, Seq, Map };
};
struct FlowType {
enum value { NoType, Flow, Block };
};
class EmitterState { class EmitterState {
public: public:
@ -51,14 +45,14 @@ class EmitterState {
void StartedDoc(); void StartedDoc();
void EndedDoc(); void EndedDoc();
void StartedScalar(); void StartedScalar();
void StartedGroup(GroupType::value type); void StartedGroup(GroupTypeValue type);
void EndedGroup(GroupType::value type); void EndedGroup(GroupTypeValue type);
EmitterNodeType::value NextGroupType(GroupType::value type) const; EmitterNodeType::value NextGroupType(GroupTypeValue type) const;
EmitterNodeType::value CurGroupNodeType() const; EmitterNodeType::value CurGroupNodeType() const;
GroupType::value CurGroupType() const; GroupTypeValue CurGroupType() const;
FlowType::value CurGroupFlowType() const; FlowTypeValue CurGroupFlowType() const;
std::size_t CurGroupIndent() const; std::size_t CurGroupIndent() const;
std::size_t CurGroupChildCount() const; std::size_t CurGroupChildCount() const;
bool CurGroupLongKey() const; bool CurGroupLongKey() const;
@ -79,50 +73,50 @@ class EmitterState {
// formatters // formatters
void SetLocalValue(EMITTER_MANIP value); void SetLocalValue(EMITTER_MANIP value);
bool SetOutputCharset(EMITTER_MANIP value, FmtScope::value scope); bool SetOutputCharset(EMITTER_MANIP value, FmtScopeTypeValue scope);
EMITTER_MANIP GetOutputCharset() const { return m_charset.get(); } EMITTER_MANIP GetOutputCharset() const { return m_charset.get(); }
bool SetStringFormat(EMITTER_MANIP value, FmtScope::value scope); bool SetStringFormat(EMITTER_MANIP value, FmtScopeTypeValue scope);
EMITTER_MANIP GetStringFormat() const { return m_strFmt.get(); } EMITTER_MANIP GetStringFormat() const { return m_strFmt.get(); }
bool SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope); bool SetBoolFormat(EMITTER_MANIP value, FmtScopeTypeValue scope);
EMITTER_MANIP GetBoolFormat() const { return m_boolFmt.get(); } EMITTER_MANIP GetBoolFormat() const { return m_boolFmt.get(); }
bool SetBoolLengthFormat(EMITTER_MANIP value, FmtScope::value scope); bool SetBoolLengthFormat(EMITTER_MANIP value, FmtScopeTypeValue scope);
EMITTER_MANIP GetBoolLengthFormat() const { return m_boolLengthFmt.get(); } EMITTER_MANIP GetBoolLengthFormat() const { return m_boolLengthFmt.get(); }
bool SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope); bool SetBoolCaseFormat(EMITTER_MANIP value, FmtScopeTypeValue scope);
EMITTER_MANIP GetBoolCaseFormat() const { return m_boolCaseFmt.get(); } EMITTER_MANIP GetBoolCaseFormat() const { return m_boolCaseFmt.get(); }
bool SetNullFormat(EMITTER_MANIP value, FmtScope::value scope); bool SetNullFormat(EMITTER_MANIP value, FmtScopeTypeValue scope);
EMITTER_MANIP GetNullFormat() const { return m_nullFmt.get(); } EMITTER_MANIP GetNullFormat() const { return m_nullFmt.get(); }
bool SetIntFormat(EMITTER_MANIP value, FmtScope::value scope); bool SetIntFormat(EMITTER_MANIP value, FmtScopeTypeValue scope);
EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); } EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); }
bool SetIndent(std::size_t value, FmtScope::value scope); bool SetIndent(std::size_t value, FmtScopeTypeValue scope);
std::size_t GetIndent() const { return m_indent.get(); } std::size_t GetIndent() const { return m_indent.get(); }
bool SetPreCommentIndent(std::size_t value, FmtScope::value scope); bool SetPreCommentIndent(std::size_t value, FmtScopeTypeValue scope);
std::size_t GetPreCommentIndent() const { return m_preCommentIndent.get(); } std::size_t GetPreCommentIndent() const { return m_preCommentIndent.get(); }
bool SetPostCommentIndent(std::size_t value, FmtScope::value scope); bool SetPostCommentIndent(std::size_t value, FmtScopeTypeValue scope);
std::size_t GetPostCommentIndent() const { return m_postCommentIndent.get(); } std::size_t GetPostCommentIndent() const { return m_postCommentIndent.get(); }
bool SetFlowType(GroupType::value groupType, EMITTER_MANIP value, bool SetFlowType(GroupTypeValue groupType, EMITTER_MANIP value,
FmtScope::value scope); FmtScopeTypeValue scope);
EMITTER_MANIP GetFlowType(GroupType::value groupType) const; EMITTER_MANIP GetFlowType(GroupTypeValue groupType) const;
bool SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope); bool SetMapKeyFormat(EMITTER_MANIP value, FmtScopeTypeValue scope);
EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); } EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); }
bool SetFloatPrecision(std::size_t value, FmtScope::value scope); bool SetFloatPrecision(std::size_t value, FmtScopeTypeValue scope);
std::size_t GetFloatPrecision() const { return m_floatPrecision.get(); } std::size_t GetFloatPrecision() const { return m_floatPrecision.get(); }
bool SetDoublePrecision(std::size_t value, FmtScope::value scope); bool SetDoublePrecision(std::size_t value, FmtScopeTypeValue scope);
std::size_t GetDoublePrecision() const { return m_doublePrecision.get(); } std::size_t GetDoublePrecision() const { return m_doublePrecision.get(); }
private: private:
template <typename T> template <typename T>
void _Set(Setting<T>& fmt, T value, FmtScope::value scope); void _Set(Setting<T>& fmt, T value,FmtScopeTypeValue scope);
void StartedNode(); void StartedNode();
@ -151,7 +145,7 @@ class EmitterState {
SettingChanges m_globalModifiedSettings; SettingChanges m_globalModifiedSettings;
struct Group { struct Group {
explicit Group(GroupType::value type_) explicit Group(GroupTypeValue type_)
: type(type_), : type(type_),
flowType{}, flowType{},
indent(0), indent(0),
@ -159,8 +153,8 @@ class EmitterState {
longKey(false), longKey(false),
modifiedSettings{} {} modifiedSettings{} {}
GroupType::value type; GroupTypeValue type;
FlowType::value flowType; FlowTypeValue flowType;
std::size_t indent; std::size_t indent;
std::size_t childCount; std::size_t childCount;
bool longKey; bool longKey;
@ -168,13 +162,13 @@ class EmitterState {
SettingChanges modifiedSettings; SettingChanges modifiedSettings;
EmitterNodeType::value NodeType() const { EmitterNodeType::value NodeType() const {
if (type == GroupType::Seq) { if (type == GroupTypeValue::Seq) {
if (flowType == FlowType::Flow) if (flowType == FlowTypeValue::Flow)
return EmitterNodeType::FlowSeq; return EmitterNodeType::FlowSeq;
else else
return EmitterNodeType::BlockSeq; return EmitterNodeType::BlockSeq;
} else { } else {
if (flowType == FlowType::Flow) if (flowType == FlowTypeValue::Flow)
return EmitterNodeType::FlowMap; return EmitterNodeType::FlowMap;
else else
return EmitterNodeType::BlockMap; return EmitterNodeType::BlockMap;
@ -196,12 +190,12 @@ class EmitterState {
}; };
template <typename T> template <typename T>
void EmitterState::_Set(Setting<T>& fmt, T value, FmtScope::value scope) { void EmitterState::_Set(Setting<T>& fmt, T value, FmtScopeTypeValue scope) {
switch (scope) { switch (scope) {
case FmtScope::Local: case FmtScopeTypeValue::Local:
m_modifiedSettings.push(fmt.set(value)); m_modifiedSettings.push(fmt.set(value));
break; break;
case FmtScope::Global: case FmtScopeTypeValue::Global:
fmt.set(value); fmt.set(value);
m_globalModifiedSettings.push( m_globalModifiedSettings.push(
fmt.set(value)); // this pushes an identity set, so when we restore, fmt.set(value)); // this pushes an identity set, so when we restore,

14
src/emitterutils.cpp
View File

@ -152,7 +152,7 @@ void WriteCodePoint(ostream_wrapper& out, int codePoint) {
} }
} }
bool IsValidPlainScalar(const std::string& str, FlowType::value flowType, bool IsValidPlainScalar(const std::string& str, FlowTypeValue flowType,
bool allowOnlyAscii) { bool allowOnlyAscii) {
// check against null // check against null
if (IsNullString(str)) { if (IsNullString(str)) {
@ -160,7 +160,7 @@ bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,
} }
// check the start // check the start
const RegEx& start = (flowType == FlowType::Flow ? Exp::PlainScalarInFlow() const RegEx& start = (flowType == FlowTypeValue::Flow ? Exp::PlainScalarInFlow()
: Exp::PlainScalar()); : Exp::PlainScalar());
if (!start.Matches(str)) { if (!start.Matches(str)) {
return false; return false;
@ -182,7 +182,7 @@ bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,
Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() | Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() |
Exp::Tab(); Exp::Tab();
const RegEx& disallowed = const RegEx& disallowed =
flowType == FlowType::Flow ? disallowed_flow : disallowed_block; flowType == FlowTypeValue::Flow ? disallowed_flow : disallowed_block;
StringCharSource buffer(str.c_str(), str.size()); StringCharSource buffer(str.c_str(), str.size());
while (buffer) { while (buffer) {
@ -206,9 +206,9 @@ bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii) {
}); });
} }
bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType, bool IsValidLiteralScalar(const std::string& str, FlowTypeValue flowType,
bool escapeNonAscii) { bool escapeNonAscii) {
if (flowType == FlowType::Flow) { if (flowType == FlowTypeValue::Flow) {
return false; return false;
} }
@ -267,9 +267,9 @@ bool WriteAliasName(ostream_wrapper& out, const std::string& str) {
} }
} // namespace } // namespace
StringFormat::value ComputeStringFormat(const std::string& str, StringFormat ComputeStringFormat(const std::string& str,
EMITTER_MANIP strFormat, EMITTER_MANIP strFormat,
FlowType::value flowType, FlowTypeValue flowType,
bool escapeNonAscii) { bool escapeNonAscii) {
switch (strFormat) { switch (strFormat) {
case Auto: case Auto:

8
src/emitterutils.h
View File

@ -20,8 +20,8 @@ class ostream_wrapper;
namespace YAML { namespace YAML {
class Binary; class Binary;
struct StringFormat { enum class StringFormat {
enum value { Plain, SingleQuoted, DoubleQuoted, Literal }; Plain, SingleQuoted, DoubleQuoted, Literal
}; };
struct StringEscaping { struct StringEscaping {
@ -29,9 +29,9 @@ struct StringEscaping {
}; };
namespace Utils { namespace Utils {
StringFormat::value ComputeStringFormat(const std::string& str, StringFormat ComputeStringFormat(const std::string& str,
EMITTER_MANIP strFormat, EMITTER_MANIP strFormat,
FlowType::value flowType, FlowTypeValue flowType,
bool escapeNonAscii); bool escapeNonAscii);
bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str); bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str);

14
test/CMakeLists.txt
View File

@ -4,12 +4,13 @@ set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
set(BUILD_MOCK ON CACHE BOOL "" FORCE) set(BUILD_MOCK ON CACHE BOOL "" FORCE)
set(CMAKE_POLICY_DEFAULT_CMP0048 NEW) set(CMAKE_POLICY_DEFAULT_CMP0048 NEW)
add_subdirectory( #add_subdirectory(
"${CMAKE_CURRENT_SOURCE_DIR}/gtest-1.10.0" # "${CMAKE_CURRENT_SOURCE_DIR}/gtest-1.10.0"
"${CMAKE_CURRENT_BINARY_DIR}/prefix") # "${CMAKE_CURRENT_BINARY_DIR}/prefix")
#
include_directories(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/gtest-1.10.0/googletest/include") #include_directories(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/gtest-1.10.0/googletest/include")
find_package(GTest REQUIRED)
include_directories(${GTEST_INCLUDE_DIRS})
set(test-new-api-pattern "new-api/*.cpp") set(test-new-api-pattern "new-api/*.cpp")
set(test-source-pattern "*.cpp" "integration/*.cpp" "node/*.cpp") set(test-source-pattern "*.cpp" "integration/*.cpp" "node/*.cpp")
if (CMAKE_VERSION VERSION_GREATER 3.11) if (CMAKE_VERSION VERSION_GREATER 3.11)
@ -45,5 +46,4 @@ if (NOT DEFINED CMAKE_CXX_STANDARD)
set_target_properties(yaml-cpp-tests PROPERTIES CXX_STANDARD 11) set_target_properties(yaml-cpp-tests PROPERTIES CXX_STANDARD 11)
endif() endif()
add_test(yaml-cpp::test yaml-cpp-tests) add_test(yaml-cpp::test yaml-cpp-tests)