- Don't eagerly convert key to std::string
- Make const char* keys streamable when exception is thrown
- Don't create a temporary string when comparing a const char* key
For completeness I've implemented escaping for characters outside the
basic multilingual plane, but it doesn't get used (as there's no
EscapeAsAsciiJson emitter option implemented).
Inside of a sequence or map, `YAML::Newline` wouldn't reset the collection state, which would cause behavior like this:
```
nodeA:
k: [{i: 0},
{i:1},
]NodeB:
k: [{i: 0},
{i:1},
]
```
* partially fix clang compilation
Missing header and mistaken algorithm usage.
Also removed it name from range loops. It's not correct.
Signed-off-by: Rosen Penev <rosenp@gmail.com>
* run through clang's -Wrange-loop-analysis
Some range loops should not use references as they need to copy.
Signed-off-by: Rosen Penev <rosenp@gmail.com>
* manual range loop conversions
Signed-off-by: Rosen Penev <rosenp@gmail.com>
Library debug postfix might not be suitable for cross platform project, and usually require extra work of link against prebuilt yaml-cpp.
Generally, Xcode project output library to these directories:
Debug
Release
Debug-iphoneos
Release-iphoneos
Debug-iphonesimulator
Release-iphonesimulator
Another Xcode project usually configured its build setting as follow, and expects library name to be same between Release and Debug
LIBRARY_SEARCH_PATHS=$(CONFIGURATION)$(EFFECT_PLATFORM_NAME)
OTHER_LDFLAGS= $(inherited) -lyaml-cpp
* Copied Tutorial from Google Code wiki.
* Initial Home page
* Copied How To Parse A Document from Google Code wiki
* Updated How To Parse A Document (markdown)
* Updated How To Parse A Document (markdown)
* Updated How To Parse A Document (Old API) (markdown)
* Copied How To Emit YAML from Google Code wiki
* Copied Breaking Changes from Google Code wiki
* Copied Strings from Google Code wiki
* Updated Strings (markdown)
* Updated Home (markdown)
* Fix typo.
* Updated Breaking Changes (markdown)
* Updated How To Parse A Document (Old API) (markdown)
* Updated Breaking Changes (markdown)
* Move wiki content to docs/
* Improve markdown and add colored code syntax
Co-authored-by: Jesse Beder <jbeder+github@gmail.com>
The explicitly defaulted or implemented move constructors and assignment
operators are made "noexcept".
Bugfix:
* src/stream.cpp Stream::Stream() char_traits::int_type intro[4] is
now aggregate-initialized (to zero) to avoid UB.
Minor changes:
* Using std::isinf() and std::signbit() instead of comparing for
equality with infinity.
* src/streamcharsource.h: Added #include "stream.h".
* src/stream.h: Forward declaring "class StreamCharSource".
* Some implicit casting changed into static_cast's.
Signed-off-by: Ted Lyngmo <ted@lyncon.se>
This is in preparation for other patches that will make use of the
macro. The patch also removes #undef:ing the macro after its been
used to not make the header inclusion order critical. Otherwise,
the new header would always have to be the last of the yaml-cpp
headers to be included.
This happens whenever in a macro you use some "if" block, and don't use curly braces {},
as the macro is expanded on a single line, not on several lines. So just add the missing
curly braces to please gcc.
In file included from /remote/users/mlamesch/CloneFromPlatinum/yamlcpp/osp/Yamlcpp/18-0-0-5/include/yaml-cpp/yaml.h:18,
from src/TestYaml.cpp:2:
/remote/users/mlamesch/CloneFromPlatinum/yamlcpp/osp/Yamlcpp/18-0-0-5/include/yaml-cpp/node/convert.h: In static member function static bool YAML::convert<int>::decode(const YAML::Node&, int&):
/remote/users/mlamesch/CloneFromPlatinum/yamlcpp/osp/Yamlcpp/18-0-0-5/include/yaml-cpp/node/convert.h:139:1: error: this if clause does not guard... [-Werror=misleading-indentation]
YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(int);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Example of how someone might consume yaml-cpp with bazel:
cc_binary(
name = "example",
srcs = ["example.cc"],
deps = ["@com_github_jbeder_yaml_cpp//:yaml-cpp"],
)
Remove 2.6-isms
Remove 2.8-isms
Bump CMake minimum version to 3.4
Disable some options when used as a subdirectory
Use `CONFIGURE_DEPENDS` with `file(GLOB)` when possible
Backport CMake 3.15's MSVC_RUNTIME_LIBRARY setting.
Set all compile options as generator expressions.
Set all find-package files to be installed to the correct file.
Remove `export(PACKAGE)`, as this has been deprecated.
Remove fat binary support
Remove manual setting of iPhone settings. These should be set by parent
projects.
Remove use of ExternalProject for a local use
Conditionally remove format target unless clang-format is found
* CMake: Prefix options with "YAML" and hide platform-specific options
When including yaml-cpp as a subproject, some option names can conflict with other projects.
(1) Make sure the yaml-cpp options are prefixed with YAML
(2) Hide platform-specific options when possible to avoid cluttering the cmake option list
* Update docs for change from BUILD_SHARED_LIBS to YAML_BUILD_SHARED_LIBS
Setting CMAKE_CXX_STANDARD and CMAKE_CXX_STANDARD_REQUIRED directly is problematic when including yaml-cpp as a subproject.
The proper way is to set these per-target.
Invalid access via operator[] or as<> will now print the offending key, if possible.
For example:
a:
x: 1
y: 2
node["a"]["z"].as<int>()
will say that the key "z" was invalid.
* Add compilation flags: -Wshadow -Weffc++ -pedantic -pedantic-errors
* Delete implicit copy & move constructors & assignment operators
in classes with pointer data members.
* An exception to the above: Add default copy & move constructors &
assignment operators for the Binary class.
* Convert boolean RegEx operators to binary operators.
* Initialize all members in all classes in ctors.
* Let default ctor delegate to the converting ctor in
Binary and RegEx
* Don't change any tests except regex_test (as a result of the change
to binary operators).
Note: https://bugzilla.redhat.com/show_bug.cgi?id=1544675 makes
-Weffc++ report a false positive in "include/yaml-cpp/node/impl.h".
NDK now uses ninja for building but yaml-cpp would emit the “ninja: error: build.ninja:326: bad $-escape (literal $ must be written as $$)” error due to syntax error in the generated build.ninja file. Related issue: https://github.com/jbeder/yaml-cpp/issues/630
The issue is that numbers like
2.01 or 3.01 can not be precisely represented with binary floating point
numbers.
This replaces all occurrences of 'std::numeric_limits<T>::digits10 + 1' with
'std::numeric_limits<T>::max_digits10'.
Background:
Using 'std::numeric_limits<T>::digits10 + 1' is not precise enough.
Converting a 'float' into a 'string' and back to a 'float' will not always
produce the original 'float' value. To guarantee that the 'string'
representation has sufficient precision the value
'std::numeric_limits<T>::max_digits10' has to be used.
* Removed an expression which is always true
* The second expression (ch is space) is removed because the first one contains space 0x20
* nextEmptyLine is always false so it is removed from the expression
Let CMake handle the default optimizations for various configurations. We don't need to override them. In fact, overriding them makes it impossible for users to override them themselves.
Roll-forward of c90c08ccc9 "Revert "Improvements to CMake buildsystem (#563)""
NEW:
* Replace CMAKE_SOURCE_DIR with CMAKE_CURRENT_SOURCE_DIR
Fixes#612 when yaml-cpp is used as a git submodule.
ORIGINAL:
* Move enable_testing() into proper place
* Added CMake's checks for C++11 standards
Raised minimal version of CMake to 3.1, since on old systems there no
decent compilers that supports c++11.
Closes#377.
* Externalize googletest project
Externalize gtest to avoid installation, fixes#539.
* Remove defined cmake_policies
CMP0012 - OLD marked as deprecated for >=cmake-3.1 and will be removed
CMP0015 - does not affect to build process
CMP0042 - already NEW for >=cmake-3.1
Fixes#505
* Fix compiling in Windows MSVC
* Move enable_testing() into proper place
* Added CMake's checks for C++11 standards
Raised minimal version of CMake to 3.1, since on old systems there no
decent compilers that supports c++11.
Closes#377.
* Externalize googletest project
Externalize gtest to avoid installation, fixes#539.
* Remove defined cmake_policies
CMP0012 - OLD marked as deprecated for >=cmake-3.1 and will be removed
CMP0015 - does not affect to build process
CMP0042 - already NEW for >=cmake-3.1
Fixes#505
* Fix compiling in Windows MSVC
It was incorrectly left at 0.6.0 when 0.6.1 was released, so this needs to be done to make it consistent between the tagged version and the CMake version.
Don't build tests if the confusingly named YAML_CPP_BUILD_TOOLS is ON.
Instead, add a new option that controls only if the tests are built.
(Also, default tests to OFF.)
Fix some virtual methods of NullEventHandler that were apparently
intended to overload base class methods, but did not. Add override
keyword to prevent these getting out of sync again.
Add explicit virtual dtor to GraphBuilderInterface. This avoids tripping
a -Wnon-virtual-dtor warning, and also ensures that the correct
(virtual) dtor is called if an instance is deleted via a pointer to the
base type.
Remove use of CMAKE_INSTALL_PREFIX when specifying install destinations.
It is preferred that install destinations are specified as relative
paths, not absolute paths. This is also needed to create relocatable
installs, and thus should fix#526.
Don't install LIBRARIES on Windows to `bin`; they belong in `lib`. (This
appears to have been done in a mistaken attempt to install the DLL's to
`bin`, which do need to be there, but RUNTIME DESTINATION already takes
care of this.)
This way it's possible to build using older MSVC (<13) that don't
support this yet. Macro is undefined in each file where it is used so it
should stack well with other libs and sources.
* Fixed compiler warning -Wdeprecated with clang.
Starting with C++11 implicit copy-constructors are deprecated when the class
has a user defined destructor.
* Fixes -Wdocumentation warning.
yaml-cpp/parser.h:50:65: warning: parameter 'eventHandler}.' not found in the function
declaration [-Wdocumentation]
* Handles the next document by calling events on the {@param eventHandler}.
^~~~~~~~~~~~~~
yaml-cpp/parser.h:50:65: note: did you mean 'eventHandler'?
* Handles the next document by calling events on the {@param eventHandler}.
^~~~~~~~~~~~~~
eventHandler
Previously, just referencing the next element in the sequence (and so constructing it, as an undefined element) would allow you to skip defining an element without turning the sequence into a map. E.g:
node[0] = "foo"; // sequence of size 1
node[1]; // sequence of size 1, with an undefined element at 1
node[2] = "bar"; // FIX: should be map of size 2 (since there's no element at index 1)
CMake policy CMP0042 changes the default value of the MACOSX_RPATH target property to TRUE, therefore setting the directory portion of the install_name field of a shared library to be @rpath on OS X.
* Change node_map type from map<ptr,ptr> to vector<pair<ptr,ptr>>
Map nodes are now iterated over in document order.
* Change insert_map_pair to always append
Always append in insert_map_pair even if the key is already present.
This breaks the behavior of force_insert which now always inserts KVs
even if the key is already present. The first insert for duplicated keys
now takes precedence for lookups.
This adds yaml-cpp-config.cmake, yaml-cpp-config-version.cmake, and
yaml-cpp-targets.cmake to the cmake install. As a result, cmake's
find_package can easily find yaml-cpp for software that depends on
yaml-cpp.
Add code to install cmake files to $CMAKE_INSTALL_PREFIX/CMake on
Windows, which is the de-facto standard.
Closesjbeder/yaml-cpp#336jbeder/yaml-cpp#127
This improves performance on the test.yaml attached to #158 by about
25% on my machine as compared to the previous commit (0.25s -> 0.20s),
as measured by `time build/util/parse < test.yaml > /dev/null`.
This improves performance on the test.yaml attached to #158 by about
35% on my machine (0.39s -> 0.25s), as measured by
`time build/util/parse < test.yaml > /dev/null`.
On my Macbook Pro, reading from standard input incurs a bunch of locking
overhead, which complicates profiling and (IMO) adds noise to
results. This adds the option to read from a file, which doesn't incur
this overhead.
- Adds 'std=c++11' compiler flags
- Replaces boost::type_traits with std::type_traits
- Replaces boost::shared_ptr with std::shared_ptr
- Replaces std::auto_ptr with std::unique_ptr
- Replaces raw pointers with std::unique_ptr in ptr_vector, ptr_stack, and SettingChanges
- Replaces boost::noncopyable with deleted copy and assignment operators
- Replaces boost::next with std::next
- Replaces boost::enable_if with std::enable_if
- Replaces boost::is_convertible with std::is_convertible
- Replaces ptrdiff_t with std::ptrdiff_t
- Replaces boost::iterator_facade and boost::iterator_adaptor with std::iterator, borrowing the 'proxy reference' technique from boost
- Removes Boost dependency from CMakeLists
- Formats changed files using clang-format
"const Node Node::operator[](const Key& key) const" changed from
returning new empty node if the key was missing in 0.5.1 to returning
a shared 'zombie' node in 0.5.2 to resolve a memory leak.
(Specifically 1025f76df1 was where this
was introduced)
This caused some regressions where this 'zombie' object threw exceptions
in some functions where the 'empty' object would not.
This change fixes the Node::as(fallback) method (to return the
'fallback' instead of throwing an exception) and the
Node::begin()/Node::end() methods to return default-constructed
iterators (so begin() == end() in such cases) instead of another
exception.
- Update the call to equals() in node_data::remove() to match the new implementation
- Add unit test for node::remove() to catch this type of bug in the future
option(YAML_CPP_SUPPORT_MERGE_KEYS"Support YAML merge keys ('<<') in yaml-cpp's executable targets. Use '#define YAML_CPP_SUPPORT_MERGE_KEYS' instead when linking from another project."OFF)
This project is formatted with [clang-format][fmt] using the style file at the root of the repository. Please run clang-format before sending a pull request.
In general, try to follow the style of surrounding code. We mostly follow the [Google C++ style guide][cpp-style].
Commit messages should be in the imperative mood, as described in the [Git contributing file][git-contrib]:
> Describe your changes in imperative mood, e.g. "make xyzzy do frotz"
> instead of "[This patch] makes xyzzy do frotz" or "[I] changed xyzzy
> to do frotz", as if you are giving orders to the codebase to change
Please verify the tests pass by running the target `tests/run_tests`.
If you are adding functionality, add tests accordingly.
# Pull request process
Every pull request undergoes a code review. Unfortunately, github's code review process isn't great, but we'll manage. During the code review, if you make changes, add new commits to the pull request for each change. Once the code review is complete, rebase against the master branch and squash into a single commit.
yaml-cpp is a [YAML](http://www.yaml.org/) parser and emitter in C++ matching the [YAML 1.2 spec](http://www.yaml.org/spec/1.2/spec.html).
To get a feel for how it can be used, see the [Tutorial](https://github.com/jbeder/yaml-cpp/wiki/Tutorial) or [How to Emit YAML](https://github.com/jbeder/yaml-cpp/wiki/How-To-Emit-YAML). For the old API (version < 0.5.0), see [How To Parse A Document](https://github.com/jbeder/yaml-cpp/wiki/How-To-Parse-A-Document-(Old-API)).
# Problems? #
If you find a bug, post an [issue](https://github.com/jbeder/yaml-cpp/issues)! If you have questions about how to use yaml-cpp, please post it on http://stackoverflow.com and tag it [`yaml-cpp`](http://stackoverflow.com/questions/tagged/yaml-cpp).
# How to Build #
yaml-cpp uses [CMake](http://www.cmake.org) to support cross-platform building. The basic steps to build are:
1. Download and install [CMake](http://www.cmake.org) (Resources -> Download).
**Note:** If you don't use the provided installer for your platform, make sure that you add CMake's bin folder to your path.
* The `generator` is whatever type of build system you'd like to use. To see a full list of generators on your platform, just run `cmake` (with no arguments). For example:
* On Windows, you might use "Visual Studio 12 2013" to generate a Visual Studio 2013 solution or "Visual Studio 14 2015 Win64" to generate a 64-bit Visual Studio 2015 solution.
* On OS X, you might use "Xcode" to generate an Xcode project
* On a UNIX-y system, simply omit the option to generate a makefile
* yaml-cpp defaults to building a static library, but you may build a shared library by specifying `-DYAML_BUILD_SHARED_LIBS=ON`.
* For more options on customizing the build, see the [CMakeLists.txt](https://github.com/jbeder/yaml-cpp/blob/master/CMakeLists.txt) file.
4. Build it!
5. To clean up, just remove the `build` directory.
# Recent Release #
[yaml-cpp 0.6.0](https://github.com/jbeder/yaml-cpp/releases/tag/yaml-cpp-0.6.0) has been released! This release requires C++11, and no longer depends on Boost.
[yaml-cpp 0.3.0](https://github.com/jbeder/yaml-cpp/releases/tag/release-0.3.0) is still available if you want the old API.
**The old API will continue to be supported, and will still receive bugfixes!** The 0.3.x and 0.4.x versions will be old API releases, and 0.5.x and above will all be new API releases.
# API Documentation
The autogenerated API reference is hosted on [CodeDocs](https://codedocs.xyz/jbeder/yaml-cpp/index.html)
# Third Party Integrations
The following projects are not officially supported:
*`Node::Identity()` is removed, and `Node::IsAlias()` and `Node::IsReferenced()` have been merged into `Node::IsAliased()`. The reason: there's no reason to distinguish an alias node from its anchor - whichever happens to be emitted first will be the anchor, and the rest will be aliases.
*`Node::Read<T>` is now `Node::to<T>`. This wasn't a documented function, so it shouldn't break anything.
*`Node`'s comparison operators (for example, `operator == (const Node&, const T&)`) have all been removed. These weren't documented either (they were just used for the tests), so this shouldn't break anything either.
* The emitter no longer produces the document start by default - if you want it, you can supply it with the manipulator `YAML::BeginDoc`.
The model for emitting YAML is `std::ostream` manipulators. A `YAML::Emitter` objects acts as an output stream, and its output can be retrieved through the `c_str()` function (as in `std::string`). For a simple example:
```cpp
#include"yaml-cpp/yaml.h"
intmain()
{
YAML::Emitterout;
out<<"Hello, World!";
std::cout<<"Here's the output YAML:\n"<<out.c_str();// prints "Hello, World!"
return0;
}
```
# Simple Lists and Maps #
A `YAML::Emitter` object acts as a state machine, and we use manipulators to move it between states. Here's a simple sequence:
We also overload `operator << ` for `YAML::Node`s in both APIs, so you can output existing Nodes. Of course, Nodes in the old API are read-only, so it's tricky to emit them if you want to modify them. So use the new API!
# Output Encoding #
The output is always UTF-8. By default, yaml-cpp will output as much as it can without escaping any characters. If you want to restrict the output to ASCII, use the manipulator `YAML::EscapeNonAscii`:
```cpp
emitter.SetOutputCharset(YAML::EscapeNonAscii);
```
# Lifetime of Manipulators #
Manipulators affect the **next** output item in the stream. If that item is a `BeginSeq` or `BeginMap`, the manipulator lasts until the corresponding `EndSeq` or `EndMap`. (However, within that sequence or map, you can override the manipulator locally, etc.; in effect, there's a "manipulator stack" behind the scenes.)
If you want to permanently change a setting, there are global setters corresponding to each manipulator, e.g.:
```cpp
YAML::Emitterout;
out.SetIndent(4);
out.SetMapStyle(YAML::Flow);
```
# When Something Goes Wrong #
If something goes wrong when you're emitting a document, it must be something like forgetting a `YAML::EndSeq`, or a misplaced `YAML::Key`. In this case, emitting silently fails (no more output is emitted) and an error flag is set. For example:
_The following describes the old API. For the new API, see the [Tutorial](https://github.com/jbeder/yaml-cpp/wiki/Tutorial)._
## Contents ##
# Basic Parsing #
The parser accepts streams, not file names, so you need to first load the file. Since a YAML file can contain many documents, you can grab them one-by-one. A simple way to parse a YAML file might be:
```
#include <fstream>
#include "yaml-cpp/yaml.h"
int main()
{
std::ifstream fin("test.yaml");
YAML::Parser parser(fin);
YAML::Node doc;
while(parser.GetNextDocument(doc)) {
// ...
}
return 0;
}
```
# Reading From the Document #
Suppose we have a document consisting only of a scalar. We can read that scalar like this:
```
YAML::Node doc; // let's say we've already parsed this document
Note that dereferencing a map iterator is undefined; instead, use the `first` and `second` methods to get the key and value nodes, respectively.
Alternatively, we can pick off the values one-by-one, if we know the keys:
```
YAML::Node doc; // already parsed
std::string name;
doc["name"] >> name;
int age;
doc["age"] >> age;
std::cout << "Found entry with name '" << name << "' and age '" << age << "'\n";
```
One thing to be keep in mind: reading a map by key (as immediately above) requires looping through all entries until we find the right key, which is an O(n) operation. So if you're reading the entire map this way, it'll be O(n^2). For small n, this isn't a big deal, but I wouldn't recommend reading maps with a very large number of entries (>100, say) this way.
## Optional Keys ##
If you try to access a key that doesn't exist, `yaml-cpp` throws an exception (see [When Something Goes Wrong](https://github.com/jbeder/yaml-cpp/wiki/How-To-Parse-A-Document-(Old-API)#When_Something_Goes_Wrong). If you have optional keys, it's often easier to use `FindValue` instead of `operator[]`:
std::cout << "Key 'name' exists, with value '" << name << "'\n";
} else {
std::cout << "Key 'name' doesn't exist\n";
}
```
# Getting More Complicated #
The above three methods can be combined to read from an arbitrary document. But we can make life a lot easier. Suppose we're reading 3-vectors (i.e., vectors with three components), so we've got a structure looking like this:
```
struct Vec3 {
float x, y, z;
};
```
We can read this in one operation by overloading the extraction (>>) operator:
... we throw an exception (all exceptions are derived from `YAML::Exception`). If there's a parsing exception (i.e., a malformed YAML document), we throw a `YAML::ParserException`:
```
try {
std::ifstream fin("test.yaml");
YAML::Parser parser(fin);
YAML::Node doc;
parser.GetNextDocument(doc);
// do stuff
} catch(YAML::ParserException& e) {
std::cout << e.what() << "\n";
}
```
If you make a programming error (say, trying to read a scalar from a sequence node, or grabbing a key that doesn't exist), we throw some kind of `YAML::RepresentationException`. To prevent this, you can check what kind of node something is:
```
YAML::Node node;
YAML::NodeType::value type = node.Type(); // should be:
// YAML::NodeType::Null
// YAML::NodeType::Scalar
// YAML::NodeType::Sequence
// YAML::NodeType::Map
```
# Note about copying `YAML::Node` #
Currently `YAML::Node` is non-copyable, so you need to do something like
```
const YAML::Node& node = doc["whatever"];
```
This is intended behavior. If you want to copy a node, use the `Clone` function:
The intent is that if you'd like to keep a `YAML::Node` around for longer than the document will stay in scope, you can clone it and store it as long as you like.
`yaml-cpp` will parse any file as specified by the [YAML 1.2 spec](http://www.yaml.org/spec/1.2/spec.html#id2570322). Internally, it stores all strings in UTF-8, and representation is done with UTF-8. This means that in
```
std::string str;
node >> str;
```
`str` will be UTF-8. Similarly, if you're accessing a map by string key, you need to pass the key in UTF-8. If your application uses a different encoding, you need to convert to and from UTF-8 to work with `yaml-cpp`. (It's possible we'll add some small conversion functions, but for now it's restricted.)
---
For convenience, Richard Weeks has kindly provided a google gadget that converts Unicode to a string literal. It's a Google Gadget, so unfortunately it does not work on GitHub. Patches welcome to port it to a usable format here:
assert(node.size()==2);// the previous call didn't create a node
```
If you're not sure what kind of data you're getting, you can query the type of a node:
```cpp
switch(node.Type()){
caseNull:// ...
caseScalar:// ...
caseSequence:// ...
caseMap:// ...
caseUndefined:// ...
}
```
or ask directly whether it's a particular type, e.g.:
```cpp
if(node.IsSequence()){
// ...
}
```
# Building Nodes #
You can build `YAML::Node` from scratch:
```cpp
YAML::Nodenode;// starts out as null
node["key"]="value";// it now is a map node
node["seq"].push_back("first element");// node["seq"] automatically becomes a sequence
node["seq"].push_back("second element");
node["mirror"]=node["seq"][0];// this creates an alias
node["seq"][0]="1st element";// this also changes node["mirror"]
node["mirror"]="element #1";// and this changes node["seq"][0] - they're really the "same" node
node["self"]=node;// you can even create self-aliases
node[node["mirror"]]=node["seq"];// and strange loops :)
```
The above node is now:
```yaml
&1
key:value
&2seq:[&3"element #1",second element]
mirror:*3
self:*1
*3:*2
```
# How Sequences Turn Into Maps #
Sequences can be turned into maps by asking for non-integer keys. For example,
```cpp
YAML::Nodenode=YAML::Load("[1, 2, 3]");
node[1]=5;// still a sequence, [1, 5, 3]
node.push_back(-3)// still a sequence, [1, 5, 3, -3]
node["key"]="value";// now it's a map! {0: 1, 1: 5, 2: 3, 3: -3, key: value}
```
Indexing a sequence node by an index that's not in its range will _usually_ turn it into a map, but if the index is one past the end of the sequence, then the sequence will grow by one to accommodate it. (That's the **only** exception to this rule.) For example,
```cpp
YAML::Nodenode=YAML::Load("[1, 2, 3]");
node[3]=4;// still a sequence, [1, 2, 3, 4]
node[10]=10;// now it's a map! {0: 1, 1: 2, 2: 3, 3: 4, 10: 10}
```
# Converting To/From Native Data Types #
Yaml-cpp has built-in conversion to and from most built-in data types, as well as `std::vector`, `std::list`, and `std::map`. The following examples demonstrate when those conversions are used:
// this needs the conversion from Node to std::vector<int> (*not* the other way around!)
std::vector<int>v;
v.push_back(0);
v.push_back(1);
std::stringstr=node[v].as<std::string>();
```
To use yaml-cpp with your own data types, you need to specialize the YAML::convert<> template class. For example, suppose you had a simple `Vec3` class:
```cpp
structVec3{doublex,y,z;/* etc - make sure you have overloaded operator== */};
```
You could write
```cpp
namespaceYAML{
template<>
structconvert<Vec3>{
staticNodeencode(constVec3&rhs){
Nodenode;
node.push_back(rhs.x);
node.push_back(rhs.y);
node.push_back(rhs.z);
returnnode;
}
staticbooldecode(constNode&node,Vec3&rhs){
if(!node.IsSequence()||node.size()!=3){
returnfalse;
}
rhs.x=node[0].as<double>();
rhs.y=node[1].as<double>();
rhs.z=node[2].as<double>();
returntrue;
}
};
}
```
Then you could use `Vec3` wherever you could use any other type:
To learn how to use the library, see the [Tutorial](https://github.com/jbeder/yaml-cpp/wiki/Tutorial) and [How To Emit YAML](https://github.com/jbeder/yaml-cpp/wiki/How-To-Emit-YAML)
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
Oliver Hamlet
Jesse Beder
theamarin
t.t
Chen
Kajetan Świerk
Pavel Karelin
Tom Collins
Raffaello Bertini
Dekken
Rosen Penev
Josh Soref
Hans-Peter Gygax
Raúl Gutiérrez Segalés
Chen
Ted Lyngmo
Ian Taylor
deflinhec
Martin Delille
Jesse Beder
Alan Griffiths
Tindy X
Maxim Okhotskiy
Victor Mataré
Romain Deterre
Néstor Subirón
Anton Onishchenko
JeffWegher
Carlos Gomes Martinho
Igor [hyperxor]
Mike Egger
Romain Geissler @ Amadeus
carmeli-tamir
Isabella Muerte
Rasmus
Andy Maloney
Fatih YAZICI
Ezekiel Warren
Jeppe Blicher Tarp
bedapisl
peterchen-cp
caryoscelus
Olli Wang
tt4g
pent0
Simon Gene Gottlieb
Alexander Anokhin
Joel Frederico
Lassi Hämäläinen
dand-oss
Florian Eich
Stefan Reinhold
Antony Polukhin
Azamat H. Hackimov
Jesse Beder
Alexander
Alexander Karatarakis
Jiao
Patrick Stotko
Tanki Zhang
maek
Jamie Snape
Guillaume Dumont
Denis Gladkikh
Cybel
Matthew Woehlke
Ryan Schmidt
Alain Vaucher
Roger Leigh
Petr Bena
Peter-Levine
Dan Ibanez
devnoname120
Andrew
Liosan
Jens Breitbart
butataatawa
Raul Tambre
Ovidiu-Florin BOGDAN
michaelkonecny
Victor Mataré
James E. King, III
Joseph Langley
c0nk
Vincent Cogne
Paul Novotny
SirLoxley
Tatsuyuki Ishi
TripleWhy
Scott Wolchok
Craig M. Brandenburg
Rodrigo Hernandez
Matt Blair
Jiri Hoogland
Michael Welsh Duggan
Haydn Trigg
Jonathan Hamilton
Sébastien Rombauts
bdutro