zhangyiss/toml11
1
0
Fork 0
mirror of https://github.com/ToruNiina/toml11.git synced 2025-09-17 00:38:08 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into recursive-find-or

Browse Source
This commit is contained in:
ToruNiina
2021-05-15 20:01:30 +09:00
parent b592ddcca2 392a260db8
commit 4b1df61142
19 changed files with 319 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
toml/comments.hpp
View File

@@ -10,6 +10,12 @@
#include <utility>
#include <vector>
#ifdef TOML11_PRESERVE_COMMENTS_BY_DEFAULT
# define TOML11_DEFAULT_COMMENT_STRATEGY ::toml::preserve_comments
#else
# define TOML11_DEFAULT_COMMENT_STRATEGY ::toml::discard_comments
#endif
// This file provides mainly two classes, `preserve_comments` and `discard_comments`.
// Those two are a container that have the same interface as `std::vector<std::string>`
// but bahaves in the opposite way. `preserve_comments` is just the same as

25
toml/get.hpp
View File

@@ -255,16 +255,19 @@ get(const basic_value<C, M, V>&);
// toml::from<T>::from_toml(v)
template<typename T, typename C,
template<typename ...> class M, template<typename ...> class V,
std::size_t S = sizeof(::toml::from<T>)>
T get(const basic_value<C, M, V>&);
template<typename ...> class M, template<typename ...> class V>
detail::enable_if_t<detail::has_specialized_from<T>::value, T>
get(const basic_value<C, M, V>&);
// T(const toml::value&) and T is not toml::basic_value
// T(const toml::value&) and T is not toml::basic_value,
// and it does not have `from<T>` nor `from_toml`.
template<typename T, typename C,
template<typename ...> class M, template<typename ...> class V>
detail::enable_if_t<detail::conjunction<
detail::negation<detail::is_basic_value<T>>,
std::is_constructible<T, const basic_value<C, M, V>&>
std::is_constructible<T, const basic_value<C, M, V>&>,
detail::negation<detail::has_from_toml_method<T, C, M, V>>,
detail::negation<detail::has_specialized_from<T>>
>::value, T>
get(const basic_value<C, M, V>&);
@@ -440,9 +443,9 @@ get(const basic_value<C, M, V>& v)
return ud;
}
template<typename T, typename C,
template<typename ...> class M, template<typename ...> class V,
std::size_t>
T get(const basic_value<C, M, V>& v)
template<typename ...> class M, template<typename ...> class V>
detail::enable_if_t<detail::has_specialized_from<T>::value, T>
get(const basic_value<C, M, V>& v)
{
return ::toml::from<T>::from_toml(v);
}
@@ -450,8 +453,10 @@ T get(const basic_value<C, M, V>& v)
template<typename T, typename C,
template<typename ...> class M, template<typename ...> class V>
detail::enable_if_t<detail::conjunction<
detail::negation<detail::is_basic_value<T>>,
std::is_constructible<T, const basic_value<C, M, V>&>
detail::negation<detail::is_basic_value<T>>, // T is not a toml::value
std::is_constructible<T, const basic_value<C, M, V>&>, // T is constructible from toml::value
detail::negation<detail::has_from_toml_method<T, C, M, V>>, // and T does not have T.from_toml(v);
detail::negation<detail::has_specialized_from<T>> // and T does not have toml::from<T>{};
>::value, T>
get(const basic_value<C, M, V>& v)
{

8
toml/literal.hpp
View File

@@ -12,11 +12,11 @@ inline namespace toml_literals
{
// implementation
inline ::toml::basic_value<::toml::discard_comments, std::unordered_map, std::vector>
inline ::toml::basic_value<TOML11_DEFAULT_COMMENT_STRATEGY, std::unordered_map, std::vector>
literal_internal_impl(::toml::detail::location loc)
{
using value_type = ::toml::basic_value<
::toml::discard_comments, std::unordered_map, std::vector>;
TOML11_DEFAULT_COMMENT_STRATEGY, std::unordered_map, std::vector>;
// if there are some comments or empty lines, skip them.
using skip_line = ::toml::detail::repeat<toml::detail::sequence<
::toml::detail::maybe<::toml::detail::lex_ws>,
@@ -81,7 +81,7 @@ literal_internal_impl(::toml::detail::location loc)
}
inline ::toml::basic_value<::toml::discard_comments, std::unordered_map, std::vector>
inline ::toml::basic_value<TOML11_DEFAULT_COMMENT_STRATEGY, std::unordered_map, std::vector>
operator"" _toml(const char* str, std::size_t len)
{
::toml::detail::location loc(
@@ -95,7 +95,7 @@ operator"" _toml(const char* str, std::size_t len)
#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
// value of u8"" literal has been changed from char to char8_t and char8_t is
// NOT compatible to char
inline ::toml::basic_value<::toml::discard_comments, std::unordered_map, std::vector>
inline ::toml::basic_value<TOML11_DEFAULT_COMMENT_STRATEGY, std::unordered_map, std::vector>
operator"" _toml(const char8_t* str, std::size_t len)
{
::toml::detail::location loc(

8
toml/parser.hpp
View File

@@ -2076,7 +2076,7 @@ result<Value, std::string> parse_toml_file(location& loc)
} // detail
template<typename Comment = ::toml::discard_comments,
template<typename Comment = TOML11_DEFAULT_COMMENT_STRATEGY,
template<typename ...> class Table = std::unordered_map,
template<typename ...> class Array = std::vector>
basic_value<Comment, Table, Array>
@@ -2127,7 +2127,7 @@ parse(std::istream& is, const std::string& fname = "unknown file")
return data.unwrap();
}
template<typename Comment = ::toml::discard_comments,
template<typename Comment = TOML11_DEFAULT_COMMENT_STRATEGY,
template<typename ...> class Table = std::unordered_map,
template<typename ...> class Array = std::vector>
basic_value<Comment, Table, Array> parse(const std::string& fname)
@@ -2150,7 +2150,7 @@ basic_value<Comment, Table, Array> parse(const std::string& fname)
//
// This function exactly matches to the invokation with c-string.
// So this function is preferred than others and the ambiguity disappears.
template<typename Comment = ::toml::discard_comments,
template<typename Comment = TOML11_DEFAULT_COMMENT_STRATEGY,
template<typename ...> class Table = std::unordered_map,
template<typename ...> class Array = std::vector>
basic_value<Comment, Table, Array> parse(const char* fname)
@@ -2158,7 +2158,7 @@ basic_value<Comment, Table, Array> parse(const char* fname)
return parse<Comment, Table, Array>(std::string(fname));
}
template<typename Comment = ::toml::discard_comments,
template<typename Comment = TOML11_DEFAULT_COMMENT_STRATEGY,
template<typename ...> class Table = std::unordered_map,
template<typename ...> class Array = std::vector>
basic_value<Comment, Table, Array> parse(const std::filesystem::path& fpath)

20
toml/region.hpp
View File

@@ -73,13 +73,13 @@ struct location final : public region_base
using difference_type = typename const_iterator::difference_type;
using source_ptr = std::shared_ptr<const std::vector<char>>;
location(std::string name, std::vector<char> cont)
location(std::string source_name, std::vector<char> cont)
: source_(std::make_shared<std::vector<char>>(std::move(cont))),
line_number_(1), source_name_(std::move(name)), iter_(source_->cbegin())
line_number_(1), source_name_(std::move(source_name)), iter_(source_->cbegin())
{}
location(std::string name, const std::string& cont)
location(std::string source_name, const std::string& cont)
: source_(std::make_shared<std::vector<char>>(cont.begin(), cont.end())),
line_number_(1), source_name_(std::move(name)), iter_(source_->cbegin())
line_number_(1), source_name_(std::move(source_name)), iter_(source_->cbegin())
{}
location(const location&) = default;
@@ -343,9 +343,9 @@ struct region final : public region_base
}))
{
// unwrap the first '#' by std::next.
auto str = make_string(std::next(comment_found), iter);
if(!str.empty() && str.back() == '\r') {str.pop_back();}
com.push_back(std::move(str));
auto s = make_string(std::next(comment_found), iter);
if(!s.empty() && s.back() == '\r') {s.pop_back();}
com.push_back(std::move(s));
}
else
{
@@ -396,9 +396,9 @@ struct region final : public region_base
}))
{
// unwrap the first '#' by std::next.
auto str = make_string(std::next(comment_found), this->line_end());
if(!str.empty() && str.back() == '\r') {str.pop_back();}
com.push_back(std::move(str));
auto s = make_string(std::next(comment_found), this->line_end());
if(!s.empty() && s.back() == '\r') {s.pop_back();}
com.push_back(std::move(s));
}
}
}

8
toml/serializer.hpp
View File

@@ -26,19 +26,19 @@ namespace toml
// a `"` and escaping some special character is boring.
template<typename charT, typename traits, typename Alloc>
std::basic_string<charT, traits, Alloc>
format_key(const std::basic_string<charT, traits, Alloc>& key)
format_key(const std::basic_string<charT, traits, Alloc>& k)
{
// check the key can be a bare (unquoted) key
detail::location loc(key, std::vector<char>(key.begin(), key.end()));
detail::location loc(k, std::vector<char>(k.begin(), k.end()));
detail::lex_unquoted_key::invoke(loc);
if(loc.iter() == loc.end())
{
return key; // all the tokens are consumed. the key is unquoted-key.
return k; // all the tokens are consumed. the key is unquoted-key.
}
//if it includes special characters, then format it in a "quoted" key.
std::basic_string<charT, traits, Alloc> serialized("\"");
for(const char c : key)
for(const char c : k)
{
switch(c)
{

25
toml/traits.hpp
View File

@@ -2,6 +2,10 @@
// Distributed under the MIT License.
#ifndef TOML11_TRAITS_HPP
#define TOML11_TRAITS_HPP
#include "from.hpp"
#include "into.hpp"
#include <chrono>
#include <forward_list>
#include <string>
@@ -84,6 +88,22 @@ struct has_into_toml_method_impl
static std::false_type check(...);
};
struct has_specialized_from_impl
{
template<typename T>
static std::false_type check(...);
template<typename T, std::size_t S = sizeof(::toml::from<T>)>
static std::true_type check(::toml::from<T>*);
};
struct has_specialized_into_impl
{
template<typename T>
static std::false_type check(...);
template<typename T, std::size_t S = sizeof(::toml::into<T>)>
static std::true_type check(::toml::from<T>*);
};
/// Intel C++ compiler can not use decltype in parent class declaration, here
/// is a hack to work around it. https://stackoverflow.com/a/23953090/4692076
#ifdef __INTEL_COMPILER
@@ -114,6 +134,11 @@ template<typename T>
struct has_into_toml_method
: decltype(has_into_toml_method_impl::check<T>(nullptr)){};
template<typename T>
struct has_specialized_from : decltype(has_specialized_from_impl::check<T>(nullptr)){};
template<typename T>
struct has_specialized_into : decltype(has_specialized_into_impl::check<T>(nullptr)){};
#ifdef __INTEL_COMPILER
#undef decltype
#endif

23
toml/types.hpp
View File

@@ -21,6 +21,11 @@ class basic_value;
using character = char;
using key = std::string;
#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ <= 4
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wshadow"
#endif
using boolean = bool;
using integer = std::int64_t;
using floating = double; // "float" is a keyward, cannot use it here.
@@ -32,12 +37,26 @@ using floating = double; // "float" is a keyward, cannot use it here.
// - local_date
// - local_time
#if defined(__GNUC__) && !defined(__clang__)
# pragma GCC diagnostic pop
#endif
// default toml::value and default array/table. these are defined after defining
// basic_value itself.
// using value = basic_value<discard_comments, std::unordered_map, std::vector>;
// using array = typename value::array_type;
// using table = typename value::table_type;
// to avoid warnings about `value_t::integer` is "shadowing" toml::integer in
// GCC -Wshadow=global.
#if defined(__GNUC__) && !defined(__clang__)
# pragma GCC diagnostic push
# if 7 <= __GNUC__
# pragma GCC diagnostic ignored "-Wshadow=global"
# else // gcc-6 or older
# pragma GCC diagnostic ignored "-Wshadow"
# endif
#endif
enum class value_t : std::uint8_t
{
empty = 0,
@@ -52,6 +71,9 @@ enum class value_t : std::uint8_t
array = 9,
table = 10,
};
#if defined(__GNUC__) && !defined(__clang__)
# pragma GCC diagnostic pop
#endif
template<typename charT, typename traits>
inline std::basic_ostream<charT, traits>&
@@ -147,4 +169,5 @@ template<typename T, typename V> struct is_exact_toml_type<T const volatile&, V>
} // detail
} // toml
#endif// TOML11_TYPES_H

115
toml/value.hpp
View File

@@ -281,9 +281,9 @@ class basic_value
// overwrite comments ----------------------------------------------------
basic_value(const basic_value& v, std::vector<std::string> comments)
basic_value(const basic_value& v, std::vector<std::string> com)
: type_(v.type()), region_info_(v.region_info_),
comments_(std::move(comments))
comments_(std::move(com))
{
switch(v.type())
{
@@ -301,9 +301,9 @@ class basic_value
}
}
basic_value(basic_value&& v, std::vector<std::string> comments)
basic_value(basic_value&& v, std::vector<std::string> com)
: type_(v.type()), region_info_(std::move(v.region_info_)),
comments_(std::move(comments))
comments_(std::move(com))
{
switch(this->type_) // here this->type_ is already initialized
{
@@ -359,9 +359,9 @@ class basic_value
template<typename C,
template<typename ...> class T,
template<typename ...> class A>
basic_value(const basic_value<C, T, A>& v, std::vector<std::string> comments)
basic_value(const basic_value<C, T, A>& v, std::vector<std::string> com)
: type_(v.type()), region_info_(v.region_info_),
comments_(std::move(comments))
comments_(std::move(com))
{
switch(v.type())
{
@@ -443,10 +443,10 @@ class basic_value
assigner(this->boolean_, b);
return *this;
}
basic_value(boolean b, std::vector<std::string> comments)
basic_value(boolean b, std::vector<std::string> com)
: type_(value_t::boolean),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->boolean_, b);
}
@@ -478,10 +478,10 @@ class basic_value
template<typename T, typename std::enable_if<detail::conjunction<
std::is_integral<T>, detail::negation<std::is_same<T, boolean>>>::value,
std::nullptr_t>::type = nullptr>
basic_value(T i, std::vector<std::string> comments)
basic_value(T i, std::vector<std::string> com)
: type_(value_t::integer),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->integer_, static_cast<integer>(i));
}
@@ -511,10 +511,10 @@ class basic_value
template<typename T, typename std::enable_if<
std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
basic_value(T f, std::vector<std::string> comments)
basic_value(T f, std::vector<std::string> com)
: type_(value_t::floating),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->floating_, f);
}
@@ -535,10 +535,10 @@ class basic_value
assigner(this->string_, s);
return *this;
}
basic_value(toml::string s, std::vector<std::string> comments)
basic_value(toml::string s, std::vector<std::string> com)
: type_(value_t::string),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->string_, std::move(s));
}
@@ -563,17 +563,17 @@ class basic_value
{
assigner(this->string_, toml::string(std::move(s), kind));
}
basic_value(std::string s, std::vector<std::string> comments)
basic_value(std::string s, std::vector<std::string> com)
: type_(value_t::string),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->string_, toml::string(std::move(s)));
}
basic_value(std::string s, string_t kind, std::vector<std::string> comments)
basic_value(std::string s, string_t kind, std::vector<std::string> com)
: type_(value_t::string),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->string_, toml::string(std::move(s), kind));
}
@@ -598,17 +598,17 @@ class basic_value
{
assigner(this->string_, toml::string(std::string(s), kind));
}
basic_value(const char* s, std::vector<std::string> comments)
basic_value(const char* s, std::vector<std::string> com)
: type_(value_t::string),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->string_, toml::string(std::string(s)));
}
basic_value(const char* s, string_t kind, std::vector<std::string> comments)
basic_value(const char* s, string_t kind, std::vector<std::string> com)
: type_(value_t::string),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->string_, toml::string(std::string(s), kind));
}
@@ -628,10 +628,10 @@ class basic_value
assigner(this->string_, toml::string(s));
return *this;
}
basic_value(std::string_view s, std::vector<std::string> comments)
basic_value(std::string_view s, std::vector<std::string> com)
: type_(value_t::string),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->string_, toml::string(s));
}
@@ -641,10 +641,10 @@ class basic_value
{
assigner(this->string_, toml::string(s, kind));
}
basic_value(std::string_view s, string_t kind, std::vector<std::string> comments)
basic_value(std::string_view s, string_t kind, std::vector<std::string> com)
: type_(value_t::string),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->string_, toml::string(s, kind));
}
@@ -666,10 +666,10 @@ class basic_value
assigner(this->local_date_, ld);
return *this;
}
basic_value(const local_date& ld, std::vector<std::string> comments)
basic_value(const local_date& ld, std::vector<std::string> com)
: type_(value_t::local_date),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->local_date_, ld);
}
@@ -682,10 +682,10 @@ class basic_value
{
assigner(this->local_time_, lt);
}
basic_value(const local_time& lt, std::vector<std::string> comments)
basic_value(const local_time& lt, std::vector<std::string> com)
: type_(value_t::local_time),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->local_time_, lt);
}
@@ -707,10 +707,10 @@ class basic_value
}
template<typename Rep, typename Period>
basic_value(const std::chrono::duration<Rep, Period>& dur,
std::vector<std::string> comments)
std::vector<std::string> com)
: type_(value_t::local_time),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->local_time_, local_time(dur));
}
@@ -732,10 +732,10 @@ class basic_value
{
assigner(this->local_datetime_, ldt);
}
basic_value(const local_datetime& ldt, std::vector<std::string> comments)
basic_value(const local_datetime& ldt, std::vector<std::string> com)
: type_(value_t::local_datetime),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->local_datetime_, ldt);
}
@@ -756,10 +756,10 @@ class basic_value
{
assigner(this->offset_datetime_, odt);
}
basic_value(const offset_datetime& odt, std::vector<std::string> comments)
basic_value(const offset_datetime& odt, std::vector<std::string> com)
: type_(value_t::offset_datetime),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->offset_datetime_, odt);
}
@@ -778,10 +778,10 @@ class basic_value
assigner(this->offset_datetime_, offset_datetime(tp));
}
basic_value(const std::chrono::system_clock::time_point& tp,
std::vector<std::string> comments)
std::vector<std::string> com)
: type_(value_t::offset_datetime),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->offset_datetime_, offset_datetime(tp));
}
@@ -802,10 +802,10 @@ class basic_value
{
assigner(this->array_, ary);
}
basic_value(const array_type& ary, std::vector<std::string> comments)
basic_value(const array_type& ary, std::vector<std::string> com)
: type_(value_t::array),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->array_, ary);
}
@@ -833,10 +833,10 @@ class basic_value
template<typename T, typename std::enable_if<
std::is_convertible<T, value_type>::value,
std::nullptr_t>::type = nullptr>
basic_value(std::initializer_list<T> list, std::vector<std::string> comments)
basic_value(std::initializer_list<T> list, std::vector<std::string> com)
: type_(value_t::array),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
array_type ary(list.begin(), list.end());
assigner(this->array_, std::move(ary));
@@ -876,10 +876,10 @@ class basic_value
detail::negation<std::is_same<T, array_type>>,
detail::is_container<T>
>::value, std::nullptr_t>::type = nullptr>
basic_value(const T& list, std::vector<std::string> comments)
basic_value(const T& list, std::vector<std::string> com)
: type_(value_t::array),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
static_assert(std::is_convertible<typename T::value_type, value_type>::value,
"elements of a container should be convertible to toml::value");
@@ -915,10 +915,10 @@ class basic_value
{
assigner(this->table_, tab);
}
basic_value(const table_type& tab, std::vector<std::string> comments)
basic_value(const table_type& tab, std::vector<std::string> com)
: type_(value_t::table),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
assigner(this->table_, tab);
}
@@ -943,10 +943,10 @@ class basic_value
}
basic_value(std::initializer_list<std::pair<key, basic_value>> list,
std::vector<std::string> comments)
std::vector<std::string> com)
: type_(value_t::table),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
table_type tab;
for(const auto& elem : list) {tab[elem.first] = elem.second;}
@@ -982,10 +982,10 @@ class basic_value
detail::negation<std::is_same<Map, table_type>>,
detail::is_map<Map>
>::value, std::nullptr_t>::type = nullptr>
basic_value(const Map& mp, std::vector<std::string> comments)
basic_value(const Map& mp, std::vector<std::string> com)
: type_(value_t::table),
region_info_(std::make_shared<region_base>(region_base{})),
comments_(std::move(comments))
comments_(std::move(com))
{
table_type tab;
for(const auto& elem : mp) {tab[elem.first] = elem.second;}
@@ -1017,8 +1017,8 @@ class basic_value
template<typename T, typename std::enable_if<
detail::has_into_toml_method<T>::value, std::nullptr_t>::type = nullptr>
basic_value(const T& ud, std::vector<std::string> comments)
: basic_value(ud.into_toml(), std::move(comments))
basic_value(const T& ud, std::vector<std::string> com)
: basic_value(ud.into_toml(), std::move(com))
{}
template<typename T, typename std::enable_if<
detail::has_into_toml_method<T>::value, std::nullptr_t>::type = nullptr>
@@ -1033,8 +1033,8 @@ class basic_value
template<typename T, std::size_t S = sizeof(::toml::into<T>)>
basic_value(const T& ud): basic_value(::toml::into<T>::into_toml(ud)) {}
template<typename T, std::size_t S = sizeof(::toml::into<T>)>
basic_value(const T& ud, std::vector<std::string> comments)
: basic_value(::toml::into<T>::into_toml(ud), std::move(comments))
basic_value(const T& ud, std::vector<std::string> com)
: basic_value(::toml::into<T>::into_toml(ud), std::move(com))
{}
template<typename T, std::size_t S = sizeof(::toml::into<T>)>
basic_value& operator=(const T& ud)
@@ -1134,10 +1134,10 @@ class basic_value
template<typename T, typename std::enable_if<
detail::is_exact_toml_type<T, value_type>::value,
std::nullptr_t>::type = nullptr>
basic_value(std::pair<T, detail::region> parse_result, std::vector<std::string> comments)
basic_value(std::pair<T, detail::region> parse_result, std::vector<std::string> com)
: basic_value(std::move(parse_result.first),
std::move(parse_result.second),
std::move(comments))
std::move(com))
{}
// type checking and casting ============================================
@@ -1739,7 +1739,8 @@ class basic_value
};
// default toml::value and default array/table.
using value = basic_value<discard_comments, std::unordered_map, std::vector>;
// TOML11_DEFAULT_COMMENT_STRATEGY is defined in comments.hpp
using value = basic_value<TOML11_DEFAULT_COMMENT_STRATEGY, std::unordered_map, std::vector>;
using array = typename value::array_type;
using table = typename value::table_type;