Run clang-format

2026-07-27 14:13:42 -07:00 · 2014-03-22 12:49:16 -05:00
parent e40ed4f94e
commit 9b4db068bb
78 changed files with 21889 additions and 21704 deletions
@@ -1,14 +1,15 @@
 #ifndef ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

 #include <cstddef>

-namespace YAML
-{
+namespace YAML {
 typedef std::size_t anchor_t;
 const anchor_t NullAnchor = 0;
 }
@@ -1,26 +1,30 @@
 #ifndef BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

 #include <string>
 #include <vector>

-namespace YAML
-{
+namespace YAML {
 std::string EncodeBase64(const unsigned char *data, std::size_t size);
 std::vector<unsigned char> DecodeBase64(const std::string &input);

 class Binary {
 public:
  Binary() : m_unownedData(0), m_unownedSize(0) {}
-        Binary(const unsigned char *data_, std::size_t size_): m_unownedData(data_), m_unownedSize(size_) {}
+  Binary(const unsigned char *data_, std::size_t size_)
+      : m_unownedData(data_), m_unownedSize(size_) {}

  bool owned() const { return !m_unownedData; }
  std::size_t size() const { return owned() ? m_data.size() : m_unownedSize; }
-        const unsigned char *data() const { return owned() ? &m_data[0] : m_unownedData; }
+  const unsigned char *data() const {
+    return owned() ? &m_data[0] : m_unownedData;
+  }

  void swap(std::vector<unsigned char> &rhs) {
    if (m_unownedData) {
@@ -48,9 +52,7 @@ namespace YAML
    return true;
  }

-        bool operator != (const Binary& rhs) const {
-            return !(*this == rhs);
-        }
+  bool operator!=(const Binary &rhs) const { return !(*this == rhs); }

 private:
  std::vector<unsigned char> m_data;
@@ -1,7 +1,9 @@
 #ifndef ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -9,30 +11,23 @@

 #include "../anchor.h"

-namespace YAML
-{
+namespace YAML {
 /// AnchorDict
 /// . An object that stores and retrieves values correlating to anchor_t
 ///   values.
 /// . Efficient implementation that can make assumptions about how anchor_t
 ///   values are assigned by the Parser class.
 template <class T>
-  class AnchorDict
-  {
+class AnchorDict {
 public:
-    void Register(anchor_t anchor, T value)
-    {
-      if (anchor > m_data.size())
-      {
+  void Register(anchor_t anchor, T value) {
+    if (anchor > m_data.size()) {
      m_data.resize(anchor);
    }
    m_data[anchor - 1] = value;
  }

-    T Get(anchor_t anchor) const
-    {
-      return m_data[anchor - 1];
-    }
+  T Get(anchor_t anchor) const { return m_data[anchor - 1]; }

 private:
  std::vector<T> m_data;
@@ -1,49 +1,59 @@
 #ifndef GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

 #include "yaml-cpp/mark.h"
 #include <string>

-namespace YAML
-{
+namespace YAML {
 class Parser;

 // GraphBuilderInterface
 // . Abstraction of node creation
 // . pParentNode is always NULL or the return value of one of the NewXXX()
 //   functions.
-  class GraphBuilderInterface
-  {
+class GraphBuilderInterface {
 public:
  // Create and return a new node with a null value.
  virtual void *NewNull(const Mark &mark, void *pParentNode) = 0;

  // Create and return a new node with the given tag and value.
-    virtual void *NewScalar(const Mark& mark, const std::string& tag, void *pParentNode, const std::string& value) = 0;
+  virtual void *NewScalar(const Mark &mark, const std::string &tag,
+                          void *pParentNode, const std::string &value) = 0;

  // Create and return a new sequence node
-    virtual void *NewSequence(const Mark& mark, const std::string& tag, void *pParentNode) = 0;
+  virtual void *NewSequence(const Mark &mark, const std::string &tag,
+                            void *pParentNode) = 0;
+
  // Add pNode to pSequence.  pNode was created with one of the NewXxx()
  // functions and pSequence with NewSequence().
  virtual void AppendToSequence(void *pSequence, void *pNode) = 0;
+
  // Note that no moew entries will be added to pSequence
  virtual void SequenceComplete(void *pSequence) { (void)pSequence; }

  // Create and return a new map node
-    virtual void *NewMap(const Mark& mark, const std::string& tag, void *pParentNode) = 0;
+  virtual void *NewMap(const Mark &mark, const std::string &tag,
+                       void *pParentNode) = 0;
+
  // Add the pKeyNode => pValueNode mapping to pMap.  pKeyNode and pValueNode
  // were created with one of the NewXxx() methods and pMap with NewMap().
  virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) = 0;
+
  // Note that no more assignments will be made in pMap
  virtual void MapComplete(void *pMap) { (void)pMap; }

  // Return the node that should be used in place of an alias referencing
  // pNode (pNode by default)
-    virtual void *AnchorReference(const Mark& mark, void *pNode) {(void)mark; return pNode;}
+  virtual void *AnchorReference(const Mark &mark, void *pNode) {
+    (void)mark;
+    return pNode;
+  }
 };

 // Typesafe wrapper for GraphBuilderInterface.  Assumes that Impl defines
@@ -54,15 +64,13 @@ namespace YAML
 // prototypes changed to accept an explicit Node*, Sequence*, or Map* where
 // appropriate.
 template <class Impl>
-  class GraphBuilder : public GraphBuilderInterface
-  {
+class GraphBuilder : public GraphBuilderInterface {
 public:
  typedef typename Impl::Node Node;
  typedef typename Impl::Sequence Sequence;
  typedef typename Impl::Map Map;

-    GraphBuilder(Impl& impl) : m_impl(impl)
-    {
+  GraphBuilder(Impl &impl) : m_impl(impl) {
    Map *pMap = NULL;
    Sequence *pSeq = NULL;
    Node *pNode = NULL;
@@ -78,12 +86,16 @@ namespace YAML
    return CheckType<Node>(m_impl.NewNull(mark, AsNode(pParentNode)));
  }

-    virtual void *NewScalar(const Mark& mark, const std::string& tag, void *pParentNode, const std::string& value) {
-      return CheckType<Node>(m_impl.NewScalar(mark, tag, AsNode(pParentNode), value));
+  virtual void *NewScalar(const Mark &mark, const std::string &tag,
+                          void *pParentNode, const std::string &value) {
+    return CheckType<Node>(
+        m_impl.NewScalar(mark, tag, AsNode(pParentNode), value));
  }

-    virtual void *NewSequence(const Mark& mark, const std::string& tag, void *pParentNode) {
-      return CheckType<Sequence>(m_impl.NewSequence(mark, tag, AsNode(pParentNode)));
+  virtual void *NewSequence(const Mark &mark, const std::string &tag,
+                            void *pParentNode) {
+    return CheckType<Sequence>(
+        m_impl.NewSequence(mark, tag, AsNode(pParentNode)));
  }
  virtual void AppendToSequence(void *pSequence, void *pNode) {
    m_impl.AppendToSequence(AsSequence(pSequence), AsNode(pNode));
@@ -92,15 +104,14 @@ namespace YAML
    m_impl.SequenceComplete(AsSequence(pSequence));
  }

-    virtual void *NewMap(const Mark& mark, const std::string& tag, void *pParentNode) {
+  virtual void *NewMap(const Mark &mark, const std::string &tag,
+                       void *pParentNode) {
    return CheckType<Map>(m_impl.NewMap(mark, tag, AsNode(pParentNode)));
  }
  virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) {
    m_impl.AssignInMap(AsMap(pMap), AsNode(pKeyNode), AsNode(pValueNode));
  }
-    virtual void MapComplete(void *pMap) {
-      m_impl.MapComplete(AsMap(pMap));
-    }
+  virtual void MapComplete(void *pMap) { m_impl.MapComplete(AsMap(pMap)); }

  virtual void *AnchorReference(const Mark &mark, void *pNode) {
    return CheckType<Node>(m_impl.AnchorReference(mark, AsNode(pNode)));
@@ -111,22 +122,25 @@ namespace YAML

  // Static check for pointer to T
  template <class T, class U>
-    static T* CheckType(U* p) {return p;}
+  static T *CheckType(U *p) {
+    return p;
+  }

  static Node *AsNode(void *pNode) { return static_cast<Node *>(pNode); }
-    static Sequence *AsSequence(void *pSeq) {return static_cast<Sequence*>(pSeq);}
+  static Sequence *AsSequence(void *pSeq) {
+    return static_cast<Sequence *>(pSeq);
+  }
  static Map *AsMap(void *pMap) { return static_cast<Map *>(pMap); }
 };

-  void *BuildGraphOfNextDocument(Parser& parser, GraphBuilderInterface& graphBuilder);
+void *BuildGraphOfNextDocument(Parser &parser,
+                               GraphBuilderInterface &graphBuilder);

 template <class Impl>
-  typename Impl::Node *BuildGraphOfNextDocument(Parser& parser, Impl& impl)
-  {
+typename Impl::Node *BuildGraphOfNextDocument(Parser &parser, Impl &impl) {
  GraphBuilder<Impl> graphBuilder(impl);
-    return static_cast<typename Impl::Node *>(BuildGraphOfNextDocument(
-      parser, graphBuilder
-    ));
+  return static_cast<typename Impl::Node *>(
+      BuildGraphOfNextDocument(parser, graphBuilder));
 }
 }

@@ -1,20 +1,29 @@
 #ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-// The following ifdef block is the standard way of creating macros which make exporting
-// from a DLL simpler. All files within this DLL are compiled with the yaml_cpp_EXPORTS
-// symbol defined on the command line. this symbol should not be defined on any project
-// that uses this DLL. This way any other project whose source files include this file see
-// YAML_CPP_API functions as being imported from a DLL, whereas this DLL sees symbols
+// The following ifdef block is the standard way of creating macros which make
+// exporting
+// from a DLL simpler. All files within this DLL are compiled with the
+// yaml_cpp_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any
+// project
+// that uses this DLL. This way any other project whose source files include
+// this file see
+// YAML_CPP_API functions as being imported from a DLL, whereas this DLL sees
+// symbols
 // defined with this macro as being exported.
 #undef YAML_CPP_API

-#ifdef YAML_CPP_DLL // Using or Building YAML-CPP DLL (definition defined manually)
-	#ifdef yaml_cpp_EXPORTS // Building YAML-CPP DLL (definition created by CMake or defined manually)
+#ifdef YAML_CPP_DLL      // Using or Building YAML-CPP DLL (definition defined
+                         // manually)
+#ifdef yaml_cpp_EXPORTS  // Building YAML-CPP DLL (definition created by CMake
+                         // or defined manually)
 //	#pragma message( "Defining YAML_CPP_API for DLL export" )
 #define YAML_CPP_API __declspec(dllexport)
 #else  // yaml_cpp_EXPORTS
@@ -1,19 +1,19 @@
 #ifndef EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

 #include "yaml-cpp/eventhandler.h"
 #include <stack>

-namespace YAML
-{
+namespace YAML {
 class Emitter;

-	class EmitFromEvents: public EventHandler
-	{
+class EmitFromEvents : public EventHandler {
 public:
  EmitFromEvents(Emitter& emitter);

@@ -22,12 +22,15 @@ namespace YAML

  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 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);
+  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
+                               anchor_t anchor);
  virtual void OnSequenceEnd();

-		virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor);
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor);
  virtual void OnMapEnd();

 private:
@@ -37,7 +40,13 @@ namespace YAML
 private:
  Emitter& m_emitter;

-		struct State { enum value { WaitingForSequenceEntry, WaitingForKey, WaitingForValue }; };
+  struct State {
+    enum value {
+      WaitingForSequenceEntry,
+      WaitingForKey,
+      WaitingForValue
+    };
+  };
  std::stack<State::value> m_stateStack;
 };
 }
@@ -1,11 +1,12 @@
 #ifndef EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-
 #include "yaml-cpp/dll.h"
 #include "yaml-cpp/binary.h"
 #include "yaml-cpp/emitterdef.h"
@@ -17,12 +18,10 @@
 #include <string>
 #include <sstream>

-namespace YAML
-{
+namespace YAML {
 class EmitterState;

-	class YAML_CPP_API Emitter: private noncopyable
-	{
+class YAML_CPP_API Emitter : private noncopyable {
 public:
  Emitter();
  explicit Emitter(std::ostream& stream);
@@ -72,7 +71,8 @@ namespace YAML
  Emitter& WriteStreamable(T value);

 private:
-        template<typename T> void SetStreamablePrecision(std::stringstream&) {}
+  template <typename T>
+  void SetStreamablePrecision(std::stringstream&) {}
  unsigned GetFloatPrecision() const;
  unsigned GetDoublePrecision() const;

@@ -120,8 +120,7 @@ namespace YAML
 };

 template <typename T>
-	inline Emitter& Emitter::WriteIntegralType(T value)
-	{
+inline Emitter& Emitter::WriteIntegralType(T value) {
  if (!good())
    return *this;

@@ -138,8 +137,7 @@ namespace YAML
 }

 template <typename T>
-	inline Emitter& Emitter::WriteStreamable(T value)
-	{
+inline Emitter& Emitter::WriteStreamable(T value) {
  if (!good())
    return *this;

@@ -156,42 +154,82 @@ namespace YAML
 }

 template <>
-    inline void Emitter::SetStreamablePrecision<float>(std::stringstream& stream)
-    {
+inline void Emitter::SetStreamablePrecision<float>(std::stringstream& stream) {
  stream.precision(GetFloatPrecision());
 }

 template <>
-    inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream)
-    {
+inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream) {
  stream.precision(GetDoublePrecision());
 }

 // overloads of insertion
-	inline Emitter& operator << (Emitter& emitter, const std::string& v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, bool v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, char v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, unsigned char v) { return emitter.Write(static_cast<char>(v)); }
-	inline Emitter& operator << (Emitter& emitter, const _Alias& v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, const _Anchor& v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, const _Tag& v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, const _Comment& v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, const _Null& v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, const Binary& b) { return emitter.Write(b); }
+inline Emitter& operator<<(Emitter& emitter, const std::string& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, bool v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, char v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned char v) {
+  return emitter.Write(static_cast<char>(v));
+}
+inline Emitter& operator<<(Emitter& emitter, const _Alias& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Anchor& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Tag& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Comment& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Null& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const Binary& b) {
+  return emitter.Write(b);
+}

-	inline Emitter& operator << (Emitter& emitter, const char *v) { return emitter.Write(std::string(v)); }
+inline Emitter& operator<<(Emitter& emitter, const char* v) {
+  return emitter.Write(std::string(v));
+}

-	inline Emitter& operator << (Emitter& emitter, int v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, unsigned int v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, short v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, unsigned short v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, long v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, unsigned long v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, long long v) { return emitter.WriteIntegralType(v); }
-	inline Emitter& operator << (Emitter& emitter, unsigned long long v) { return emitter.WriteIntegralType(v); }
+inline Emitter& operator<<(Emitter& emitter, int v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned int v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, short v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned short v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, long v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned long v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, long long v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned long long v) {
+  return emitter.WriteIntegralType(v);
+}

-	inline Emitter& operator << (Emitter& emitter, float v) { return emitter.WriteStreamable(v); }
-	inline Emitter& operator << (Emitter& emitter, double v) { return emitter.WriteStreamable(v); }
+inline Emitter& operator<<(Emitter& emitter, float v) {
+  return emitter.WriteStreamable(v);
+}
+inline Emitter& operator<<(Emitter& emitter, double v) {
+  return emitter.WriteStreamable(v);
+}

 inline Emitter& operator<<(Emitter& emitter, EMITTER_MANIP value) {
  return emitter.SetLocalValue(value);
@@ -1,13 +1,24 @@
 #ifndef EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-namespace YAML
-{
-    struct EmitterNodeType { enum value { None, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap }; };
+namespace YAML {
+struct EmitterNodeType {
+  enum value {
+    None,
+    Property,
+    Scalar,
+    FlowSeq,
+    BlockSeq,
+    FlowMap,
+    BlockMap
+  };
+};
 }

 #endif  // EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,15 +1,15 @@
 #ifndef EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-
 #include <string>

-namespace YAML
-{
+namespace YAML {
 enum EMITTER_MANIP {
  // general manipulators
  Auto,
@@ -67,35 +67,34 @@ namespace YAML
  int value;
 };

-	inline _Indent Indent(int value) {
-		return _Indent(value);
-	}
+inline _Indent Indent(int value) { return _Indent(value); }

 struct _Alias {
  _Alias(const std::string& content_) : content(content_) {}
  std::string content;
 };

-	inline _Alias Alias(const std::string content) {
-		return _Alias(content);
-	}
+inline _Alias Alias(const std::string content) { return _Alias(content); }

 struct _Anchor {
  _Anchor(const std::string& content_) : content(content_) {}
  std::string content;
 };

-	inline _Anchor Anchor(const std::string content) {
-		return _Anchor(content);
-	}
+inline _Anchor Anchor(const std::string content) { return _Anchor(content); }

 struct _Tag {
-		struct Type { enum value { Verbatim, PrimaryHandle, NamedHandle }; };
+  struct Type {
+    enum value {
+      Verbatim,
+      PrimaryHandle,
+      NamedHandle
+    };
+  };

-		explicit _Tag(const std::string& prefix_, const std::string& content_, Type::value type_)
-		: prefix(prefix_), content(content_), type(type_)
-		{
-		}
+  explicit _Tag(const std::string& prefix_, const std::string& content_,
+                Type::value type_)
+      : prefix(prefix_), content(content_), type(type_) {}
  std::string prefix;
  std::string content;
  Type::value type;
@@ -122,28 +121,21 @@ namespace YAML
  std::string content;
 };

-	inline _Comment Comment(const std::string content) {
-		return _Comment(content);
-	}
+inline _Comment Comment(const std::string content) { return _Comment(content); }

 struct _Precision {
-        _Precision(int floatPrecision_, int doublePrecision_): floatPrecision(floatPrecision_), doublePrecision(doublePrecision_) {}
+  _Precision(int floatPrecision_, int doublePrecision_)
+      : floatPrecision(floatPrecision_), doublePrecision(doublePrecision_) {}

  int floatPrecision;
  int doublePrecision;
 };

-    inline _Precision FloatPrecision(int n) {
-        return _Precision(n, -1);
-    }
+inline _Precision FloatPrecision(int n) { return _Precision(n, -1); }

-    inline _Precision DoublePrecision(int n) {
-        return _Precision(-1, n);
-    }
+inline _Precision DoublePrecision(int n) { return _Precision(-1, n); }

-    inline _Precision Precision(int n) {
-        return _Precision(n, n);
-    }
+inline _Precision Precision(int n) { return _Precision(n, n); }
 }

 #endif  // EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
@@ -1,19 +1,19 @@
 #ifndef EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

 #include "yaml-cpp/anchor.h"
 #include <string>

-namespace YAML
-{
+namespace YAML {
 struct Mark;

-	class EventHandler
-	{
+class EventHandler {
 public:
  virtual ~EventHandler() {}

@@ -22,15 +22,17 @@ namespace YAML

  virtual void OnNull(const Mark& mark, anchor_t anchor) = 0;
  virtual void OnAlias(const Mark& mark, anchor_t anchor) = 0;
-		virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value) = 0;
+  virtual void OnScalar(const Mark& mark, const std::string& tag,
+                        anchor_t anchor, const std::string& value) = 0;

-		virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor) = 0;
+  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
+                               anchor_t anchor) = 0;
  virtual void OnSequenceEnd() = 0;

-		virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor) = 0;
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor) = 0;
  virtual void OnMapEnd() = 0;
 };
 }

 #endif  // EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
@@ -1,39 +1,45 @@
 #ifndef EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-
 #include "yaml-cpp/mark.h"
 #include "yaml-cpp/traits.h"
 #include <stdexcept>
 #include <string>
 #include <sstream>

-namespace YAML
-{
+namespace YAML {
 // error messages
-	namespace ErrorMsg
-	{
-		const char * const YAML_DIRECTIVE_ARGS    = "YAML directives must have exactly one argument";
+namespace ErrorMsg {
+const char* const YAML_DIRECTIVE_ARGS =
+    "YAML directives must have exactly one argument";
 const char* const YAML_VERSION = "bad YAML version: ";
 const char* const YAML_MAJOR_VERSION = "YAML major version too large";
 const char* const REPEATED_YAML_DIRECTIVE = "repeated YAML directive";
-		const char * const TAG_DIRECTIVE_ARGS     = "TAG directives must have exactly two arguments";
+const char* const TAG_DIRECTIVE_ARGS =
+    "TAG directives must have exactly two arguments";
 const char* const REPEATED_TAG_DIRECTIVE = "repeated TAG directive";
-		const char * const CHAR_IN_TAG_HANDLE     = "illegal character found while scanning tag handle";
+const char* const CHAR_IN_TAG_HANDLE =
+    "illegal character found while scanning tag handle";
 const char* const TAG_WITH_NO_SUFFIX = "tag handle with no suffix";
 const char* const END_OF_VERBATIM_TAG = "end of verbatim tag not found";
 const char* const END_OF_MAP = "end of map not found";
 const char* const END_OF_MAP_FLOW = "end of map flow not found";
 const char* const END_OF_SEQ = "end of sequence not found";
 const char* const END_OF_SEQ_FLOW = "end of sequence flow not found";
-		const char * const MULTIPLE_TAGS          = "cannot assign multiple tags to the same node";
-		const char * const MULTIPLE_ANCHORS       = "cannot assign multiple anchors to the same node";
-		const char * const MULTIPLE_ALIASES       = "cannot assign multiple aliases to the same node";
-		const char * const ALIAS_CONTENT          = "aliases can't have any content, *including* tags";
+const char* const MULTIPLE_TAGS =
+    "cannot assign multiple tags to the same node";
+const char* const MULTIPLE_ANCHORS =
+    "cannot assign multiple anchors to the same node";
+const char* const MULTIPLE_ALIASES =
+    "cannot assign multiple aliases to the same node";
+const char* const ALIAS_CONTENT =
+    "aliases can't have any content, *including* tags";
 const char* const INVALID_HEX = "bad character found while scanning hex number";
 const char* const INVALID_UNICODE = "invalid unicode: ";
 const char* const INVALID_ESCAPE = "unknown escape character: ";
@@ -41,24 +47,30 @@ namespace YAML
 const char* const DOC_IN_SCALAR = "illegal document indicator in scalar";
 const char* const EOF_IN_SCALAR = "illegal EOF in scalar";
 const char* const CHAR_IN_SCALAR = "illegal character in scalar";
-		const char * const TAB_IN_INDENTATION     = "illegal tab when looking for indentation";
+const char* const TAB_IN_INDENTATION =
+    "illegal tab when looking for indentation";
 const char* const FLOW_END = "illegal flow end";
 const char* const BLOCK_ENTRY = "illegal block entry";
 const char* const MAP_KEY = "illegal map key";
 const char* const MAP_VALUE = "illegal map value";
 const char* const ALIAS_NOT_FOUND = "alias not found after *";
 const char* const ANCHOR_NOT_FOUND = "anchor not found after &";
-		const char * const CHAR_IN_ALIAS          = "illegal character found while scanning alias";
-		const char * const CHAR_IN_ANCHOR         = "illegal character found while scanning anchor";
-		const char * const ZERO_INDENT_IN_BLOCK   = "cannot set zero indentation for a block scalar";
+const char* const CHAR_IN_ALIAS =
+    "illegal character found while scanning alias";
+const char* const CHAR_IN_ANCHOR =
+    "illegal character found while scanning anchor";
+const char* const ZERO_INDENT_IN_BLOCK =
+    "cannot set zero indentation for a block scalar";
 const char* const CHAR_IN_BLOCK = "unexpected character in block scalar";
-		const char * const AMBIGUOUS_ANCHOR       = "cannot assign the same alias to multiple nodes";
+const char* const AMBIGUOUS_ANCHOR =
+    "cannot assign the same alias to multiple nodes";
 const char* const UNKNOWN_ANCHOR = "the referenced anchor is not defined";

 const char* const UNMATCHED_GROUP_TAG = "unmatched group tag";
 const char* const UNEXPECTED_END_SEQ = "unexpected end sequence token";
 const char* const UNEXPECTED_END_MAP = "unexpected end map token";
-		const char * const SINGLE_QUOTED_CHAR     = "invalid character in single-quoted string";
+const char* const SINGLE_QUOTED_CHAR =
+    "invalid character in single-quoted string";
 const char* const INVALID_ANCHOR = "invalid anchor";
 const char* const INVALID_ALIAS = "invalid alias";
 const char* const INVALID_TAG = "invalid tag";
@@ -74,9 +86,11 @@ namespace YAML
  std::string msg;

 private:
-		static const std::string build_what(const Mark& mark, const std::string& msg) {
+  static const std::string build_what(const Mark& mark,
+                                      const std::string& msg) {
    std::stringstream output;
-			output << "yaml-cpp: error at line " << mark.line+1 << ", column " << mark.column+1 << ": " << msg;
+    output << "yaml-cpp: error at line " << mark.line + 1 << ", column "
+           << mark.column + 1 << ": " << msg;
    return output.str();
  }
 };
@@ -1,15 +1,15 @@
 #ifndef MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-
 #include "yaml-cpp/dll.h"

-namespace YAML
-{
+namespace YAML {
 struct YAML_CPP_API Mark {
  Mark() : pos(0), line(0), column(0) {}

@@ -19,7 +19,8 @@ namespace YAML
  int line, column;

 private:
-		Mark(int pos_, int line_, int column_): pos(pos_), line(line_), column(column_) {}
+  Mark(int pos_, int line_, int column_)
+      : pos(pos_), line(line_), column(column_) {}
 };
 }

@@ -1,17 +1,17 @@
 #ifndef NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

 #include "yaml-cpp/dll.h"

-namespace YAML
-{
+namespace YAML {
 // this is basically boost::noncopyable
-	class YAML_CPP_API noncopyable
-	{
+class YAML_CPP_API noncopyable {
 protected:
  noncopyable() {}
  ~noncopyable() {}
@@ -1,15 +1,15 @@
 #ifndef NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-
 #include "yaml-cpp/dll.h"

-namespace YAML
-{
+namespace YAML {
 class Node;

 struct YAML_CPP_API _Null {};
@@ -22,4 +22,3 @@ namespace YAML
 }

 #endif  // NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
@@ -1,18 +1,17 @@
 #ifndef OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-
 #include <string>
 #include <vector>

-namespace YAML
-{
-	class ostream_wrapper
-	{
+namespace YAML {
+class ostream_wrapper {
 public:
  ostream_wrapper();
  explicit ostream_wrapper(std::ostream& stream);
@@ -50,12 +49,14 @@ namespace YAML
 };

 template <std::size_t N>
-	inline ostream_wrapper& operator << (ostream_wrapper& stream, const char (&str)[N]) {
+inline ostream_wrapper& operator<<(ostream_wrapper& stream,
+                                   const char (&str)[N]) {
  stream.write(str, N - 1);
  return stream;
 }

-	inline ostream_wrapper& operator << (ostream_wrapper& stream, const std::string& str) {
+inline ostream_wrapper& operator<<(ostream_wrapper& stream,
+                                   const std::string& str) {
  stream.write(str);
  return stream;
 }
@@ -1,18 +1,18 @@
 #ifndef PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-
 #include "yaml-cpp/dll.h"
 #include "yaml-cpp/noncopyable.h"
 #include <ios>
 #include <memory>

-namespace YAML
-{
+namespace YAML {
 struct Directives;
 struct Mark;
 struct Token;
@@ -20,8 +20,7 @@ namespace YAML
 class Node;
 class Scanner;

-	class YAML_CPP_API Parser: private noncopyable
-	{
+class YAML_CPP_API Parser : private noncopyable {
 public:
  Parser();
  Parser(std::istream& in);
@@ -1,18 +1,18 @@
 #ifndef STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-
 #include <vector>
 #include <list>
 #include <set>
 #include <map>

-namespace YAML
-{
+namespace YAML {
 template <typename Seq>
 inline Emitter& EmitSeq(Emitter& emitter, const Seq& seq) {
  emitter << BeginSeq;
@@ -1,34 +1,113 @@
 #ifndef TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

-
-namespace YAML
-{
+namespace YAML {
 template <typename>
-	struct is_numeric { enum { value = false }; };
+struct is_numeric {
+  enum {
+    value = false
+  };
+};

-	template <> struct is_numeric <char> { enum { value = true }; };
-	template <> struct is_numeric <unsigned char> { enum { value = true }; };
-	template <> struct is_numeric <int> { enum { value = true }; };
-	template <> struct is_numeric <unsigned int> { enum { value = true }; };
-	template <> struct is_numeric <long int> { enum { value = true }; };
-	template <> struct is_numeric <unsigned long int> { enum { value = true }; };
-	template <> struct is_numeric <short int> { enum { value = true }; };
-	template <> struct is_numeric <unsigned short int> { enum { value = true }; };
+template <>
+struct is_numeric<char> {
+  enum {
+    value = true
+  };
+};
+template <>
+struct is_numeric<unsigned char> {
+  enum {
+    value = true
+  };
+};
+template <>
+struct is_numeric<int> {
+  enum {
+    value = true
+  };
+};
+template <>
+struct is_numeric<unsigned int> {
+  enum {
+    value = true
+  };
+};
+template <>
+struct is_numeric<long int> {
+  enum {
+    value = true
+  };
+};
+template <>
+struct is_numeric<unsigned long int> {
+  enum {
+    value = true
+  };
+};
+template <>
+struct is_numeric<short int> {
+  enum {
+    value = true
+  };
+};
+template <>
+struct is_numeric<unsigned short int> {
+  enum {
+    value = true
+  };
+};
 #if defined(_MSC_VER) && (_MSC_VER < 1310)
-	template <> struct is_numeric <__int64> { enum { value = true }; };
-	template <> struct is_numeric <unsigned __int64> { enum { value = true }; };
+template <>
+struct is_numeric<__int64> {
+  enum {
+    value = true
+  };
+};
+template <>
+struct is_numeric<unsigned __int64> {
+  enum {
+    value = true
+  };
+};
 #else
-	template <> struct is_numeric <long long> { enum { value = true }; };
-	template <> struct is_numeric <unsigned long long> { enum { value = true }; };
+template <>
+struct is_numeric<long long> {
+  enum {
+    value = true
+  };
+};
+template <>
+struct is_numeric<unsigned long long> {
+  enum {
+    value = true
+  };
+};
 #endif
-	template <> struct is_numeric <float> { enum { value = true }; };
-	template <> struct is_numeric <double> { enum { value = true }; };
-	template <> struct is_numeric <long double> { enum { value = true }; };
+template <>
+struct is_numeric<float> {
+  enum {
+    value = true
+  };
+};
+template <>
+struct is_numeric<double> {
+  enum {
+    value = true
+  };
+};
+template <>
+struct is_numeric<long double> {
+  enum {
+    value = true
+  };
+};

 template <bool, class T = void>
 struct enable_if_c {
@@ -54,4 +133,3 @@ namespace YAML
 }

 #endif  // TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
@@ -1,7 +1,9 @@
 #ifndef YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif

@@ -1,11 +1,10 @@
 #include "yaml-cpp/binary.h"

-namespace YAML
-{
-    static const char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+namespace YAML {
+static const char encoding[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

-    std::string EncodeBase64(const unsigned char *data, std::size_t size)
-    {
+std::string EncodeBase64(const unsigned char *data, std::size_t size) {
  const char PAD = '=';

  std::string ret;
@@ -44,26 +43,26 @@ namespace YAML
 }

 static const unsigned char decoding[] = {
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
-        255,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63,
-         52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255,  0,255,255,
-        255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
-         15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255,
-        255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-         41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,255,255,255,255,255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
-    };
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62,  255,
+    255, 255, 63,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255,
+    255, 0,   255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
+    10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
+    25,  255, 255, 255, 255, 255, 255, 26,  27,  28,  29,  30,  31,  32,  33,
+    34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
+    49,  50,  51,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, };

-    std::vector<unsigned char> DecodeBase64(const std::string& input)
-    {
+std::vector<unsigned char> DecodeBase64(const std::string &input) {
  typedef std::vector<unsigned char> ret_type;
  if (input.empty())
    return ret_type();
--- a/Show More
+++ b/Show More