External/yaml-cpp
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Don't eagerly convert key to std::string

Browse Source
This commit is contained in:
k0zmo 2020-07-18 21:18:02 +02:00
parent c3df6d87d4
commit 1ef43dcb29
2 changed files with 13 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/yaml-cpp/node/convert.h
View File

@ -74,12 +74,17 @@ struct convert<std::string> {
// C-strings can only be encoded // C-strings can only be encoded
template <> template <>
struct convert<const char*> { struct convert<const char*> {
static Node encode(const char*& rhs) { return Node(rhs); } static Node encode(const char* rhs) { return Node(rhs); }
};
template <>
struct convert<char*> {
static Node encode(const char* rhs) { return Node(rhs); }
}; };
template <std::size_t N> template <std::size_t N>
struct convert<const char[N]> { struct convert<char[N]> {
static Node encode(const char(&rhs)[N]) { return Node(rhs); } static Node encode(const char* rhs) { return Node(rhs); }
}; };
template <> template <>

56
include/yaml-cpp/node/impl.h
View File

@ -315,51 +315,6 @@ inline void Node::push_back(const Node& rhs) {
m_pMemory->merge(*rhs.m_pMemory); m_pMemory->merge(*rhs.m_pMemory);
} }
// helpers for indexing
namespace detail {
template <typename T>
struct to_value_t {
explicit to_value_t(const T& t_) : t(t_) {}
const T& t;
using return_type = const T &;
const T& operator()() const { return t; }
};
template <>
struct to_value_t<const char*> {
explicit to_value_t(const char* t_) : t(t_) {}
const char* t;
using return_type = std::string;
const std::string operator()() const { return t; }
};
template <>
struct to_value_t<char*> {
explicit to_value_t(char* t_) : t(t_) {}
const char* t;
using return_type = std::string;
const std::string operator()() const { return t; }
};
template <std::size_t N>
struct to_value_t<char[N]> {
explicit to_value_t(const char* t_) : t(t_) {}
const char* t;
using return_type = std::string;
const std::string operator()() const { return t; }
};
// converts C-strings to std::strings so they can be copied
template <typename T>
inline typename to_value_t<T>::return_type to_value(const T& t) {
return to_value_t<T>(t)();
}
} // namespace detail
template<typename Key> template<typename Key>
std::string key_to_string(const Key& key) { std::string key_to_string(const Key& key) {
return streamable_to_string<Key, is_streamable<std::stringstream, Key>::value>().impl(key); return streamable_to_string<Key, is_streamable<std::stringstream, Key>::value>().impl(key);
@ -369,8 +324,8 @@ std::string key_to_string(const Key& key) {
template <typename Key> template <typename Key>
inline const Node Node::operator[](const Key& key) const { inline const Node Node::operator[](const Key& key) const {
EnsureNodeExists(); EnsureNodeExists();
detail::node* value = static_cast<const detail::node&>(*m_pNode).get( detail::node* value =
detail::to_value(key), m_pMemory); static_cast<const detail::node&>(*m_pNode).get(key, m_pMemory);
if (!value) { if (!value) {
return Node(ZombieNode, key_to_string(key)); return Node(ZombieNode, key_to_string(key));
} }
@ -380,14 +335,14 @@ inline const Node Node::operator[](const Key& key) const {
template <typename Key> template <typename Key>
inline Node Node::operator[](const Key& key) { inline Node Node::operator[](const Key& key) {
EnsureNodeExists(); EnsureNodeExists();
detail::node& value = m_pNode->get(detail::to_value(key), m_pMemory); detail::node& value = m_pNode->get(key, m_pMemory);
return Node(value, m_pMemory); return Node(value, m_pMemory);
} }
template <typename Key> template <typename Key>
inline bool Node::remove(const Key& key) { inline bool Node::remove(const Key& key) {
EnsureNodeExists(); EnsureNodeExists();
return m_pNode->remove(detail::to_value(key), m_pMemory); return m_pNode->remove(key, m_pMemory);
} }
inline const Node Node::operator[](const Node& key) const { inline const Node Node::operator[](const Node& key) const {
@ -420,8 +375,7 @@ inline bool Node::remove(const Node& key) {
template <typename Key, typename Value> template <typename Key, typename Value>
inline void Node::force_insert(const Key& key, const Value& value) { inline void Node::force_insert(const Key& key, const Value& value) {
EnsureNodeExists(); EnsureNodeExists();
m_pNode->force_insert(detail::to_value(key), detail::to_value(value), m_pNode->force_insert(key, value, m_pMemory);
m_pMemory);
} }
// free functions // free functions