yaml-cpp: Prep for a clean update

Copyright (c) 2008-2015 Jesse Beder.

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in

all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

THE SOFTWARE.

#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

#pragma once

#endif

#include <cstddef>

namespace YAML {

typedef std::size_t anchor_t;

const anchor_t NullAnchor = 0;

}

#endif  // ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

#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

#pragma once

#endif

#include <string>

#include <vector>

#include "yaml-cpp/dll.h"

namespace YAML {

YAML_CPP_API std::string EncodeBase64(const unsigned char *data,

                                      std::size_t size);

YAML_CPP_API std::vector<unsigned char> DecodeBase64(const std::string &input);

class YAML_CPP_API Binary {

 public:

  Binary(const unsigned char *data_, std::size_t size_)

      : m_data{}, m_unownedData(data_), m_unownedSize(size_) {}

  Binary() : Binary(nullptr, 0) {}

  Binary(const Binary &) = default;

  Binary(Binary &&) = default;

  Binary &operator=(const Binary &) = default;

  Binary &operator=(Binary &&) = default;

  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;

  }

  void swap(std::vector<unsigned char> &rhs) {

    if (m_unownedData) {

      m_data.swap(rhs);

      rhs.clear();

      rhs.resize(m_unownedSize);

      std::copy(m_unownedData, m_unownedData + m_unownedSize, rhs.begin());

      m_unownedData = nullptr;

      m_unownedSize = 0;

    } else {

      m_data.swap(rhs);

    }

  }

  bool operator==(const Binary &rhs) const {

    const std::size_t s = size();

    if (s != rhs.size())

      return false;

    const unsigned char *d1 = data();

    const unsigned char *d2 = rhs.data();

    for (std::size_t i = 0; i < s; i++) {

      if (*d1++ != *d2++)

        return false;

    }

    return true;

  }

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

 private:

  std::vector<unsigned char> m_data;

  const unsigned char *m_unownedData;

  std::size_t m_unownedSize;

};

}  // namespace YAML

#endif  // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66

#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

#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 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)

//	#pragma message( "Defining YAML_CPP_API for DLL export" )

#define YAML_CPP_API __declspec(dllexport)

#else  // yaml_cpp_EXPORTS

//	#pragma message( "Defining YAML_CPP_API for DLL import" )

#define YAML_CPP_API __declspec(dllimport)

#endif  // yaml_cpp_EXPORTS

#else   // YAML_CPP_DLL

#define YAML_CPP_API

#endif  // YAML_CPP_DLL

#endif  // DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

#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

#pragma once

#endif

#include <stack>

#include "yaml-cpp/anchor.h"

#include "yaml-cpp/emitterstyle.h"

#include "yaml-cpp/eventhandler.h"

namespace YAML {

struct Mark;

}  // namespace YAML

namespace YAML {

class Emitter;

class EmitFromEvents : public EventHandler {

 public:

  EmitFromEvents(Emitter& emitter);

  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:

  void BeginNode();

  void EmitProps(const std::string& tag, anchor_t anchor);

 private:

  Emitter& m_emitter;

  struct State {

    enum value { WaitingForSequenceEntry, WaitingForKey, WaitingForValue };

  };

  std::stack<State::value> m_stateStack;

};

}

#endif  // EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66