11 |
12 | #include "../anchor.h"
13 |
14 | namespace YAML {
15 | /**
16 | * An object that stores and retrieves values correlating to {@link anchor_t}
17 | * values.
18 | *
19 | * Efficient implementation that can make assumptions about how
20 | * {@code anchor_t} values are assigned by the {@link Parser} class.
21 | */
22 | template
23 | class AnchorDict {
24 | public:
25 | AnchorDict() : m_data{} {}
26 | void Register(anchor_t anchor, T value) {
27 | if (anchor > m_data.size()) {
28 | m_data.resize(anchor);
29 | }
30 | m_data[anchor - 1] = value;
31 | }
32 |
33 | T Get(anchor_t anchor) const { return m_data[anchor - 1]; }
34 |
35 | private:
36 | std::vector m_data;
37 | };
38 | } // namespace YAML
39 |
40 | #endif // ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
41 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/dll.h:
--------------------------------------------------------------------------------
1 | #ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
2 | #define DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | // The following ifdef block is the standard way of creating macros which make
11 | // exporting from a DLL simpler. All files within this DLL are compiled with the
12 | // yaml_cpp_EXPORTS symbol defined on the command line. This symbol should not
13 | // be defined on any project that uses this DLL. This way any other project
14 | // whose source files include this file see YAML_CPP_API functions as being
15 | // imported from a DLL, whereas this DLL sees symbols defined with this macro as
16 | // being exported.
17 | #undef YAML_CPP_API
18 |
19 | #ifdef YAML_CPP_DLL // Using or Building YAML-CPP DLL (definition defined
20 | // manually)
21 | #ifdef yaml_cpp_EXPORTS // Building YAML-CPP DLL (definition created by CMake
22 | // or defined manually)
23 | // #pragma message( "Defining YAML_CPP_API for DLL export" )
24 | #define YAML_CPP_API __declspec(dllexport)
25 | #else // yaml_cpp_EXPORTS
26 | // #pragma message( "Defining YAML_CPP_API for DLL import" )
27 | #define YAML_CPP_API __declspec(dllimport)
28 | #endif // yaml_cpp_EXPORTS
29 | #else // YAML_CPP_DLL
30 | #define YAML_CPP_API
31 | #endif // YAML_CPP_DLL
32 |
33 | #endif // DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
34 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/emitterdef.h:
--------------------------------------------------------------------------------
1 | #ifndef EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
2 | #define EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | namespace YAML {
11 | struct EmitterNodeType {
12 | enum value { NoType, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap };
13 | };
14 | }
15 |
16 | #endif // EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
17 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/emitterstyle.h:
--------------------------------------------------------------------------------
1 | #ifndef EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
2 | #define EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | namespace YAML {
11 | struct EmitterStyle {
12 | enum value { Default, Block, Flow };
13 | };
14 | }
15 |
16 | #endif // EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
17 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/eventhandler.h:
--------------------------------------------------------------------------------
1 | #ifndef EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
2 | #define EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | #include
11 |
12 | #include "yaml-cpp/anchor.h"
13 | #include "yaml-cpp/emitterstyle.h"
14 |
15 | namespace YAML {
16 | struct Mark;
17 |
18 | class EventHandler {
19 | public:
20 | virtual ~EventHandler() = default;
21 |
22 | virtual void OnDocumentStart(const Mark& mark) = 0;
23 | virtual void OnDocumentEnd() = 0;
24 |
25 | virtual void OnNull(const Mark& mark, anchor_t anchor) = 0;
26 | virtual void OnAlias(const Mark& mark, anchor_t anchor) = 0;
27 | virtual void OnScalar(const Mark& mark, const std::string& tag,
28 | anchor_t anchor, const std::string& value) = 0;
29 |
30 | virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
31 | anchor_t anchor, EmitterStyle::value style) = 0;
32 | virtual void OnSequenceEnd() = 0;
33 |
34 | virtual void OnMapStart(const Mark& mark, const std::string& tag,
35 | anchor_t anchor, EmitterStyle::value style) = 0;
36 | virtual void OnMapEnd() = 0;
37 |
38 | virtual void OnAnchor(const Mark& /*mark*/,
39 | const std::string& /*anchor_name*/) {
40 | // empty default implementation for compatibility
41 | }
42 | };
43 | } // namespace YAML
44 |
45 | #endif // EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
46 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/mark.h:
--------------------------------------------------------------------------------
1 | #ifndef MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
2 | #define MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | #include "yaml-cpp/dll.h"
11 |
12 | namespace YAML {
13 | struct YAML_CPP_API Mark {
14 | Mark() : pos(0), line(0), column(0) {}
15 |
16 | static const Mark null_mark() { return Mark(-1, -1, -1); }
17 |
18 | bool is_null() const { return pos == -1 && line == -1 && column == -1; }
19 |
20 | int pos;
21 | int line, column;
22 |
23 | private:
24 | Mark(int pos_, int line_, int column_)
25 | : pos(pos_), line(line_), column(column_) {}
26 | };
27 | }
28 |
29 | #endif // MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
30 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/node/detail/iterator_fwd.h:
--------------------------------------------------------------------------------
1 | #ifndef VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
2 | #define VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | #include "yaml-cpp/dll.h"
11 | #include
12 | #include
13 | #include
14 |
15 | namespace YAML {
16 |
17 | namespace detail {
18 | struct iterator_value;
19 | template
20 | class iterator_base;
21 | }
22 |
23 | using iterator = detail::iterator_base;
24 | using const_iterator = detail::iterator_base;
25 | }
26 |
27 | #endif // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
28 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/node/detail/memory.h:
--------------------------------------------------------------------------------
1 | #ifndef VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
2 | #define VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | #include
11 |
12 | #include "yaml-cpp/dll.h"
13 | #include "yaml-cpp/node/ptr.h"
14 |
15 | namespace YAML {
16 | namespace detail {
17 | class node;
18 | } // namespace detail
19 | } // namespace YAML
20 |
21 | namespace YAML {
22 | namespace detail {
23 | class YAML_CPP_API memory {
24 | public:
25 | memory() : m_nodes{} {}
26 | node& create_node();
27 | void merge(const memory& rhs);
28 |
29 | private:
30 | using Nodes = std::set;
31 | Nodes m_nodes;
32 | };
33 |
34 | class YAML_CPP_API memory_holder {
35 | public:
36 | memory_holder() : m_pMemory(new memory) {}
37 |
38 | node& create_node() { return m_pMemory->create_node(); }
39 | void merge(memory_holder& rhs);
40 |
41 | private:
42 | shared_memory m_pMemory;
43 | };
44 | } // namespace detail
45 | } // namespace YAML
46 |
47 | #endif // VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
48 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/node/emit.h:
--------------------------------------------------------------------------------
1 | #ifndef NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
2 | #define NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | #include
11 | #include
12 |
13 | #include "yaml-cpp/dll.h"
14 |
15 | namespace YAML {
16 | class Emitter;
17 | class Node;
18 |
19 | /**
20 | * Emits the node to the given {@link Emitter}. If there is an error in writing,
21 | * {@link Emitter#good} will return false.
22 | */
23 | YAML_CPP_API Emitter& operator<<(Emitter& out, const Node& node);
24 |
25 | /** Emits the node to the given output stream. */
26 | YAML_CPP_API std::ostream& operator<<(std::ostream& out, const Node& node);
27 |
28 | /** Converts the node to a YAML string. */
29 | YAML_CPP_API std::string Dump(const Node& node);
30 | } // namespace YAML
31 |
32 | #endif // NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
33 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/node/iterator.h:
--------------------------------------------------------------------------------
1 | #ifndef VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
2 | #define VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | #include "yaml-cpp/dll.h"
11 | #include "yaml-cpp/node/node.h"
12 | #include "yaml-cpp/node/detail/iterator_fwd.h"
13 | #include "yaml-cpp/node/detail/iterator.h"
14 | #include
15 | #include
16 | #include
17 |
18 | namespace YAML {
19 | namespace detail {
20 | struct iterator_value : public Node, std::pair {
21 | iterator_value() = default;
22 | explicit iterator_value(const Node& rhs)
23 | : Node(rhs),
24 | std::pair(Node(Node::ZombieNode), Node(Node::ZombieNode)) {}
25 | explicit iterator_value(const Node& key, const Node& value)
26 | : Node(Node::ZombieNode), std::pair(key, value) {}
27 | };
28 | }
29 | }
30 |
31 | #endif // VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
32 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/node/ptr.h:
--------------------------------------------------------------------------------
1 | #ifndef VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
2 | #define VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | #include "yaml-cpp/dll.h"
11 | #include
12 |
13 | namespace YAML {
14 | namespace detail {
15 | class node;
16 | class node_ref;
17 | class node_data;
18 | class memory;
19 | class memory_holder;
20 |
21 | using shared_node = std::shared_ptr;
22 | using shared_node_ref = std::shared_ptr;
23 | using shared_node_data = std::shared_ptr;
24 | using shared_memory_holder = std::shared_ptr;
25 | using shared_memory = std::shared_ptr;
26 | }
27 | }
28 |
29 | #endif // VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
30 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/node/type.h:
--------------------------------------------------------------------------------
1 | #ifndef VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
2 | #define VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | namespace YAML {
11 | struct NodeType {
12 | enum value { Undefined, Null, Scalar, Sequence, Map };
13 | };
14 | }
15 |
16 | #endif // VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
17 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/noexcept.h:
--------------------------------------------------------------------------------
1 | #ifndef NOEXCEPT_H_768872DA_476C_11EA_88B8_90B11C0C0FF8
2 | #define NOEXCEPT_H_768872DA_476C_11EA_88B8_90B11C0C0FF8
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | // This is here for compatibility with older versions of Visual Studio
11 | // which don't support noexcept.
12 | #if defined(_MSC_VER) && _MSC_VER < 1900
13 | #define YAML_CPP_NOEXCEPT _NOEXCEPT
14 | #else
15 | #define YAML_CPP_NOEXCEPT noexcept
16 | #endif
17 |
18 | #endif
19 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/null.h:
--------------------------------------------------------------------------------
1 | #ifndef NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
2 | #define NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | #include "yaml-cpp/dll.h"
11 | #include
12 |
13 | namespace YAML {
14 | class Node;
15 |
16 | struct YAML_CPP_API _Null {};
17 | inline bool operator==(const _Null&, const _Null&) { return true; }
18 | inline bool operator!=(const _Null&, const _Null&) { return false; }
19 |
20 | YAML_CPP_API bool IsNull(const Node& node); // old API only
21 | YAML_CPP_API bool IsNullString(const std::string& str);
22 |
23 | extern YAML_CPP_API _Null Null;
24 | }
25 |
26 | #endif // NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
27 |
--------------------------------------------------------------------------------
/third-party/yaml-cpp/include/yaml-cpp/stlemitter.h:
--------------------------------------------------------------------------------
1 | #ifndef STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
2 | #define STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
3 |
4 | #if defined(_MSC_VER) || \
5 | (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
6 | (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
7 | #pragma once
8 | #endif
9 |
10 | #include
11 | #include
12 | #include
13 | #include