yaml_util.cpp
Go to the documentation of this file.
1 // *****************************************************************************
2 //
3 // Copyright (c) 2014, Southwest Research Institute® (SwRI®)
4 // All rights reserved.
5 //
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are met:
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // * Neither the name of Southwest Research Institute® (SwRI®) nor the
14 // names of its contributors may be used to endorse or promote products
15 // derived from this software without specific prior written permission.
16 //
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 // ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 //
28 // *****************************************************************************
29 
31 
32 #include <stdio.h>
33 // C++ standard libraries
34 #include <sstream>
35 #include <iomanip>
36 #ifdef YAMLCPP_OLD_API
37 #include <fstream>
38 #endif // YAMLCPP_OLD_API
39 
40 #ifndef YAMLCPP_OLD_API
41 namespace YAML
42 {
43  void operator >> (const YAML::Node& node, float& value)
44  {
45  value = node.as<float>();
46  }
47 
48  void operator >> (const YAML::Node& node, double& value)
49  {
50  value = node.as<double>();
51  }
52 
53  void operator >> (const YAML::Node& node, bool& value)
54  {
55  value = node.as<bool>();
56  }
57 
58  void operator >> (const YAML::Node& node, int16_t& value)
59  {
60  value = node.as<int16_t>();
61  }
62 
63  void operator >> (const YAML::Node& node, uint16_t& value)
64  {
65  value = node.as<uint16_t>();
66  }
67 
68  void operator >> (const YAML::Node& node, int32_t& value)
69  {
70  value = node.as<int32_t>();
71  }
72 
73  void operator >> (const YAML::Node& node, uint32_t& value)
74  {
75  value = node.as<uint32_t>();
76  }
77 
78  void operator >> (const YAML::Node& node, int64_t& value)
79  {
80  value = node.as<int64_t>();
81  }
82 
83  void operator >> (const YAML::Node& node, uint64_t& value)
84  {
85  value = node.as<uint64_t>();
86  }
87 
88  void operator >> (const YAML::Node& node, std::string& value)
89  {
90  value = node.as<std::string>();
91  }
92 }
93 #endif // YAMLCPP_OLD_API
94 
95 namespace swri_yaml_util
96 {
97  bool LoadFile(const std::string& path, YAML::Node& yaml)
98  {
99  try
100  {
101  #ifndef YAMLCPP_OLD_API
102  yaml = YAML::LoadFile(path);
103  #else
104  std::ifstream fin(path.c_str());
105  if (fin.fail())
106  {
107  return false;
108  }
109 
110  YAML::Parser parser(fin);
111  parser.GetNextDocument(yaml);
112  #endif // YAMLCPP_OLD_API
113  }
114  catch (...)
115  {
116  return false;
117  }
118 
119  return true;
120  }
121 
122  bool LoadString(const std::string& input, YAML::Node& yaml)
123  {
124  try
125  {
126 #ifndef YAMLCPP_OLD_API
127  yaml = YAML::Load(input);
128 #else
129  std::stringstream stream(input);
130  YAML::Parser parser(stream);
131  parser.GetNextDocument(yaml);
132 #endif // YAMLCPP_OLD_API
133  }
134  catch (...)
135  {
136  return false;
137  }
138 
139  return true;
140  }
141 
142  bool LoadMap(const std::map<std::string,std::string>& dict, YAML::Node& yaml)
143  {
144  std::vector<std::string> items;
145 
146  for (std::map<std::string,std::string>::const_iterator iter = dict.begin();
147  iter != dict.end();
148  ++iter)
149  {
150  if (!iter->first.empty()) {
151  items.push_back("\"" + iter->first + "\": \"" + iter->second + "\"");
152  }
153  }
154 
155  std::string input = "{ ";
156  for (size_t i = 0; i < items.size(); ++i) {
157  input += items[i];
158  if (i+1 < items.size()) {
159  input += ", ";
160  }
161  }
162  input += "}";
163 
164  printf("stringified: %s", input.c_str());
165 
166  return LoadString(input, yaml);
167  }
168 
169  bool FindValue(const YAML::Node& node, const std::string& name)
170  {
171  #ifndef YAMLCPP_OLD_API
172  return static_cast<bool>(node[name]);
173  #else
174  return node.FindValue(name);
175  #endif // YAMLCPP_OLD_API
176  }
177 
178  YamlNodePtr Clone(const YAML::Node& node)
179  {
180  #ifndef YAMLCPP_OLD_API
181  return YamlNodePtr(new YAML::Node(YAML::Clone(node)));
182  #else
183  return node.Clone();
184  #endif // YAMLCPP_OLD_API
185  }
186 
187  std::string ToString(double value, int32_t precision)
188  {
189  std::stringstream ss;
190  ss << std::setprecision(precision) << value;
191 
192  return ss.str();
193  }
194 }
YAML::operator>>
void operator>>(const YAML::Node &node, float &value)
Definition: yaml_util.cpp:43
swri_yaml_util::FindValue
bool FindValue(const YAML::Node &node, const std::string &name)
Definition: yaml_util.cpp:169
swri_yaml_util::LoadFile
bool LoadFile(const std::string &path, YAML::Node &yaml)
Definition: yaml_util.cpp:97
swri_yaml_util::YamlNodePtr
std::unique_ptr< YAML::Node > YamlNodePtr
Definition: yaml_util.h:59
yaml_util.h
swri_yaml_util
Definition: yaml_util.h:57
YAML
Definition: yaml_util.h:42
swri_yaml_util::ToString
std::string ToString(double value, int32_t precision)
Definition: yaml_util.cpp:187
swri_yaml_util::Clone
YamlNodePtr Clone(const YAML::Node &node)
Definition: yaml_util.cpp:178
swri_yaml_util::LoadMap
bool LoadMap(const std::map< std::string, std::string > &dict, YAML::Node &yaml)
Definition: yaml_util.cpp:142
swri_yaml_util::LoadString
bool LoadString(const std::string &input, YAML::Node &yaml)
Definition: yaml_util.cpp:122


swri_yaml_util
Author(s): Marc Alban
autogenerated on Fri Aug 2 2024 08:39:24