yaml-cpp 2021-07-10 (0579ae3d)

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 {

using anchor_t = std::size_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 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

#pragma once

#endif

#include <vector>

#include "../anchor.h"

namespace YAML {

/**

 * An object that stores and retrieves values correlating to {@link anchor_t}

 * values.

 *

 * <p>Efficient implementation that can make assumptions about how

 * {@code anchor_t} values are assigned by the {@link Parser} class.

 */

template <class T>

class AnchorDict {

 public:

  AnchorDict() : m_data{} {}

  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]; }

 private:

  std::vector<T> m_data;

};

}  // namespace YAML

#endif  // ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66

#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

#pragma once

#endif

#include "yaml-cpp/mark.h"

#include <string>

namespace YAML {

class Parser;

// GraphBuilderInterface

// . Abstraction of node creation

// . pParentNode is always nullptr or the return value of one of the NewXXX()

//   functions.

class GraphBuilderInterface {

 public:

  virtual ~GraphBuilderInterface() = 0;

  // 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;

  // Create and return a new sequence node

  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;

  // 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;

  }

};

// Typesafe wrapper for GraphBuilderInterface.  Assumes that Impl defines

// Node, Sequence, and Map types.  Sequence and Map must derive from Node

// (unless Node is defined as void).  Impl must also implement function with

// all of the same names as the virtual functions in GraphBuilderInterface

// -- including the ones with default implementations -- but with the

// prototypes changed to accept an explicit Node*, Sequence*, or Map* where

// appropriate.

template <class Impl>

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

    Map *pMap = nullptr;

    Sequence *pSeq = nullptr;

    Node *pNode = nullptr;

    // Type consistency checks

    pNode = pMap;

    pNode = pSeq;

  }

  GraphBuilderInterface &AsBuilderInterface() { return *this; }

  virtual void *NewNull(const Mark &mark, void *pParentNode) {

    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 *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));

  }

  virtual void SequenceComplete(void *pSequence) {

    m_impl.SequenceComplete(AsSequence(pSequence));

  }

  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 *AnchorReference(const Mark &mark, void *pNode) {

    return CheckType<Node>(m_impl.AnchorReference(mark, AsNode(pNode)));

  }

 private:

  Impl &m_impl;

  // Static check for pointer to T

  template <class T, class U>

  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 Map *AsMap(void *pMap) { return static_cast<Map *>(pMap); }

};

void *BuildGraphOfNextDocument(Parser &parser,

                               GraphBuilderInterface &graphBuilder);

template <class Impl>

typename Impl::Node *BuildGraphOfNextDocument(Parser &parser, Impl &impl) {

  GraphBuilder<Impl> graphBuilder(impl);

  return static_cast<typename Impl::Node *>(

      BuildGraphOfNextDocument(parser, graphBuilder));

}

}

#endif  // GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66