nifi-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ald...@apache.org
Subject [07/13] nifi-minifi-cpp git commit: MINIFICPP-263: Move merge content to an extension. Also remove circular dependencies
Date Thu, 26 Oct 2017 01:21:10 GMT
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/emitterutils.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/emitterutils.cpp b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/emitterutils.cpp
deleted file mode 100644
index 4a4c982..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/emitterutils.cpp
+++ /dev/null
@@ -1,484 +0,0 @@
-#include <iomanip>
-#include <sstream>
-
-#include "emitterutils.h"
-#include "exp.h"
-#include "indentation.h"
-#include "regex_yaml.h"
-#include "regeximpl.h"
-#include "stringsource.h"
-#include "yaml-cpp/binary.h"  // IWYU pragma: keep
-#include "yaml-cpp/ostream_wrapper.h"
-
-namespace YAML {
-namespace Utils {
-namespace {
-enum { REPLACEMENT_CHARACTER = 0xFFFD };
-
-bool IsAnchorChar(int ch) {  // test for ns-anchor-char
-  switch (ch) {
-    case ',':
-    case '[':
-    case ']':
-    case '{':
-    case '}':  // c-flow-indicator
-    case ' ':
-    case '\t':    // s-white
-    case 0xFEFF:  // c-byte-order-mark
-    case 0xA:
-    case 0xD:  // b-char
-      return false;
-    case 0x85:
-      return true;
-  }
-
-  if (ch < 0x20) {
-    return false;
-  }
-
-  if (ch < 0x7E) {
-    return true;
-  }
-
-  if (ch < 0xA0) {
-    return false;
-  }
-  if (ch >= 0xD800 && ch <= 0xDFFF) {
-    return false;
-  }
-  if ((ch & 0xFFFE) == 0xFFFE) {
-    return false;
-  }
-  if ((ch >= 0xFDD0) && (ch <= 0xFDEF)) {
-    return false;
-  }
-  if (ch > 0x10FFFF) {
-    return false;
-  }
-
-  return true;
-}
-
-int Utf8BytesIndicated(char ch) {
-  int byteVal = static_cast<unsigned char>(ch);
-  switch (byteVal >> 4) {
-    case 0:
-    case 1:
-    case 2:
-    case 3:
-    case 4:
-    case 5:
-    case 6:
-    case 7:
-      return 1;
-    case 12:
-    case 13:
-      return 2;
-    case 14:
-      return 3;
-    case 15:
-      return 4;
-    default:
-      return -1;
-  }
-}
-
-bool IsTrailingByte(char ch) { return (ch & 0xC0) == 0x80; }
-
-bool GetNextCodePointAndAdvance(int& codePoint,
-                                std::string::const_iterator& first,
-                                std::string::const_iterator last) {
-  if (first == last)
-    return false;
-
-  int nBytes = Utf8BytesIndicated(*first);
-  if (nBytes < 1) {
-    // Bad lead byte
-    ++first;
-    codePoint = REPLACEMENT_CHARACTER;
-    return true;
-  }
-
-  if (nBytes == 1) {
-    codePoint = *first++;
-    return true;
-  }
-
-  // Gather bits from trailing bytes
-  codePoint = static_cast<unsigned char>(*first) & ~(0xFF << (7 - nBytes));
-  ++first;
-  --nBytes;
-  for (; nBytes > 0; ++first, --nBytes) {
-    if ((first == last) || !IsTrailingByte(*first)) {
-      codePoint = REPLACEMENT_CHARACTER;
-      break;
-    }
-    codePoint <<= 6;
-    codePoint |= *first & 0x3F;
-  }
-
-  // Check for illegal code points
-  if (codePoint > 0x10FFFF)
-    codePoint = REPLACEMENT_CHARACTER;
-  else if (codePoint >= 0xD800 && codePoint <= 0xDFFF)
-    codePoint = REPLACEMENT_CHARACTER;
-  else if ((codePoint & 0xFFFE) == 0xFFFE)
-    codePoint = REPLACEMENT_CHARACTER;
-  else if (codePoint >= 0xFDD0 && codePoint <= 0xFDEF)
-    codePoint = REPLACEMENT_CHARACTER;
-  return true;
-}
-
-void WriteCodePoint(ostream_wrapper& out, int codePoint) {
-  if (codePoint < 0 || codePoint > 0x10FFFF) {
-    codePoint = REPLACEMENT_CHARACTER;
-  }
-  if (codePoint < 0x7F) {
-    out << static_cast<char>(codePoint);
-  } else if (codePoint < 0x7FF) {
-    out << static_cast<char>(0xC0 | (codePoint >> 6))
-        << static_cast<char>(0x80 | (codePoint & 0x3F));
-  } else if (codePoint < 0xFFFF) {
-    out << static_cast<char>(0xE0 | (codePoint >> 12))
-        << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F))
-        << static_cast<char>(0x80 | (codePoint & 0x3F));
-  } else {
-    out << static_cast<char>(0xF0 | (codePoint >> 18))
-        << static_cast<char>(0x80 | ((codePoint >> 12) & 0x3F))
-        << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F))
-        << static_cast<char>(0x80 | (codePoint & 0x3F));
-  }
-}
-
-bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,
-                        bool allowOnlyAscii) {
-  if (str.empty()) {
-    return false;
-  }
-
-  // check against null
-  if (str == "null") {
-    return false;
-  }
-
-  // check the start
-  const RegEx& start = (flowType == FlowType::Flow ? Exp::PlainScalarInFlow()
-                                                   : Exp::PlainScalar());
-  if (!start.Matches(str)) {
-    return false;
-  }
-
-  // and check the end for plain whitespace (which can't be faithfully kept in a
-  // plain scalar)
-  if (!str.empty() && *str.rbegin() == ' ') {
-    return false;
-  }
-
-  // then check until something is disallowed
-  static const RegEx& disallowed_flow =
-      Exp::EndScalarInFlow() || (Exp::BlankOrBreak() + Exp::Comment()) ||
-      Exp::NotPrintable() || Exp::Utf8_ByteOrderMark() || Exp::Break() ||
-      Exp::Tab();
-  static const RegEx& disallowed_block =
-      Exp::EndScalar() || (Exp::BlankOrBreak() + Exp::Comment()) ||
-      Exp::NotPrintable() || Exp::Utf8_ByteOrderMark() || Exp::Break() ||
-      Exp::Tab();
-  const RegEx& disallowed =
-      flowType == FlowType::Flow ? disallowed_flow : disallowed_block;
-
-  StringCharSource buffer(str.c_str(), str.size());
-  while (buffer) {
-    if (disallowed.Matches(buffer)) {
-      return false;
-    }
-    if (allowOnlyAscii && (0x80 <= static_cast<unsigned char>(buffer[0]))) {
-      return false;
-    }
-    ++buffer;
-  }
-
-  return true;
-}
-
-bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii) {
-  // TODO: check for non-printable characters?
-  for (std::size_t i = 0; i < str.size(); i++) {
-    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) {
-      return false;
-    }
-    if (str[i] == '\n') {
-      return false;
-    }
-  }
-  return true;
-}
-
-bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType,
-                          bool escapeNonAscii) {
-  if (flowType == FlowType::Flow) {
-    return false;
-  }
-
-  // TODO: check for non-printable characters?
-  for (std::size_t i = 0; i < str.size(); i++) {
-    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) {
-      return false;
-    }
-  }
-  return true;
-}
-
-void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint) {
-  static const char hexDigits[] = "0123456789abcdef";
-
-  out << "\\";
-  int digits = 8;
-  if (codePoint < 0xFF) {
-    out << "x";
-    digits = 2;
-  } else if (codePoint < 0xFFFF) {
-    out << "u";
-    digits = 4;
-  } else {
-    out << "U";
-    digits = 8;
-  }
-
-  // Write digits into the escape sequence
-  for (; digits > 0; --digits)
-    out << hexDigits[(codePoint >> (4 * (digits - 1))) & 0xF];
-}
-
-bool WriteAliasName(ostream_wrapper& out, const std::string& str) {
-  int codePoint;
-  for (std::string::const_iterator i = str.begin();
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
-    if (!IsAnchorChar(codePoint)) {
-      return false;
-    }
-
-    WriteCodePoint(out, codePoint);
-  }
-  return true;
-}
-}
-
-StringFormat::value ComputeStringFormat(const std::string& str,
-                                        EMITTER_MANIP strFormat,
-                                        FlowType::value flowType,
-                                        bool escapeNonAscii) {
-  switch (strFormat) {
-    case Auto:
-      if (IsValidPlainScalar(str, flowType, escapeNonAscii)) {
-        return StringFormat::Plain;
-      }
-      return StringFormat::DoubleQuoted;
-    case SingleQuoted:
-      if (IsValidSingleQuotedScalar(str, escapeNonAscii)) {
-        return StringFormat::SingleQuoted;
-      }
-      return StringFormat::DoubleQuoted;
-    case DoubleQuoted:
-      return StringFormat::DoubleQuoted;
-    case Literal:
-      if (IsValidLiteralScalar(str, flowType, escapeNonAscii)) {
-        return StringFormat::Literal;
-      }
-      return StringFormat::DoubleQuoted;
-    default:
-      break;
-  }
-
-  return StringFormat::DoubleQuoted;
-}
-
-bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str) {
-  out << "'";
-  int codePoint;
-  for (std::string::const_iterator i = str.begin();
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
-    if (codePoint == '\n') {
-      return false;  // We can't handle a new line and the attendant indentation
-                     // yet
-    }
-
-    if (codePoint == '\'') {
-      out << "''";
-    } else {
-      WriteCodePoint(out, codePoint);
-    }
-  }
-  out << "'";
-  return true;
-}
-
-bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
-                             bool escapeNonAscii) {
-  out << "\"";
-  int codePoint;
-  for (std::string::const_iterator i = str.begin();
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
-    switch (codePoint) {
-      case '\"':
-        out << "\\\"";
-        break;
-      case '\\':
-        out << "\\\\";
-        break;
-      case '\n':
-        out << "\\n";
-        break;
-      case '\t':
-        out << "\\t";
-        break;
-      case '\r':
-        out << "\\r";
-        break;
-      case '\b':
-        out << "\\b";
-        break;
-      default:
-        if (codePoint < 0x20 ||
-            (codePoint >= 0x80 &&
-             codePoint <= 0xA0)) {  // Control characters and non-breaking space
-          WriteDoubleQuoteEscapeSequence(out, codePoint);
-        } else if (codePoint == 0xFEFF) {  // Byte order marks (ZWNS) should be
-                                           // escaped (YAML 1.2, sec. 5.2)
-          WriteDoubleQuoteEscapeSequence(out, codePoint);
-        } else if (escapeNonAscii && codePoint > 0x7E) {
-          WriteDoubleQuoteEscapeSequence(out, codePoint);
-        } else {
-          WriteCodePoint(out, codePoint);
-        }
-    }
-  }
-  out << "\"";
-  return true;
-}
-
-bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
-                        int indent) {
-  out << "|\n";
-  out << IndentTo(indent);
-  int codePoint;
-  for (std::string::const_iterator i = str.begin();
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
-    if (codePoint == '\n') {
-      out << "\n" << IndentTo(indent);
-    } else {
-      WriteCodePoint(out, codePoint);
-    }
-  }
-  return true;
-}
-
-bool WriteChar(ostream_wrapper& out, char ch) {
-  if (('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z')) {
-    out << ch;
-  } else if (ch == '\"') {
-    out << "\"\\\"\"";
-  } else if (ch == '\t') {
-    out << "\"\\t\"";
-  } else if (ch == '\n') {
-    out << "\"\\n\"";
-  } else if (ch == '\b') {
-    out << "\"\\b\"";
-  } else if ((0x20 <= ch && ch <= 0x7e) || ch == ' ') {
-    out << "\"" << ch << "\"";
-  } else {
-    out << "\"";
-    WriteDoubleQuoteEscapeSequence(out, ch);
-    out << "\"";
-  }
-  return true;
-}
-
-bool WriteComment(ostream_wrapper& out, const std::string& str,
-                  int postCommentIndent) {
-  const std::size_t curIndent = out.col();
-  out << "#" << Indentation(postCommentIndent);
-  out.set_comment();
-  int codePoint;
-  for (std::string::const_iterator i = str.begin();
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
-    if (codePoint == '\n') {
-      out << "\n" << IndentTo(curIndent) << "#"
-          << Indentation(postCommentIndent);
-      out.set_comment();
-    } else {
-      WriteCodePoint(out, codePoint);
-    }
-  }
-  return true;
-}
-
-bool WriteAlias(ostream_wrapper& out, const std::string& str) {
-  out << "*";
-  return WriteAliasName(out, str);
-}
-
-bool WriteAnchor(ostream_wrapper& out, const std::string& str) {
-  out << "&";
-  return WriteAliasName(out, str);
-}
-
-bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim) {
-  out << (verbatim ? "!<" : "!");
-  StringCharSource buffer(str.c_str(), str.size());
-  const RegEx& reValid = verbatim ? Exp::URI() : Exp::Tag();
-  while (buffer) {
-    int n = reValid.Match(buffer);
-    if (n <= 0) {
-      return false;
-    }
-
-    while (--n >= 0) {
-      out << buffer[0];
-      ++buffer;
-    }
-  }
-  if (verbatim) {
-    out << ">";
-  }
-  return true;
-}
-
-bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix,
-                        const std::string& tag) {
-  out << "!";
-  StringCharSource prefixBuffer(prefix.c_str(), prefix.size());
-  while (prefixBuffer) {
-    int n = Exp::URI().Match(prefixBuffer);
-    if (n <= 0) {
-      return false;
-    }
-
-    while (--n >= 0) {
-      out << prefixBuffer[0];
-      ++prefixBuffer;
-    }
-  }
-
-  out << "!";
-  StringCharSource tagBuffer(tag.c_str(), tag.size());
-  while (tagBuffer) {
-    int n = Exp::Tag().Match(tagBuffer);
-    if (n <= 0) {
-      return false;
-    }
-
-    while (--n >= 0) {
-      out << tagBuffer[0];
-      ++tagBuffer;
-    }
-  }
-  return true;
-}
-
-bool WriteBinary(ostream_wrapper& out, const Binary& binary) {
-  WriteDoubleQuotedString(out, EncodeBase64(binary.data(), binary.size()),
-                          false);
-  return true;
-}
-}
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/emitterutils.h
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/emitterutils.h b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/emitterutils.h
deleted file mode 100644
index 3a9c2f8..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/emitterutils.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef 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
-#pragma once
-#endif
-
-#include <string>
-
-#include "emitterstate.h"
-#include "yaml-cpp/emittermanip.h"
-#include "yaml-cpp/ostream_wrapper.h"
-
-namespace YAML {
-class ostream_wrapper;
-}  // namespace YAML
-
-namespace YAML {
-class Binary;
-
-struct StringFormat {
-  enum value { Plain, SingleQuoted, DoubleQuoted, Literal };
-};
-
-namespace Utils {
-StringFormat::value ComputeStringFormat(const std::string& str,
-                                        EMITTER_MANIP strFormat,
-                                        FlowType::value flowType,
-                                        bool escapeNonAscii);
-
-bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str);
-bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
-                             bool escapeNonAscii);
-bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
-                        int indent);
-bool WriteChar(ostream_wrapper& out, char ch);
-bool WriteComment(ostream_wrapper& out, const std::string& str,
-                  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

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/exp.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/exp.cpp b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/exp.cpp
deleted file mode 100644
index 695440a..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/exp.cpp
+++ /dev/null
@@ -1,136 +0,0 @@
-#include <sstream>
-
-#include "exp.h"
-#include "stream.h"
-#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
-
-namespace YAML {
-struct Mark;
-}  // namespace YAML
-
-namespace YAML {
-namespace Exp {
-unsigned ParseHex(const std::string& str, const Mark& mark) {
-  unsigned value = 0;
-  for (std::size_t i = 0; i < str.size(); i++) {
-    char ch = str[i];
-    int digit = 0;
-    if ('a' <= ch && ch <= 'f')
-      digit = ch - 'a' + 10;
-    else if ('A' <= ch && ch <= 'F')
-      digit = ch - 'A' + 10;
-    else if ('0' <= ch && ch <= '9')
-      digit = ch - '0';
-    else
-      throw ParserException(mark, ErrorMsg::INVALID_HEX);
-
-    value = (value << 4) + digit;
-  }
-
-  return value;
-}
-
-std::string Str(unsigned ch) { return std::string(1, static_cast<char>(ch)); }
-
-// Escape
-// . Translates the next 'codeLength' characters into a hex number and returns
-// the result.
-// . Throws if it's not actually hex.
-std::string Escape(Stream& in, int codeLength) {
-  // grab string
-  std::string str;
-  for (int i = 0; i < codeLength; i++)
-    str += in.get();
-
-  // get the value
-  unsigned value = ParseHex(str, in.mark());
-
-  // legal unicode?
-  if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) {
-    std::stringstream msg;
-    msg << ErrorMsg::INVALID_UNICODE << value;
-    throw ParserException(in.mark(), msg.str());
-  }
-
-  // now break it up into chars
-  if (value <= 0x7F)
-    return Str(value);
-  else if (value <= 0x7FF)
-    return Str(0xC0 + (value >> 6)) + Str(0x80 + (value & 0x3F));
-  else if (value <= 0xFFFF)
-    return Str(0xE0 + (value >> 12)) + Str(0x80 + ((value >> 6) & 0x3F)) +
-           Str(0x80 + (value & 0x3F));
-  else
-    return Str(0xF0 + (value >> 18)) + Str(0x80 + ((value >> 12) & 0x3F)) +
-           Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F));
-}
-
-// Escape
-// . Escapes the sequence starting 'in' (it must begin with a '\' or single
-// quote)
-//   and returns the result.
-// . Throws if it's an unknown escape character.
-std::string Escape(Stream& in) {
-  // eat slash
-  char escape = in.get();
-
-  // switch on escape character
-  char ch = in.get();
-
-  // first do single quote, since it's easier
-  if (escape == '\'' && ch == '\'')
-    return "\'";
-
-  // now do the slash (we're not gonna check if it's a slash - you better pass
-  // one!)
-  switch (ch) {
-    case '0':
-      return std::string(1, '\x00');
-    case 'a':
-      return "\x07";
-    case 'b':
-      return "\x08";
-    case 't':
-    case '\t':
-      return "\x09";
-    case 'n':
-      return "\x0A";
-    case 'v':
-      return "\x0B";
-    case 'f':
-      return "\x0C";
-    case 'r':
-      return "\x0D";
-    case 'e':
-      return "\x1B";
-    case ' ':
-      return "\x20";
-    case '\"':
-      return "\"";
-    case '\'':
-      return "\'";
-    case '\\':
-      return "\\";
-    case '/':
-      return "/";
-    case 'N':
-      return "\x85";
-    case '_':
-      return "\xA0";
-    case 'L':
-      return "\xE2\x80\xA8";  // LS (#x2028)
-    case 'P':
-      return "\xE2\x80\xA9";  // PS (#x2029)
-    case 'x':
-      return Escape(in, 2);
-    case 'u':
-      return Escape(in, 4);
-    case 'U':
-      return Escape(in, 8);
-  }
-
-  std::stringstream msg;
-  throw ParserException(in.mark(), std::string(ErrorMsg::INVALID_ESCAPE) + ch);
-}
-}
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/exp.h
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/exp.h b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/exp.h
deleted file mode 100644
index f248802..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/exp.h
+++ /dev/null
@@ -1,209 +0,0 @@
-#ifndef EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define EXP_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 <ios>
-#include <string>
-
-#include "regex_yaml.h"
-#include "stream.h"
-
-namespace YAML {
-////////////////////////////////////////////////////////////////////////////////
-// Here we store a bunch of expressions for matching different parts of the
-// file.
-
-namespace Exp {
-// misc
-inline const RegEx& Space() {
-  static const RegEx e = RegEx(' ');
-  return e;
-}
-inline const RegEx& Tab() {
-  static const RegEx e = RegEx('\t');
-  return e;
-}
-inline const RegEx& Blank() {
-  static const RegEx e = Space() || Tab();
-  return e;
-}
-inline const RegEx& Break() {
-  static const RegEx e = RegEx('\n') || RegEx("\r\n");
-  return e;
-}
-inline const RegEx& BlankOrBreak() {
-  static const RegEx e = Blank() || Break();
-  return e;
-}
-inline const RegEx& Digit() {
-  static const RegEx e = RegEx('0', '9');
-  return e;
-}
-inline const RegEx& Alpha() {
-  static const RegEx e = RegEx('a', 'z') || RegEx('A', 'Z');
-  return e;
-}
-inline const RegEx& AlphaNumeric() {
-  static const RegEx e = Alpha() || Digit();
-  return e;
-}
-inline const RegEx& Word() {
-  static const RegEx e = AlphaNumeric() || RegEx('-');
-  return e;
-}
-inline const RegEx& Hex() {
-  static const RegEx e = Digit() || RegEx('A', 'F') || RegEx('a', 'f');
-  return e;
-}
-// Valid Unicode code points that are not part of c-printable (YAML 1.2, sec.
-// 5.1)
-inline const RegEx& NotPrintable() {
-  static const RegEx e =
-      RegEx(0) ||
-      RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) ||
-      RegEx(0x0E, 0x1F) ||
-      (RegEx('\xC2') + (RegEx('\x80', '\x84') || RegEx('\x86', '\x9F')));
-  return e;
-}
-inline const RegEx& Utf8_ByteOrderMark() {
-  static const RegEx e = RegEx("\xEF\xBB\xBF");
-  return e;
-}
-
-// actual tags
-
-inline const RegEx& DocStart() {
-  static const RegEx e = RegEx("---") + (BlankOrBreak() || RegEx());
-  return e;
-}
-inline const RegEx& DocEnd() {
-  static const RegEx e = RegEx("...") + (BlankOrBreak() || RegEx());
-  return e;
-}
-inline const RegEx& DocIndicator() {
-  static const RegEx e = DocStart() || DocEnd();
-  return e;
-}
-inline const RegEx& BlockEntry() {
-  static const RegEx e = RegEx('-') + (BlankOrBreak() || RegEx());
-  return e;
-}
-inline const RegEx& Key() {
-  static const RegEx e = RegEx('?') + BlankOrBreak();
-  return e;
-}
-inline const RegEx& KeyInFlow() {
-  static const RegEx e = RegEx('?') + BlankOrBreak();
-  return e;
-}
-inline const RegEx& Value() {
-  static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx());
-  return e;
-}
-inline const RegEx& ValueInFlow() {
-  static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx(",}", REGEX_OR));
-  return e;
-}
-inline const RegEx& ValueInJSONFlow() {
-  static const RegEx e = RegEx(':');
-  return e;
-}
-inline const RegEx Comment() {
-  static const RegEx e = RegEx('#');
-  return e;
-}
-inline const RegEx& Anchor() {
-  static const RegEx e = !(RegEx("[]{},", REGEX_OR) || BlankOrBreak());
-  return e;
-}
-inline const RegEx& AnchorEnd() {
-  static const RegEx e = RegEx("?:,]}%@`", REGEX_OR) || BlankOrBreak();
-  return e;
-}
-inline const RegEx& URI() {
-  static const RegEx e = Word() || RegEx("#;/?:@&=+$,_.!~*'()[]", REGEX_OR) ||
-                         (RegEx('%') + Hex() + Hex());
-  return e;
-}
-inline const RegEx& Tag() {
-  static const RegEx e = Word() || RegEx("#;/?:@&=+$_.~*'", REGEX_OR) ||
-                         (RegEx('%') + Hex() + Hex());
-  return e;
-}
-
-// Plain scalar rules:
-// . Cannot start with a blank.
-// . Can never start with any of , [ ] { } # & * ! | > \' \" % @ `
-// . In the block context - ? : must be not be followed with a space.
-// . In the flow context ? is illegal and : and - must not be followed with a
-// space.
-inline const RegEx& PlainScalar() {
-  static const RegEx e =
-      !(BlankOrBreak() || RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) ||
-        (RegEx("-?:", REGEX_OR) + (BlankOrBreak() || RegEx())));
-  return e;
-}
-inline const RegEx& PlainScalarInFlow() {
-  static const RegEx e =
-      !(BlankOrBreak() || RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) ||
-        (RegEx("-:", REGEX_OR) + Blank()));
-  return e;
-}
-inline const RegEx& EndScalar() {
-  static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx());
-  return e;
-}
-inline const RegEx& EndScalarInFlow() {
-  static const RegEx e =
-      (RegEx(':') + (BlankOrBreak() || RegEx() || RegEx(",]}", REGEX_OR))) ||
-      RegEx(",?[]{}", REGEX_OR);
-  return e;
-}
-
-inline const RegEx& EscSingleQuote() {
-  static const RegEx e = RegEx("\'\'");
-  return e;
-}
-inline const RegEx& EscBreak() {
-  static const RegEx e = RegEx('\\') + Break();
-  return e;
-}
-
-inline const RegEx& ChompIndicator() {
-  static const RegEx e = RegEx("+-", REGEX_OR);
-  return e;
-}
-inline const RegEx& Chomp() {
-  static const RegEx e = (ChompIndicator() + Digit()) ||
-                         (Digit() + ChompIndicator()) || ChompIndicator() ||
-                         Digit();
-  return e;
-}
-
-// and some functions
-std::string Escape(Stream& in);
-}
-
-namespace Keys {
-const char Directive = '%';
-const char FlowSeqStart = '[';
-const char FlowSeqEnd = ']';
-const char FlowMapStart = '{';
-const char FlowMapEnd = '}';
-const char FlowEntry = ',';
-const char Alias = '*';
-const char Anchor = '&';
-const char Tag = '!';
-const char LiteralScalar = '|';
-const char FoldedScalar = '>';
-const char VerbatimTagStart = '<';
-const char VerbatimTagEnd = '>';
-}
-}
-
-#endif  // EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/indentation.h
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/indentation.h b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/indentation.h
deleted file mode 100644
index 1a2ccae..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/indentation.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define INDENTATION_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 <iostream>
-#include <cstddef>
-
-#include "yaml-cpp/ostream_wrapper.h"
-
-namespace YAML {
-struct Indentation {
-  Indentation(std::size_t n_) : n(n_) {}
-  std::size_t n;
-};
-
-inline ostream_wrapper& operator<<(ostream_wrapper& out,
-                                   const Indentation& indent) {
-  for (std::size_t i = 0; i < indent.n; i++)
-    out << ' ';
-  return out;
-}
-
-struct IndentTo {
-  IndentTo(std::size_t n_) : n(n_) {}
-  std::size_t n;
-};
-
-inline ostream_wrapper& operator<<(ostream_wrapper& out,
-                                   const IndentTo& indent) {
-  while (out.col() < indent.n)
-    out << ' ';
-  return out;
-}
-}
-
-#endif  // INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/memory.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/memory.cpp b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/memory.cpp
deleted file mode 100644
index e5f8a9d..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/memory.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "yaml-cpp/node/detail/memory.h"
-#include "yaml-cpp/node/detail/node.h"  // IWYU pragma: keep
-#include "yaml-cpp/node/ptr.h"
-
-namespace YAML {
-namespace detail {
-
-void memory_holder::merge(memory_holder& rhs) {
-  if (m_pMemory == rhs.m_pMemory)
-    return;
-
-  m_pMemory->merge(*rhs.m_pMemory);
-  rhs.m_pMemory = m_pMemory;
-}
-
-node& memory::create_node() {
-  shared_node pNode(new node);
-  m_nodes.insert(pNode);
-  return *pNode;
-}
-
-void memory::merge(const memory& rhs) {
-  m_nodes.insert(rhs.m_nodes.begin(), rhs.m_nodes.end());
-}
-}
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/node.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/node.cpp b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/node.cpp
deleted file mode 100644
index 2088e13..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/node.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "yaml-cpp/node/node.h"
-#include "nodebuilder.h"
-#include "nodeevents.h"
-
-namespace YAML {
-Node Clone(const Node& node) {
-  NodeEvents events(node);
-  NodeBuilder builder;
-  events.Emit(builder);
-  return builder.Root();
-}
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/node_data.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/node_data.cpp b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/node_data.cpp
deleted file mode 100644
index a1ca900..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/node_data.cpp
+++ /dev/null
@@ -1,301 +0,0 @@
-#include <assert.h>
-#include <boost/smart_ptr/shared_ptr.hpp>
-#include <sstream>
-
-#include "yaml-cpp/exceptions.h"
-#include "yaml-cpp/node/detail/memory.h"
-#include "yaml-cpp/node/detail/node.h"  // IWYU pragma: keep
-#include "yaml-cpp/node/detail/node_data.h"
-#include "yaml-cpp/node/detail/node_iterator.h"
-#include "yaml-cpp/node/ptr.h"
-#include "yaml-cpp/node/type.h"
-
-namespace YAML {
-namespace detail {
-
-std::string node_data::empty_scalar;
-
-node_data::node_data()
-    : m_isDefined(false),
-      m_mark(Mark::null_mark()),
-      m_type(NodeType::Null),
-      m_style(EmitterStyle::Default),
-      m_seqSize(0) {}
-
-void node_data::mark_defined() {
-  if (m_type == NodeType::Undefined)
-    m_type = NodeType::Null;
-  m_isDefined = true;
-}
-
-void node_data::set_mark(const Mark& mark) {
-  m_mark = mark;
-}
-
-void node_data::set_type(NodeType::value type) {
-  if (type == NodeType::Undefined) {
-    m_type = type;
-    m_isDefined = false;
-    return;
-  }
-
-  m_isDefined = true;
-  if (type == m_type)
-    return;
-
-  m_type = type;
-
-  switch (m_type) {
-    case NodeType::Null:
-      break;
-    case NodeType::Scalar:
-      m_scalar.clear();
-      break;
-    case NodeType::Sequence:
-      reset_sequence();
-      break;
-    case NodeType::Map:
-      reset_map();
-      break;
-    case NodeType::Undefined:
-      assert(false);
-      break;
-  }
-}
-
-void node_data::set_tag(const std::string& tag) { m_tag = tag; }
-
-void node_data::set_style(EmitterStyle::value style) { m_style = style; }
-
-void node_data::set_null() {
-  m_isDefined = true;
-  m_type = NodeType::Null;
-}
-
-void node_data::set_scalar(const std::string& scalar) {
-  m_isDefined = true;
-  m_type = NodeType::Scalar;
-  m_scalar = scalar;
-}
-
-// size/iterator
-std::size_t node_data::size() const {
-  if (!m_isDefined)
-    return 0;
-
-  switch (m_type) {
-    case NodeType::Sequence:
-      compute_seq_size();
-      return m_seqSize;
-    case NodeType::Map:
-      compute_map_size();
-      return m_map.size() - m_undefinedPairs.size();
-    default:
-      return 0;
-  }
-  return 0;
-}
-
-void node_data::compute_seq_size() const {
-  while (m_seqSize < m_sequence.size() && m_sequence[m_seqSize]->is_defined())
-    m_seqSize++;
-}
-
-void node_data::compute_map_size() const {
-  kv_pairs::iterator it = m_undefinedPairs.begin();
-  while (it != m_undefinedPairs.end()) {
-    kv_pairs::iterator jt = boost::next(it);
-    if (it->first->is_defined() && it->second->is_defined())
-      m_undefinedPairs.erase(it);
-    it = jt;
-  }
-}
-
-const_node_iterator node_data::begin() const {
-  if (!m_isDefined)
-    return const_node_iterator();
-
-  switch (m_type) {
-    case NodeType::Sequence:
-      return const_node_iterator(m_sequence.begin());
-    case NodeType::Map:
-      return const_node_iterator(m_map.begin(), m_map.end());
-    default:
-      return const_node_iterator();
-  }
-}
-
-node_iterator node_data::begin() {
-  if (!m_isDefined)
-    return node_iterator();
-
-  switch (m_type) {
-    case NodeType::Sequence:
-      return node_iterator(m_sequence.begin());
-    case NodeType::Map:
-      return node_iterator(m_map.begin(), m_map.end());
-    default:
-      return node_iterator();
-  }
-}
-
-const_node_iterator node_data::end() const {
-  if (!m_isDefined)
-    return const_node_iterator();
-
-  switch (m_type) {
-    case NodeType::Sequence:
-      return const_node_iterator(m_sequence.end());
-    case NodeType::Map:
-      return const_node_iterator(m_map.end(), m_map.end());
-    default:
-      return const_node_iterator();
-  }
-}
-
-node_iterator node_data::end() {
-  if (!m_isDefined)
-    return node_iterator();
-
-  switch (m_type) {
-    case NodeType::Sequence:
-      return node_iterator(m_sequence.end());
-    case NodeType::Map:
-      return node_iterator(m_map.end(), m_map.end());
-    default:
-      return node_iterator();
-  }
-}
-
-// sequence
-void node_data::push_back(node& node, shared_memory_holder /* pMemory */) {
-  if (m_type == NodeType::Undefined || m_type == NodeType::Null) {
-    m_type = NodeType::Sequence;
-    reset_sequence();
-  }
-
-  if (m_type != NodeType::Sequence)
-    throw BadPushback();
-
-  m_sequence.push_back(&node);
-}
-
-void node_data::insert(node& key, node& value, shared_memory_holder pMemory) {
-  switch (m_type) {
-    case NodeType::Map:
-      break;
-    case NodeType::Undefined:
-    case NodeType::Null:
-    case NodeType::Sequence:
-      convert_to_map(pMemory);
-      break;
-    case NodeType::Scalar:
-      throw BadSubscript();
-  }
-
-  insert_map_pair(key, value);
-}
-
-// indexing
-node* node_data::get(node& key, shared_memory_holder /* pMemory */) const {
-  if (m_type != NodeType::Map) {
-    return NULL;
-  }
-
-  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    if (it->first->is(key))
-      return it->second;
-  }
-
-  return NULL;
-}
-
-node& node_data::get(node& key, shared_memory_holder pMemory) {
-  switch (m_type) {
-    case NodeType::Map:
-      break;
-    case NodeType::Undefined:
-    case NodeType::Null:
-    case NodeType::Sequence:
-      convert_to_map(pMemory);
-      break;
-    case NodeType::Scalar:
-      throw BadSubscript();
-  }
-
-  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    if (it->first->is(key))
-      return *it->second;
-  }
-
-  node& value = pMemory->create_node();
-  insert_map_pair(key, value);
-  return value;
-}
-
-bool node_data::remove(node& key, shared_memory_holder /* pMemory */) {
-  if (m_type != NodeType::Map)
-    return false;
-
-  for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    if (it->first->is(key)) {
-      m_map.erase(it);
-      return true;
-    }
-  }
-
-  return false;
-}
-
-void node_data::reset_sequence() {
-  m_sequence.clear();
-  m_seqSize = 0;
-}
-
-void node_data::reset_map() {
-  m_map.clear();
-  m_undefinedPairs.clear();
-}
-
-void node_data::insert_map_pair(node& key, node& value) {
-  m_map[&key] = &value;
-  if (!key.is_defined() || !value.is_defined())
-    m_undefinedPairs.push_back(kv_pair(&key, &value));
-}
-
-void node_data::convert_to_map(shared_memory_holder pMemory) {
-  switch (m_type) {
-    case NodeType::Undefined:
-    case NodeType::Null:
-      reset_map();
-      m_type = NodeType::Map;
-      break;
-    case NodeType::Sequence:
-      convert_sequence_to_map(pMemory);
-      break;
-    case NodeType::Map:
-      break;
-    case NodeType::Scalar:
-      assert(false);
-      break;
-  }
-}
-
-void node_data::convert_sequence_to_map(shared_memory_holder pMemory) {
-  assert(m_type == NodeType::Sequence);
-
-  reset_map();
-  for (std::size_t i = 0; i < m_sequence.size(); i++) {
-    std::stringstream stream;
-    stream << i;
-
-    node& key = pMemory->create_node();
-    key.set_scalar(stream.str());
-    insert_map_pair(key, *m_sequence[i]);
-  }
-
-  reset_sequence();
-  m_type = NodeType::Map;
-}
-}
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodebuilder.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodebuilder.cpp b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodebuilder.cpp
deleted file mode 100644
index 20ec3ac..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodebuilder.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-#include <assert.h>
-#include <cassert>
-
-#include "nodebuilder.h"
-#include "yaml-cpp/node/detail/node.h"
-#include "yaml-cpp/node/impl.h"
-#include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/type.h"
-
-namespace YAML {
-struct Mark;
-
-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
-}
-
-NodeBuilder::~NodeBuilder() {}
-
-Node NodeBuilder::Root() {
-  if (!m_pRoot)
-    return Node();
-
-  return Node(*m_pRoot, m_pMemory);
-}
-
-void NodeBuilder::OnDocumentStart(const Mark&) {}
-
-void NodeBuilder::OnDocumentEnd() {}
-
-void NodeBuilder::OnNull(const Mark& mark, anchor_t anchor) {
-  detail::node& node = Push(mark, anchor);
-  node.set_null();
-  Pop();
-}
-
-void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor) {
-  detail::node& node = *m_anchors[anchor];
-  Push(node);
-  Pop();
-}
-
-void NodeBuilder::OnScalar(const Mark& mark, const std::string& tag,
-                           anchor_t anchor, const std::string& value) {
-  detail::node& node = Push(mark, anchor);
-  node.set_scalar(value);
-  node.set_tag(tag);
-  Pop();
-}
-
-void NodeBuilder::OnSequenceStart(const Mark& mark,
-                                  const std::string& tag, anchor_t anchor,
-                                  EmitterStyle::value style) {
-  detail::node& node = Push(mark, anchor);
-  node.set_tag(tag);
-  node.set_type(NodeType::Sequence);
-  node.set_style(style);
-}
-
-void NodeBuilder::OnSequenceEnd() { Pop(); }
-
-void NodeBuilder::OnMapStart(const Mark& mark, const std::string& tag,
-                             anchor_t anchor, EmitterStyle::value style) {
-  detail::node& node = Push(mark, anchor);
-  node.set_type(NodeType::Map);
-  node.set_tag(tag);
-  node.set_style(style);
-  m_mapDepth++;
-}
-
-void NodeBuilder::OnMapEnd() {
-  assert(m_mapDepth > 0);
-  m_mapDepth--;
-  Pop();
-}
-
-detail::node& NodeBuilder::Push(const Mark& mark, anchor_t anchor) {
-  detail::node& node = m_pMemory->create_node();
-  node.set_mark(mark);
-  RegisterAnchor(anchor, node);
-  Push(node);
-  return node;
-}
-
-void NodeBuilder::Push(detail::node& node) {
-  const bool needsKey =
-      (!m_stack.empty() && m_stack.back()->type() == NodeType::Map &&
-       m_keys.size() < m_mapDepth);
-
-  m_stack.push_back(&node);
-  if (needsKey)
-    m_keys.push_back(PushedKey(&node, false));
-}
-
-void NodeBuilder::Pop() {
-  assert(!m_stack.empty());
-  if (m_stack.size() == 1) {
-    m_pRoot = m_stack[0];
-    m_stack.pop_back();
-    return;
-  }
-
-  detail::node& node = *m_stack.back();
-  m_stack.pop_back();
-
-  detail::node& collection = *m_stack.back();
-
-  if (collection.type() == NodeType::Sequence) {
-    collection.push_back(node, m_pMemory);
-  } else if (collection.type() == NodeType::Map) {
-    assert(!m_keys.empty());
-    PushedKey& key = m_keys.back();
-    if (key.second) {
-      collection.insert(*key.first, node, m_pMemory);
-      m_keys.pop_back();
-    } else {
-      key.second = true;
-    }
-  } else {
-    assert(false);
-    m_stack.clear();
-  }
-}
-
-void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node) {
-  if (anchor) {
-    assert(anchor == m_anchors.size());
-    m_anchors.push_back(&node);
-  }
-}
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodebuilder.h
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodebuilder.h b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodebuilder.h
deleted file mode 100644
index a6a47f0..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodebuilder.h
+++ /dev/null
@@ -1,70 +0,0 @@
-#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 <vector>
-
-#include "yaml-cpp/anchor.h"
-#include "yaml-cpp/emitterstyle.h"
-#include "yaml-cpp/eventhandler.h"
-#include "yaml-cpp/node/ptr.h"
-
-namespace YAML {
-namespace detail {
-class node;
-}  // namespace detail
-struct Mark;
-}  // namespace YAML
-
-namespace YAML {
-class Node;
-
-class NodeBuilder : public EventHandler {
- public:
-  NodeBuilder();
-  virtual ~NodeBuilder();
-
-  Node Root();
-
-  virtual void OnDocumentStart(const Mark& mark);
-  virtual void OnDocumentEnd();
-
-  virtual void OnNull(const Mark& mark, anchor_t anchor);
-  virtual void OnAlias(const Mark& mark, anchor_t anchor);
-  virtual void OnScalar(const Mark& mark, const std::string& tag,
-                        anchor_t anchor, const std::string& value);
-
-  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
-                               anchor_t anchor, EmitterStyle::value style);
-  virtual void OnSequenceEnd();
-
-  virtual void OnMapStart(const Mark& mark, const std::string& tag,
-                          anchor_t anchor, EmitterStyle::value style);
-  virtual void OnMapEnd();
-
- private:
-  detail::node& Push(const Mark& mark, anchor_t anchor);
-  void Push(detail::node& node);
-  void Pop();
-  void RegisterAnchor(anchor_t anchor, detail::node& node);
-
- private:
-  detail::shared_memory_holder m_pMemory;
-  detail::node* m_pRoot;
-
-  typedef std::vector<detail::node*> Nodes;
-  Nodes m_stack;
-  Nodes m_anchors;
-
-  typedef std::pair<detail::node*, bool> PushedKey;
-  std::vector<PushedKey> m_keys;
-  std::size_t m_mapDepth;
-};
-}
-
-#endif  // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodeevents.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodeevents.cpp b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodeevents.cpp
deleted file mode 100644
index 82261fe..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodeevents.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include "nodeevents.h"
-#include "yaml-cpp/eventhandler.h"
-#include "yaml-cpp/mark.h"
-#include "yaml-cpp/node/detail/node.h"
-#include "yaml-cpp/node/detail/node_iterator.h"
-#include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/type.h"
-
-namespace YAML {
-void NodeEvents::AliasManager::RegisterReference(const detail::node& node) {
-  m_anchorByIdentity.insert(std::make_pair(node.ref(), _CreateNewAnchor()));
-}
-
-anchor_t NodeEvents::AliasManager::LookupAnchor(
-    const detail::node& node) const {
-  AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(node.ref());
-  if (it == m_anchorByIdentity.end())
-    return 0;
-  return it->second;
-}
-
-NodeEvents::NodeEvents(const Node& node)
-    : m_pMemory(node.m_pMemory), m_root(node.m_pNode) {
-  if (m_root)
-    Setup(*m_root);
-}
-
-void NodeEvents::Setup(const detail::node& node) {
-  int& refCount = m_refCount[node.ref()];
-  refCount++;
-  if (refCount > 1)
-    return;
-
-  if (node.type() == NodeType::Sequence) {
-    for (detail::const_node_iterator it = node.begin(); it != node.end(); ++it)
-      Setup(**it);
-  } else if (node.type() == NodeType::Map) {
-    for (detail::const_node_iterator it = node.begin(); it != node.end();
-         ++it) {
-      Setup(*it->first);
-      Setup(*it->second);
-    }
-  }
-}
-
-void NodeEvents::Emit(EventHandler& handler) {
-  AliasManager am;
-
-  handler.OnDocumentStart(Mark());
-  if (m_root)
-    Emit(*m_root, handler, am);
-  handler.OnDocumentEnd();
-}
-
-void NodeEvents::Emit(const detail::node& node, EventHandler& handler,
-                      AliasManager& am) const {
-  anchor_t anchor = NullAnchor;
-  if (IsAliased(node)) {
-    anchor = am.LookupAnchor(node);
-    if (anchor) {
-      handler.OnAlias(Mark(), anchor);
-      return;
-    }
-
-    am.RegisterReference(node);
-    anchor = am.LookupAnchor(node);
-  }
-
-  switch (node.type()) {
-    case NodeType::Undefined:
-      break;
-    case NodeType::Null:
-      handler.OnNull(Mark(), anchor);
-      break;
-    case NodeType::Scalar:
-      handler.OnScalar(Mark(), node.tag(), anchor, node.scalar());
-      break;
-    case NodeType::Sequence:
-      handler.OnSequenceStart(Mark(), node.tag(), anchor, node.style());
-      for (detail::const_node_iterator it = node.begin(); it != node.end();
-           ++it)
-        Emit(**it, handler, am);
-      handler.OnSequenceEnd();
-      break;
-    case NodeType::Map:
-      handler.OnMapStart(Mark(), node.tag(), anchor, node.style());
-      for (detail::const_node_iterator it = node.begin(); it != node.end();
-           ++it) {
-        Emit(*it->first, handler, am);
-        Emit(*it->second, handler, am);
-      }
-      handler.OnMapEnd();
-      break;
-  }
-}
-
-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;
-}
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodeevents.h
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodeevents.h b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodeevents.h
deleted file mode 100644
index 49c18eb..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/nodeevents.h
+++ /dev/null
@@ -1,64 +0,0 @@
-#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 <map>
-#include <vector>
-
-#include "yaml-cpp/anchor.h"
-#include "yaml-cpp/node/ptr.h"
-
-namespace YAML {
-namespace detail {
-class node;
-}  // namespace detail
-}  // namespace YAML
-
-namespace YAML {
-class EventHandler;
-class Node;
-
-class NodeEvents {
- public:
-  explicit NodeEvents(const Node& node);
-
-  void Emit(EventHandler& handler);
-
- private:
-  class AliasManager {
-   public:
-    AliasManager() : m_curAnchor(0) {}
-
-    void RegisterReference(const detail::node& node);
-    anchor_t LookupAnchor(const detail::node& node) const;
-
-   private:
-    anchor_t _CreateNewAnchor() { return ++m_curAnchor; }
-
-   private:
-    typedef std::map<const detail::node_ref*, anchor_t> AnchorByIdentity;
-    AnchorByIdentity m_anchorByIdentity;
-
-    anchor_t m_curAnchor;
-  };
-
-  void Setup(const detail::node& node);
-  void Emit(const detail::node& node, EventHandler& handler,
-            AliasManager& am) const;
-  bool IsAliased(const detail::node& node) const;
-
- private:
-  detail::shared_memory_holder m_pMemory;
-  detail::node* m_root;
-
-  typedef std::map<const detail::node_ref*, int> RefCount;
-  RefCount m_refCount;
-};
-}
-
-#endif  // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/null.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/null.cpp b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/null.cpp
deleted file mode 100644
index 1b24b70..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/null.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "yaml-cpp/null.h"
-
-namespace YAML {
-_Null Null;
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/ostream_wrapper.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/ostream_wrapper.cpp b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/ostream_wrapper.cpp
deleted file mode 100644
index 357fc00..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/ostream_wrapper.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "yaml-cpp/ostream_wrapper.h"
-
-#include <algorithm>
-#include <cstring>
-#include <iostream>
-
-namespace YAML {
-ostream_wrapper::ostream_wrapper()
-    : m_buffer(1, '\0'),
-      m_pStream(0),
-      m_pos(0),
-      m_row(0),
-      m_col(0),
-      m_comment(false) {}
-
-ostream_wrapper::ostream_wrapper(std::ostream& stream)
-    : m_pStream(&stream), m_pos(0), m_row(0), m_col(0), m_comment(false) {}
-
-ostream_wrapper::~ostream_wrapper() {}
-
-void ostream_wrapper::write(const std::string& str) {
-  if (m_pStream) {
-    m_pStream->write(str.c_str(), str.size());
-  } else {
-    m_buffer.resize(std::max(m_buffer.size(), m_pos + str.size() + 1));
-    std::copy(str.begin(), str.end(), m_buffer.begin() + m_pos);
-  }
-
-  for (std::size_t i = 0; i < str.size(); i++) {
-    update_pos(str[i]);
-  }
-}
-
-void ostream_wrapper::write(const char* str, std::size_t size) {
-  if (m_pStream) {
-    m_pStream->write(str, size);
-  } else {
-    m_buffer.resize(std::max(m_buffer.size(), m_pos + size + 1));
-    std::copy(str, str + size, m_buffer.begin() + m_pos);
-  }
-
-  for (std::size_t i = 0; i < size; i++) {
-    update_pos(str[i]);
-  }
-}
-
-void ostream_wrapper::update_pos(char ch) {
-  m_pos++;
-  m_col++;
-
-  if (ch == '\n') {
-    m_row++;
-    m_col = 0;
-    m_comment = false;
-  }
-}
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/parse.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/parse.cpp b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/parse.cpp
deleted file mode 100644
index 1ef474d..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/parse.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "yaml-cpp/node/parse.h"
-
-#include <fstream>
-#include <sstream>
-
-#include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/impl.h"
-#include "yaml-cpp/parser.h"
-#include "nodebuilder.h"
-
-namespace YAML {
-Node Load(const std::string& input) {
-  std::stringstream stream(input);
-  return Load(stream);
-}
-
-Node Load(const char* input) {
-  std::stringstream stream(input);
-  return Load(stream);
-}
-
-Node Load(std::istream& input) {
-  Parser parser(input);
-  NodeBuilder builder;
-  if (!parser.HandleNextDocument(builder))
-    return Node();
-
-  return builder.Root();
-}
-
-Node LoadFile(const std::string& filename) {
-  std::ifstream fin(filename.c_str());
-  if (!fin)
-    throw BadFile();
-  return Load(fin);
-}
-
-std::vector<Node> LoadAll(const std::string& input) {
-  std::stringstream stream(input);
-  return LoadAll(stream);
-}
-
-std::vector<Node> LoadAll(const char* input) {
-  std::stringstream stream(input);
-  return LoadAll(stream);
-}
-
-std::vector<Node> LoadAll(std::istream& input) {
-  std::vector<Node> docs;
-
-  Parser parser(input);
-  while (1) {
-    NodeBuilder builder;
-    if (!parser.HandleNextDocument(builder))
-      break;
-    docs.push_back(builder.Root());
-  }
-
-  return docs;
-}
-
-std::vector<Node> LoadAllFromFile(const std::string& filename) {
-  std::ifstream fin(filename.c_str());
-  if (!fin)
-    throw BadFile();
-  return LoadAll(fin);
-}
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/parser.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/parser.cpp b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/parser.cpp
deleted file mode 100644
index 538d0be..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/parser.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-#include <cstdio>
-#include <sstream>
-
-#include "directives.h"  // IWYU pragma: keep
-#include "scanner.h"     // IWYU pragma: keep
-#include "singledocparser.h"
-#include "token.h"
-#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
-#include "yaml-cpp/parser.h"
-
-namespace YAML {
-class EventHandler;
-
-Parser::Parser() {}
-
-Parser::Parser(std::istream& in) { Load(in); }
-
-Parser::~Parser() {}
-
-Parser::operator bool() const {
-  return m_pScanner.get() && !m_pScanner->empty();
-}
-
-void Parser::Load(std::istream& in) {
-  m_pScanner.reset(new Scanner(in));
-  m_pDirectives.reset(new Directives);
-}
-
-// HandleNextDocument
-// . Handles the next document
-// . Throws a ParserException on error.
-// . Returns false if there are no more documents
-bool Parser::HandleNextDocument(EventHandler& eventHandler) {
-  if (!m_pScanner.get())
-    return false;
-
-  ParseDirectives();
-  if (m_pScanner->empty())
-    return false;
-
-  SingleDocParser sdp(*m_pScanner, *m_pDirectives);
-  sdp.HandleDocument(eventHandler);
-  return true;
-}
-
-// ParseDirectives
-// . Reads any directives that are next in the queue.
-void Parser::ParseDirectives() {
-  bool readDirective = false;
-
-  while (1) {
-    if (m_pScanner->empty())
-      break;
-
-    Token& token = m_pScanner->peek();
-    if (token.type != Token::DIRECTIVE)
-      break;
-
-    // we keep the directives from the last document if none are specified;
-    // but if any directives are specific, then we reset them
-    if (!readDirective)
-      m_pDirectives.reset(new Directives);
-
-    readDirective = true;
-    HandleDirective(token);
-    m_pScanner->pop();
-  }
-}
-
-void Parser::HandleDirective(const Token& token) {
-  if (token.value == "YAML")
-    HandleYamlDirective(token);
-  else if (token.value == "TAG")
-    HandleTagDirective(token);
-}
-
-// HandleYamlDirective
-// . Should be of the form 'major.minor' (like a version number)
-void Parser::HandleYamlDirective(const Token& token) {
-  if (token.params.size() != 1)
-    throw ParserException(token.mark, ErrorMsg::YAML_DIRECTIVE_ARGS);
-
-  if (!m_pDirectives->version.isDefault)
-    throw ParserException(token.mark, ErrorMsg::REPEATED_YAML_DIRECTIVE);
-
-  std::stringstream str(token.params[0]);
-  str >> m_pDirectives->version.major;
-  str.get();
-  str >> m_pDirectives->version.minor;
-  if (!str || str.peek() != EOF)
-    throw ParserException(
-        token.mark, std::string(ErrorMsg::YAML_VERSION) + token.params[0]);
-
-  if (m_pDirectives->version.major > 1)
-    throw ParserException(token.mark, ErrorMsg::YAML_MAJOR_VERSION);
-
-  m_pDirectives->version.isDefault = false;
-  // TODO: warning on major == 1, minor > 2?
-}
-
-// HandleTagDirective
-// . Should be of the form 'handle prefix', where 'handle' is converted to
-// 'prefix' in the file.
-void Parser::HandleTagDirective(const Token& token) {
-  if (token.params.size() != 2)
-    throw ParserException(token.mark, ErrorMsg::TAG_DIRECTIVE_ARGS);
-
-  const std::string& handle = token.params[0];
-  const std::string& prefix = token.params[1];
-  if (m_pDirectives->tags.find(handle) != m_pDirectives->tags.end())
-    throw ParserException(token.mark, ErrorMsg::REPEATED_TAG_DIRECTIVE);
-
-  m_pDirectives->tags[handle] = prefix;
-}
-
-void Parser::PrintTokens(std::ostream& out) {
-  if (!m_pScanner.get())
-    return;
-
-  while (1) {
-    if (m_pScanner->empty())
-      break;
-
-    out << m_pScanner->peek() << "\n";
-    m_pScanner->pop();
-  }
-}
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/ptr_stack.h
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/ptr_stack.h b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/ptr_stack.h
deleted file mode 100644
index f378ffc..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/ptr_stack.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#ifndef PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define PTR_STACK_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 <cstddef>
-#include <cstdlib>
-#include <memory>
-#include <vector>
-
-#include "yaml-cpp/noncopyable.h"
-
-template <typename T>
-class ptr_stack : private YAML::noncopyable {
- public:
-  ptr_stack() {}
-  ~ptr_stack() { clear(); }
-
-  void clear() {
-    for (std::size_t i = 0; i < m_data.size(); i++)
-      delete m_data[i];
-    m_data.clear();
-  }
-
-  std::size_t size() const { return m_data.size(); }
-  bool empty() const { return m_data.empty(); }
-
-  void push(std::auto_ptr<T> t) {
-    m_data.push_back(NULL);
-    m_data.back() = t.release();
-  }
-  std::auto_ptr<T> pop() {
-    std::auto_ptr<T> t(m_data.back());
-    m_data.pop_back();
-    return t;
-  }
-  T& top() { return *m_data.back(); }
-  const T& top() const { return *m_data.back(); }
-
-  T& top(std::ptrdiff_t diff) { return **(m_data.end() - 1 + diff); }
-  const T& top(std::ptrdiff_t diff) const {
-    return **(m_data.end() - 1 + diff);
-  }
-
- private:
-  std::vector<T*> m_data;
-};
-
-#endif  // PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/ptr_vector.h
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/ptr_vector.h b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/ptr_vector.h
deleted file mode 100644
index a546a89..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/ptr_vector.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#ifndef PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define PTR_VECTOR_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 <cstddef>
-#include <cstdlib>
-#include <memory>
-#include <vector>
-
-#include "yaml-cpp/noncopyable.h"
-
-namespace YAML {
-
-template <typename T>
-class ptr_vector : private YAML::noncopyable {
- public:
-  ptr_vector() {}
-  ~ptr_vector() { clear(); }
-
-  void clear() {
-    for (std::size_t i = 0; i < m_data.size(); i++)
-      delete m_data[i];
-    m_data.clear();
-  }
-
-  std::size_t size() const { return m_data.size(); }
-  bool empty() const { return m_data.empty(); }
-
-  void push_back(std::auto_ptr<T> t) {
-    m_data.push_back(NULL);
-    m_data.back() = t.release();
-  }
-  T& operator[](std::size_t i) { return *m_data[i]; }
-  const T& operator[](std::size_t i) const { return *m_data[i]; }
-
-  T& back() { return *m_data.back(); }
-  const T& back() const { return *m_data.back(); }
-
- private:
-  std::vector<T*> m_data;
-};
-}
-
-#endif  // PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/regex_yaml.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/regex_yaml.cpp b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/regex_yaml.cpp
deleted file mode 100644
index 20b7720..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/regex_yaml.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "regex_yaml.h"
-
-namespace YAML {
-// constructors
-RegEx::RegEx() : m_op(REGEX_EMPTY) {}
-
-RegEx::RegEx(REGEX_OP op) : m_op(op) {}
-
-RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch) {}
-
-RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z) {}
-
-RegEx::RegEx(const std::string& str, REGEX_OP op) : m_op(op) {
-  for (std::size_t i = 0; i < str.size(); i++)
-    m_params.push_back(RegEx(str[i]));
-}
-
-// combination constructors
-RegEx operator!(const RegEx& ex) {
-  RegEx ret(REGEX_NOT);
-  ret.m_params.push_back(ex);
-  return ret;
-}
-
-RegEx operator||(const RegEx& ex1, const RegEx& ex2) {
-  RegEx ret(REGEX_OR);
-  ret.m_params.push_back(ex1);
-  ret.m_params.push_back(ex2);
-  return ret;
-}
-
-RegEx operator&&(const RegEx& ex1, const RegEx& ex2) {
-  RegEx ret(REGEX_AND);
-  ret.m_params.push_back(ex1);
-  ret.m_params.push_back(ex2);
-  return ret;
-}
-
-RegEx operator+(const RegEx& ex1, const RegEx& ex2) {
-  RegEx ret(REGEX_SEQ);
-  ret.m_params.push_back(ex1);
-  ret.m_params.push_back(ex2);
-  return ret;
-}
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/regex_yaml.h
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/regex_yaml.h b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/regex_yaml.h
deleted file mode 100644
index 3fa7327..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/regex_yaml.h
+++ /dev/null
@@ -1,85 +0,0 @@
-#ifndef REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define REGEX_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 <string>
-#include <vector>
-
-namespace YAML {
-class Stream;
-
-enum REGEX_OP {
-  REGEX_EMPTY,
-  REGEX_MATCH,
-  REGEX_RANGE,
-  REGEX_OR,
-  REGEX_AND,
-  REGEX_NOT,
-  REGEX_SEQ
-};
-
-// simplified regular expressions
-// . Only straightforward matches (no repeated characters)
-// . Only matches from start of string
-class RegEx {
- public:
-  RegEx();
-  RegEx(char ch);
-  RegEx(char a, char z);
-  RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ);
-  ~RegEx() {}
-
-  friend RegEx operator!(const RegEx& ex);
-  friend RegEx operator||(const RegEx& ex1, const RegEx& ex2);
-  friend RegEx operator&&(const RegEx& ex1, const RegEx& ex2);
-  friend RegEx operator+(const RegEx& ex1, const RegEx& ex2);
-
-  bool Matches(char ch) const;
-  bool Matches(const std::string& str) const;
-  bool Matches(const Stream& in) const;
-  template <typename Source>
-  bool Matches(const Source& source) const;
-
-  int Match(const std::string& str) const;
-  int Match(const Stream& in) const;
-  template <typename Source>
-  int Match(const Source& source) const;
-
- private:
-  RegEx(REGEX_OP op);
-
-  template <typename Source>
-  bool IsValidSource(const Source& source) const;
-  template <typename Source>
-  int MatchUnchecked(const Source& source) const;
-
-  template <typename Source>
-  int MatchOpEmpty(const Source& source) const;
-  template <typename Source>
-  int MatchOpMatch(const Source& source) const;
-  template <typename Source>
-  int MatchOpRange(const Source& source) const;
-  template <typename Source>
-  int MatchOpOr(const Source& source) const;
-  template <typename Source>
-  int MatchOpAnd(const Source& source) const;
-  template <typename Source>
-  int MatchOpNot(const Source& source) const;
-  template <typename Source>
-  int MatchOpSeq(const Source& source) const;
-
- private:
-  REGEX_OP m_op;
-  char m_a, m_z;
-  std::vector<RegEx> m_params;
-};
-}
-
-#include "regeximpl.h"
-
-#endif  // REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/regeximpl.h
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/regeximpl.h b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/regeximpl.h
deleted file mode 100644
index 709124f..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/regeximpl.h
+++ /dev/null
@@ -1,186 +0,0 @@
-#ifndef REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define REGEXIMPL_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 "stream.h"
-#include "stringsource.h"
-#include "streamcharsource.h"
-
-namespace YAML {
-// query matches
-inline bool RegEx::Matches(char ch) const {
-  std::string str;
-  str += ch;
-  return Matches(str);
-}
-
-inline bool RegEx::Matches(const std::string& str) const {
-  return Match(str) >= 0;
-}
-
-inline bool RegEx::Matches(const Stream& in) const { return Match(in) >= 0; }
-
-template <typename Source>
-inline bool RegEx::Matches(const Source& source) const {
-  return Match(source) >= 0;
-}
-
-// Match
-// . Matches the given string against this regular expression.
-// . Returns the number of characters matched.
-// . Returns -1 if no characters were matched (the reason for
-//   not returning zero is that we may have an empty regex
-//   which is ALWAYS successful at matching zero characters).
-// . REMEMBER that we only match from the start of the buffer!
-inline int RegEx::Match(const std::string& str) const {
-  StringCharSource source(str.c_str(), str.size());
-  return Match(source);
-}
-
-inline int RegEx::Match(const Stream& in) const {
-  StreamCharSource source(in);
-  return Match(source);
-}
-
-template <typename Source>
-inline bool RegEx::IsValidSource(const Source& source) const {
-  return source;
-}
-
-template <>
-inline bool RegEx::IsValidSource<StringCharSource>(
-    const StringCharSource& source) const {
-  switch (m_op) {
-    case REGEX_MATCH:
-    case REGEX_RANGE:
-      return source;
-    default:
-      return true;
-  }
-}
-
-template <typename Source>
-inline int RegEx::Match(const Source& source) const {
-  return IsValidSource(source) ? MatchUnchecked(source) : -1;
-}
-
-template <typename Source>
-inline int RegEx::MatchUnchecked(const Source& source) const {
-  switch (m_op) {
-    case REGEX_EMPTY:
-      return MatchOpEmpty(source);
-    case REGEX_MATCH:
-      return MatchOpMatch(source);
-    case REGEX_RANGE:
-      return MatchOpRange(source);
-    case REGEX_OR:
-      return MatchOpOr(source);
-    case REGEX_AND:
-      return MatchOpAnd(source);
-    case REGEX_NOT:
-      return MatchOpNot(source);
-    case REGEX_SEQ:
-      return MatchOpSeq(source);
-  }
-
-  return -1;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// Operators
-// Note: the convention MatchOp*<Source> is that we can assume
-// IsSourceValid(source).
-//       So we do all our checks *before* we call these functions
-
-// EmptyOperator
-template <typename Source>
-inline int RegEx::MatchOpEmpty(const Source& source) const {
-  return source[0] == Stream::eof() ? 0 : -1;
-}
-
-template <>
-inline int RegEx::MatchOpEmpty<StringCharSource>(
-    const StringCharSource& source) const {
-  return !source
-             ? 0
-             : -1;  // the empty regex only is successful on the empty string
-}
-
-// MatchOperator
-template <typename Source>
-inline int RegEx::MatchOpMatch(const Source& source) const {
-  if (source[0] != m_a)
-    return -1;
-  return 1;
-}
-
-// RangeOperator
-template <typename Source>
-inline int RegEx::MatchOpRange(const Source& source) const {
-  if (m_a > source[0] || m_z < source[0])
-    return -1;
-  return 1;
-}
-
-// OrOperator
-template <typename Source>
-inline int RegEx::MatchOpOr(const Source& source) const {
-  for (std::size_t i = 0; i < m_params.size(); i++) {
-    int n = m_params[i].MatchUnchecked(source);
-    if (n >= 0)
-      return n;
-  }
-  return -1;
-}
-
-// AndOperator
-// Note: 'AND' is a little funny, since we may be required to match things
-//       of different lengths. If we find a match, we return the length of
-//       the FIRST entry on the list.
-template <typename Source>
-inline int RegEx::MatchOpAnd(const Source& source) const {
-  int first = -1;
-  for (std::size_t i = 0; i < m_params.size(); i++) {
-    int n = m_params[i].MatchUnchecked(source);
-    if (n == -1)
-      return -1;
-    if (i == 0)
-      first = n;
-  }
-  return first;
-}
-
-// NotOperator
-template <typename Source>
-inline int RegEx::MatchOpNot(const Source& source) const {
-  if (m_params.empty())
-    return -1;
-  if (m_params[0].MatchUnchecked(source) >= 0)
-    return -1;
-  return 1;
-}
-
-// SeqOperator
-template <typename Source>
-inline int RegEx::MatchOpSeq(const Source& source) const {
-  int offset = 0;
-  for (std::size_t i = 0; i < m_params.size(); i++) {
-    int n = m_params[i].Match(source + offset);  // note Match, not
-                                                 // MatchUnchecked because we
-                                                 // need to check validity after
-                                                 // the offset
-    if (n == -1)
-      return -1;
-    offset += n;
-  }
-
-  return offset;
-}
-}
-
-#endif  // REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/scanner.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/scanner.cpp b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/scanner.cpp
deleted file mode 100644
index 680c73b..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/scanner.cpp
+++ /dev/null
@@ -1,386 +0,0 @@
-#include <cassert>
-#include <memory>
-
-#include "exp.h"
-#include "scanner.h"
-#include "token.h"
-#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
-
-namespace YAML {
-Scanner::Scanner(std::istream& in)
-    : INPUT(in),
-      m_startedStream(false),
-      m_endedStream(false),
-      m_simpleKeyAllowed(false),
-      m_canBeJSONFlow(false) {}
-
-Scanner::~Scanner() {}
-
-// empty
-// . Returns true if there are no more tokens to be read
-bool Scanner::empty() {
-  EnsureTokensInQueue();
-  return m_tokens.empty();
-}
-
-// pop
-// . Simply removes the next token on the queue.
-void Scanner::pop() {
-  EnsureTokensInQueue();
-  if (!m_tokens.empty())
-    m_tokens.pop();
-}
-
-// peek
-// . Returns (but does not remove) the next token on the queue.
-Token& Scanner::peek() {
-  EnsureTokensInQueue();
-  assert(!m_tokens.empty());  // should we be asserting here? I mean, we really
-                              // just be checking
-                              // if it's empty before peeking.
-
-#if 0
-		static Token *pLast = 0;
-		if(pLast != &m_tokens.front())
-			std::cerr << "peek: " << m_tokens.front() << "\n";
-		pLast = &m_tokens.front();
-#endif
-
-  return m_tokens.front();
-}
-
-// mark
-// . Returns the current mark in the stream
-Mark Scanner::mark() const { return INPUT.mark(); }
-
-// EnsureTokensInQueue
-// . Scan until there's a valid token at the front of the queue,
-//   or we're sure the queue is empty.
-void Scanner::EnsureTokensInQueue() {
-  while (1) {
-    if (!m_tokens.empty()) {
-      Token& token = m_tokens.front();
-
-      // if this guy's valid, then we're done
-      if (token.status == Token::VALID)
-        return;
-
-      // here's where we clean up the impossible tokens
-      if (token.status == Token::INVALID) {
-        m_tokens.pop();
-        continue;
-      }
-
-      // note: what's left are the unverified tokens
-    }
-
-    // no token? maybe we've actually finished
-    if (m_endedStream)
-      return;
-
-    // no? then scan...
-    ScanNextToken();
-  }
-}
-
-// ScanNextToken
-// . The main scanning function; here we branch out and
-//   scan whatever the next token should be.
-void Scanner::ScanNextToken() {
-  if (m_endedStream)
-    return;
-
-  if (!m_startedStream)
-    return StartStream();
-
-  // get rid of whitespace, etc. (in between tokens it should be irrelevent)
-  ScanToNextToken();
-
-  // maybe need to end some blocks
-  PopIndentToHere();
-
-  // *****
-  // And now branch based on the next few characters!
-  // *****
-
-  // end of stream
-  if (!INPUT)
-    return EndStream();
-
-  if (INPUT.column() == 0 && INPUT.peek() == Keys::Directive)
-    return ScanDirective();
-
-  // document token
-  if (INPUT.column() == 0 && Exp::DocStart().Matches(INPUT))
-    return ScanDocStart();
-
-  if (INPUT.column() == 0 && Exp::DocEnd().Matches(INPUT))
-    return ScanDocEnd();
-
-  // flow start/end/entry
-  if (INPUT.peek() == Keys::FlowSeqStart || INPUT.peek() == Keys::FlowMapStart)
-    return ScanFlowStart();
-
-  if (INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd)
-    return ScanFlowEnd();
-
-  if (INPUT.peek() == Keys::FlowEntry)
-    return ScanFlowEntry();
-
-  // block/map stuff
-  if (Exp::BlockEntry().Matches(INPUT))
-    return ScanBlockEntry();
-
-  if ((InBlockContext() ? Exp::Key() : Exp::KeyInFlow()).Matches(INPUT))
-    return ScanKey();
-
-  if (GetValueRegex().Matches(INPUT))
-    return ScanValue();
-
-  // alias/anchor
-  if (INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor)
-    return ScanAnchorOrAlias();
-
-  // tag
-  if (INPUT.peek() == Keys::Tag)
-    return ScanTag();
-
-  // special scalars
-  if (InBlockContext() && (INPUT.peek() == Keys::LiteralScalar ||
-                           INPUT.peek() == Keys::FoldedScalar))
-    return ScanBlockScalar();
-
-  if (INPUT.peek() == '\'' || INPUT.peek() == '\"')
-    return ScanQuotedScalar();
-
-  // plain scalars
-  if ((InBlockContext() ? Exp::PlainScalar() : Exp::PlainScalarInFlow())
-          .Matches(INPUT))
-    return ScanPlainScalar();
-
-  // don't know what it is!
-  throw ParserException(INPUT.mark(), ErrorMsg::UNKNOWN_TOKEN);
-}
-
-// ScanToNextToken
-// . Eats input until we reach the next token-like thing.
-void Scanner::ScanToNextToken() {
-  while (1) {
-    // first eat whitespace
-    while (INPUT && IsWhitespaceToBeEaten(INPUT.peek())) {
-      if (InBlockContext() && Exp::Tab().Matches(INPUT))
-        m_simpleKeyAllowed = false;
-      INPUT.eat(1);
-    }
-
-    // then eat a comment
-    if (Exp::Comment().Matches(INPUT)) {
-      // eat until line break
-      while (INPUT && !Exp::Break().Matches(INPUT))
-        INPUT.eat(1);
-    }
-
-    // if it's NOT a line break, then we're done!
-    if (!Exp::Break().Matches(INPUT))
-      break;
-
-    // otherwise, let's eat the line break and keep going
-    int n = Exp::Break().Match(INPUT);
-    INPUT.eat(n);
-
-    // oh yeah, and let's get rid of that simple key
-    InvalidateSimpleKey();
-
-    // new line - we may be able to accept a simple key now
-    if (InBlockContext())
-      m_simpleKeyAllowed = true;
-  }
-}
-
-///////////////////////////////////////////////////////////////////////
-// Misc. helpers
-
-// IsWhitespaceToBeEaten
-// . We can eat whitespace if it's a space or tab
-// . Note: originally tabs in block context couldn't be eaten
-//         "where a simple key could be allowed
-//         (i.e., not at the beginning of a line, or following '-', '?', or
-// ':')"
-//   I think this is wrong, since tabs can be non-content whitespace; it's just
-//   that they can't contribute to indentation, so once you've seen a tab in a
-//   line, you can't start a simple key
-bool Scanner::IsWhitespaceToBeEaten(char ch) {
-  if (ch == ' ')
-    return true;
-
-  if (ch == '\t')
-    return true;
-
-  return false;
-}
-
-// GetValueRegex
-// . Get the appropriate regex to check if it's a value token
-const RegEx& Scanner::GetValueRegex() const {
-  if (InBlockContext())
-    return Exp::Value();
-
-  return m_canBeJSONFlow ? Exp::ValueInJSONFlow() : Exp::ValueInFlow();
-}
-
-// StartStream
-// . Set the initial conditions for starting a stream.
-void Scanner::StartStream() {
-  m_startedStream = true;
-  m_simpleKeyAllowed = true;
-  std::auto_ptr<IndentMarker> pIndent(new IndentMarker(-1, IndentMarker::NONE));
-  m_indentRefs.push_back(pIndent);
-  m_indents.push(&m_indentRefs.back());
-}
-
-// EndStream
-// . Close out the stream, finish up, etc.
-void Scanner::EndStream() {
-  // force newline
-  if (INPUT.column() > 0)
-    INPUT.ResetColumn();
-
-  PopAllIndents();
-  PopAllSimpleKeys();
-
-  m_simpleKeyAllowed = false;
-  m_endedStream = true;
-}
-
-Token* Scanner::PushToken(Token::TYPE type) {
-  m_tokens.push(Token(type, INPUT.mark()));
-  return &m_tokens.back();
-}
-
-Token::TYPE Scanner::GetStartTokenFor(IndentMarker::INDENT_TYPE type) const {
-  switch (type) {
-    case IndentMarker::SEQ:
-      return Token::BLOCK_SEQ_START;
-    case IndentMarker::MAP:
-      return Token::BLOCK_MAP_START;
-    case IndentMarker::NONE:
-      assert(false);
-      break;
-  }
-  assert(false);
-  throw std::runtime_error("yaml-cpp: internal error, invalid indent type");
-}
-
-// PushIndentTo
-// . Pushes an indentation onto the stack, and enqueues the
-//   proper token (sequence start or mapping start).
-// . Returns the indent marker it generates (if any).
-Scanner::IndentMarker* Scanner::PushIndentTo(int column,
-                                             IndentMarker::INDENT_TYPE type) {
-  // are we in flow?
-  if (InFlowContext())
-    return 0;
-
-  std::auto_ptr<IndentMarker> pIndent(new IndentMarker(column, type));
-  IndentMarker& indent = *pIndent;
-  const IndentMarker& lastIndent = *m_indents.top();
-
-  // is this actually an indentation?
-  if (indent.column < lastIndent.column)
-    return 0;
-  if (indent.column == lastIndent.column &&
-      !(indent.type == IndentMarker::SEQ &&
-        lastIndent.type == IndentMarker::MAP))
-    return 0;
-
-  // push a start token
-  indent.pStartToken = PushToken(GetStartTokenFor(type));
-
-  // and then the indent
-  m_indents.push(&indent);
-  m_indentRefs.push_back(pIndent);
-  return &m_indentRefs.back();
-}
-
-// PopIndentToHere
-// . Pops indentations off the stack until we reach the current indentation
-// level,
-//   and enqueues the proper token each time.
-// . Then pops all invalid indentations off.
-void Scanner::PopIndentToHere() {
-  // are we in flow?
-  if (InFlowContext())
-    return;
-
-  // now pop away
-  while (!m_indents.empty()) {
-    const IndentMarker& indent = *m_indents.top();
-    if (indent.column < INPUT.column())
-      break;
-    if (indent.column == INPUT.column() &&
-        !(indent.type == IndentMarker::SEQ &&
-          !Exp::BlockEntry().Matches(INPUT)))
-      break;
-
-    PopIndent();
-  }
-
-  while (!m_indents.empty() && m_indents.top()->status == IndentMarker::INVALID)
-    PopIndent();
-}
-
-// PopAllIndents
-// . Pops all indentations (except for the base empty one) off the stack,
-//   and enqueues the proper token each time.
-void Scanner::PopAllIndents() {
-  // are we in flow?
-  if (InFlowContext())
-    return;
-
-  // now pop away
-  while (!m_indents.empty()) {
-    const IndentMarker& indent = *m_indents.top();
-    if (indent.type == IndentMarker::NONE)
-      break;
-
-    PopIndent();
-  }
-}
-
-// PopIndent
-// . Pops a single indent, pushing the proper token
-void Scanner::PopIndent() {
-  const IndentMarker& indent = *m_indents.top();
-  m_indents.pop();
-
-  if (indent.status != IndentMarker::VALID) {
-    InvalidateSimpleKey();
-    return;
-  }
-
-  if (indent.type == IndentMarker::SEQ)
-    m_tokens.push(Token(Token::BLOCK_SEQ_END, INPUT.mark()));
-  else if (indent.type == IndentMarker::MAP)
-    m_tokens.push(Token(Token::BLOCK_MAP_END, INPUT.mark()));
-}
-
-// GetTopIndent
-int Scanner::GetTopIndent() const {
-  if (m_indents.empty())
-    return 0;
-  return m_indents.top()->column;
-}
-
-// ThrowParserException
-// . Throws a ParserException with the current token location
-//   (if available).
-// . Does not parse any more tokens.
-void Scanner::ThrowParserException(const std::string& msg) const {
-  Mark mark = Mark::null_mark();
-  if (!m_tokens.empty()) {
-    const Token& token = m_tokens.front();
-    mark = token.mark;
-  }
-  throw ParserException(mark, msg);
-}
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/1d6b2416/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/scanner.h
----------------------------------------------------------------------
diff --git a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/scanner.h b/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/scanner.h
deleted file mode 100644
index b0ac6d9..0000000
--- a/thirdparty/yaml-cpp-yaml-cpp-0.5.3/src/scanner.h
+++ /dev/null
@@ -1,135 +0,0 @@
-#ifndef SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define SCANNER_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 <cstddef>
-#include <ios>
-#include <map>
-#include <queue>
-#include <set>
-#include <stack>
-#include <string>
-
-#include "ptr_vector.h"
-#include "stream.h"
-#include "token.h"
-#include "yaml-cpp/mark.h"
-
-namespace YAML {
-class Node;
-class RegEx;
-
-class Scanner {
- public:
-  Scanner(std::istream &in);
-  ~Scanner();
-
-  // token queue management (hopefully this looks kinda stl-ish)
-  bool empty();
-  void pop();
-  Token &peek();
-  Mark mark() const;
-
- private:
-  struct IndentMarker {
-    enum INDENT_TYPE { MAP, SEQ, NONE };
-    enum STATUS { VALID, INVALID, UNKNOWN };
-    IndentMarker(int column_, INDENT_TYPE type_)
-        : column(column_), type(type_), status(VALID), pStartToken(0) {}
-
-    int column;
-    INDENT_TYPE type;
-    STATUS status;
-    Token *pStartToken;
-  };
-
-  enum FLOW_MARKER { FLOW_MAP, FLOW_SEQ };
-
- private:
-  // scanning
-  void EnsureTokensInQueue();
-  void ScanNextToken();
-  void ScanToNextToken();
-  void StartStream();
-  void EndStream();
-  Token *PushToken(Token::TYPE type);
-
-  bool InFlowContext() const { return !m_flows.empty(); }
-  bool InBlockContext() const { return m_flows.empty(); }
-  std::size_t GetFlowLevel() const { return m_flows.size(); }
-
-  Token::TYPE GetStartTokenFor(IndentMarker::INDENT_TYPE type) const;
-  IndentMarker *PushIndentTo(int column, IndentMarker::INDENT_TYPE type);
-  void PopIndentToHere();
-  void PopAllIndents();
-  void PopIndent();
-  int GetTopIndent() const;
-
-  // checking input
-  bool CanInsertPotentialSimpleKey() const;
-  bool ExistsActiveSimpleKey() const;
-  void InsertPotentialSimpleKey();
-  void InvalidateSimpleKey();
-  bool VerifySimpleKey();
-  void PopAllSimpleKeys();
-
-  void ThrowParserException(const std::string &msg) const;
-
-  bool IsWhitespaceToBeEaten(char ch);
-  const RegEx &GetValueRegex() const;
-
-  struct SimpleKey {
-    SimpleKey(const Mark &mark_, std::size_t flowLevel_);
-
-    void Validate();
-    void Invalidate();
-
-    Mark mark;
-    std::size_t flowLevel;
-    IndentMarker *pIndent;
-    Token *pMapStart, *pKey;
-  };
-
-  // and the tokens
-  void ScanDirective();
-  void ScanDocStart();
-  void ScanDocEnd();
-  void ScanBlockSeqStart();
-  void ScanBlockMapSTart();
-  void ScanBlockEnd();
-  void ScanBlockEntry();
-  void ScanFlowStart();
-  void ScanFlowEnd();
-  void ScanFlowEntry();
-  void ScanKey();
-  void ScanValue();
-  void ScanAnchorOrAlias();
-  void ScanTag();
-  void ScanPlainScalar();
-  void ScanQuotedScalar();
-  void ScanBlockScalar();
-
- private:
-  // the stream
-  Stream INPUT;
-
-  // the output (tokens)
-  std::queue<Token> m_tokens;
-
-  // state info
-  bool m_startedStream, m_endedStream;
-  bool m_simpleKeyAllowed;
-  bool m_canBeJSONFlow;
-  std::stack<SimpleKey> m_simpleKeys;
-  std::stack<IndentMarker *> m_indents;
-  ptr_vector<IndentMarker> m_indentRefs;  // for "garbage collection"
-  std::stack<FLOW_MARKER> m_flows;
-};
-}
-
-#endif  // SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66


Mime
View raw message