yaml-cpp

FORK: A YAML parser and emitter in C++
git clone https://git.neptards.moe/neptards/yaml-cpp.git
Log | Files | Refs | README | LICENSE

emitfromevents.cpp (3116B)

      1 #include <cassert>
      2 #include <sstream>
      3 
      4 #include "yaml-cpp/emitfromevents.h"
      5 #include "yaml-cpp/emitter.h"
      6 #include "yaml-cpp/emittermanip.h"
      7 #include "yaml-cpp/null.h"
      8 
      9 namespace YAML {
     10 struct Mark;
     11 }  // namespace YAML
     12 
     13 namespace {
     14 std::string ToString(YAML::anchor_t anchor) {
     15   std::stringstream stream;
     16   stream << anchor;
     17   return stream.str();
     18 }
     19 }  // namespace
     20 
     21 namespace YAML {
     22 EmitFromEvents::EmitFromEvents(Emitter& emitter)
     23     : m_emitter(emitter), m_stateStack{} {}
     24 
     25 void EmitFromEvents::OnDocumentStart(const Mark&) {}
     26 
     27 void EmitFromEvents::OnDocumentEnd() {}
     28 
     29 void EmitFromEvents::OnNull(const Mark&, anchor_t anchor) {
     30   BeginNode();
     31   EmitProps("", anchor);
     32   m_emitter << Null;
     33 }
     34 
     35 void EmitFromEvents::OnAlias(const Mark&, anchor_t anchor) {
     36   BeginNode();
     37   m_emitter << Alias(ToString(anchor));
     38 }
     39 
     40 void EmitFromEvents::OnScalar(const Mark&, const std::string& tag,
     41                               anchor_t anchor, const std::string& value) {
     42   BeginNode();
     43   EmitProps(tag, anchor);
     44   m_emitter << value;
     45 }
     46 
     47 void EmitFromEvents::OnSequenceStart(const Mark&, const std::string& tag,
     48                                      anchor_t anchor,
     49                                      EmitterStyle::value style) {
     50   BeginNode();
     51   EmitProps(tag, anchor);
     52   switch (style) {
     53     case EmitterStyle::Block:
     54       m_emitter << Block;
     55       break;
     56     case EmitterStyle::Flow:
     57       m_emitter << Flow;
     58       break;
     59     default:
     60       break;
     61   }
     62   // Restore the global settings to eliminate the override from node style
     63   m_emitter.RestoreGlobalModifiedSettings();
     64   m_emitter << BeginSeq;
     65   m_stateStack.push(State::WaitingForSequenceEntry);
     66 }
     67 
     68 void EmitFromEvents::OnSequenceEnd() {
     69   m_emitter << EndSeq;
     70   assert(m_stateStack.top() == State::WaitingForSequenceEntry);
     71   m_stateStack.pop();
     72 }
     73 
     74 void EmitFromEvents::OnMapStart(const Mark&, const std::string& tag,
     75                                 anchor_t anchor, EmitterStyle::value style) {
     76   BeginNode();
     77   EmitProps(tag, anchor);
     78   switch (style) {
     79     case EmitterStyle::Block:
     80       m_emitter << Block;
     81       break;
     82     case EmitterStyle::Flow:
     83       m_emitter << Flow;
     84       break;
     85     default:
     86       break;
     87   }
     88   // Restore the global settings to eliminate the override from node style
     89   m_emitter.RestoreGlobalModifiedSettings();
     90   m_emitter << BeginMap;
     91   m_stateStack.push(State::WaitingForKey);
     92 }
     93 
     94 void EmitFromEvents::OnMapEnd() {
     95   m_emitter << EndMap;
     96   assert(m_stateStack.top() == State::WaitingForKey);
     97   m_stateStack.pop();
     98 }
     99 
    100 void EmitFromEvents::BeginNode() {
    101   if (m_stateStack.empty())
    102     return;
    103 
    104   switch (m_stateStack.top()) {
    105     case State::WaitingForKey:
    106       m_emitter << Key;
    107       m_stateStack.top() = State::WaitingForValue;
    108       break;
    109     case State::WaitingForValue:
    110       m_emitter << Value;
    111       m_stateStack.top() = State::WaitingForKey;
    112       break;
    113     default:
    114       break;
    115   }
    116 }
    117 
    118 void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) {
    119   if (!tag.empty() && tag != "?" && tag != "!")
    120     m_emitter << VerbatimTag(tag);
    121   if (anchor)
    122     m_emitter << Anchor(ToString(anchor));
    123 }
    124 }  // namespace YAML