1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
/*
* Copyright 2011 Nate Koenig
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#ifndef SDFORMAT_TYPES_HH_
#define SDFORMAT_TYPES_HH_
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#include <sdf/sdf_config.h>
#include "sdf/system_util.hh"
#include "sdf/Error.hh"
#if defined(__GNUC__) || defined(__clang__)
#define SDF_DEPRECATED(version) __attribute__((deprecated))
#define SDF_FORCEINLINE __attribute__((always_inline))
#elif defined(_MSC_VER)
#define SDF_DEPRECATED(version)
#define SDF_FORCEINLINE __forceinline
#else
#define SDF_DEPRECATED(version)
#define SDF_FORCEINLINE
#endif
#if defined(__GNUC__)
# define SDF_SUPPRESS_DEPRECATED_BEGIN \
_Pragma("GCC diagnostic push") \
_Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
# define SDF_SUPPRESS_DEPRECATED_END _Pragma("GCC diagnostic pop")
#elif defined(__clang__)
# define SDF_SUPPRESS_DEPRECATED_BEGIN \
_Pragma("clang diagnostic push") \
_Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
# define SDF_SUPPRESS_DEPRECATED_END _Pragma("clang diagnostic pop")
#else
# define SDF_SUPPRESS_DEPRECATED_BEGIN
# define SDF_SUPPRESS_DEPRECATED_END
#endif
namespace sdf
{
// Inline bracket to help doxygen filtering.
inline namespace SDF_VERSION_NAMESPACE {
//
const std::string kSdfScopeDelimiter = "::";
/// \brief The source path replacement if it was parsed from a string,
/// instead of a file.
constexpr char kSdfStringSource[] = "<data-string>";
/// \brief The source path replacement if the urdf was parsed from a string,
/// instead of a file.
constexpr char kUrdfStringSource[] = "<urdf-string>";
/// \brief Split a string using the delimiter in splitter.
/// \param[in] str The string to split.
/// \param[in] splitter The delimiter to use.
/// \return A vector of strings containing the split tokens.
SDFORMAT_VISIBLE
std::vector<std::string> split(const std::string &_str,
const std::string &_splitter);
/// \brief Trim leading and trailing whitespace from a string.
/// \param[in] _in The string to trim.
/// \return A string containing the trimmed value.
SDFORMAT_VISIBLE
std::string trim(const char *_in);
/// \brief Trim leading and trailing whitespace from a string.
/// \param[in] _in The string to trim.
/// \return A string containing the trimmed value.
SDFORMAT_VISIBLE
std::string trim(const std::string &_in);
/// \brief check if two values are equal, within a tolerance
/// \param[in] _a the first value
/// \param[in] _b the second value
/// \param[in] _epsilon the tolerance
template<typename T>
inline bool equal(const T &_a, const T &_b,
const T &_epsilon = 1e-6f)
{
return std::fabs(_a - _b) <= _epsilon;
}
/// \brief A vector of Error.
using Errors = std::vector<Error>;
/// \brief Output operator for a collection of errors.
/// \param[in,out] _out The output stream.
/// \param[in] _err The errors to output.
/// \return Reference to the given output stream
SDFORMAT_VISIBLE std::ostream &operator<<(
std::ostream &_out, const sdf::Errors &_errs);
/// \brief A Time class, can be used to hold wall- or sim-time.
/// stored as sec and nano-sec.
class SDFORMAT_VISIBLE Time
{
/// \brief Constructor
public: Time()
: sec(0), nsec(0)
{
}
/// \brief Constructor
/// \param[in] _sec Seconds
/// \param[in] _nsec Nanoseconds
public: Time(int32_t _sec, int32_t _nsec)
: sec(_sec), nsec(_nsec)
{
}
/// \brief Stream insertion operator
/// \param[in] _out the output stream
/// \param[in] _time time to write to the stream
/// \return the output stream
public: friend std::ostream &operator<<(std::ostream &_out,
const Time &_time)
{
_out << _time.sec << " " << _time.nsec;
return _out;
}
/// \brief Stream extraction operator
/// \param[in] _in the input stream
/// \param[in] _time time to read from to the stream
/// \return the input stream
public: friend std::istream &operator>>(std::istream &_in,
Time &_time)
{
// Skip white spaces
_in.setf(std::ios_base::skipws);
_in >> _time.sec >> _time.nsec;
return _in;
}
/// \brief Equal to operator.
/// \param[in] _time the time to compare to.
/// \return true if values are the same, false otherwise.
public: bool operator ==(const Time &_time) const
{
return this->sec == _time.sec && this->nsec == _time.nsec;
}
/// \brief Seconds.
public: int32_t sec;
/// \brief Nanoseconds.
public: int32_t nsec;
};
/// \brief A class for inertial information about a link.
class SDFORMAT_VISIBLE Inertia
{
public: double mass;
};
/// \brief Transforms a string to its lowercase equivalent
/// \param[in] _in String to convert to lowercase
/// \return Lowercase equilvalent of _in.
std::string SDFORMAT_VISIBLE lowercase(const std::string &_in);
/// \brief Split a name into a two strings based on the '::' delimeter
/// \param[in] _absoluteName The fully qualified absolute name
/// \return A pair with the absolute name minus the leaf node name, and the
/// leaf name
SDFORMAT_VISIBLE
std::pair<std::string, std::string> SplitName(
const std::string &_absoluteName);
/// \brief Join two strings with the '::' delimiter.
/// This checks for edge cases and is safe to use with any valid names
/// \param[in] _scopeName the left-hand-side component
/// \param[in] _localName the right-hand-side component
/// \return A full string with the names joined by the '::' delimeter.
SDFORMAT_VISIBLE
std::string JoinName(
const std::string &_scopeName, const std::string &_localName);
}
}
#endif
|
