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

refactor: remove template from detail::region

Browse Source
This commit is contained in:
ToruNiina
2020-07-25 22:01:34 +09:00
parent 72f5afb6af
commit 19cc9a2edf
4 changed files with 78 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
toml/combinator.hpp
View File

@@ -58,7 +58,7 @@ struct character
{ {
static constexpr char target = C; static constexpr char target = C;
static result<region<std::vector<char>>, none_t> static result<region, none_t>
invoke(location& loc) invoke(location& loc)
{ {
if(loc.iter() == loc.end()) {return none();} if(loc.iter() == loc.end()) {return none();}
@@ -71,7 +71,7 @@ struct character
} }
loc.advance(); // update location loc.advance(); // update location
return ok(region<std::vector<char>>(loc, first, loc.iter())); return ok(region(loc, first, loc.iter()));
} }
}; };
template<char C> template<char C>
@@ -87,7 +87,7 @@ struct in_range
static constexpr char upper = Up; static constexpr char upper = Up;
static constexpr char lower = Low; static constexpr char lower = Low;
static result<region<std::vector<char>>, none_t> static result<region, none_t>
invoke(location& loc) invoke(location& loc)
{ {
if(loc.iter() == loc.end()) {return none();} if(loc.iter() == loc.end()) {return none();}
@@ -100,7 +100,7 @@ struct in_range
} }
loc.advance(); loc.advance();
return ok(region<std::vector<char>>(loc, first, loc.iter())); return ok(region(loc, first, loc.iter()));
} }
}; };
template<char L, char U> constexpr char in_range<L, U>::upper; template<char L, char U> constexpr char in_range<L, U>::upper;
@@ -111,7 +111,7 @@ template<char L, char U> constexpr char in_range<L, U>::lower;
template<typename Combinator> template<typename Combinator>
struct exclude struct exclude
{ {
static result<region<std::vector<char>>, none_t> static result<region, none_t>
invoke(location& loc) invoke(location& loc)
{ {
if(loc.iter() == loc.end()) {return none();} if(loc.iter() == loc.end()) {return none();}
@@ -124,7 +124,7 @@ struct exclude
return none(); return none();
} }
loc.reset(std::next(first)); // XXX maybe loc.advance() is okay but... loc.reset(std::next(first)); // XXX maybe loc.advance() is okay but...
return ok(region<std::vector<char>>(loc, first, loc.iter())); return ok(region(loc, first, loc.iter()));
} }
}; };
@@ -132,7 +132,7 @@ struct exclude
template<typename Combinator> template<typename Combinator>
struct maybe struct maybe
{ {
static result<region<std::vector<char>>, none_t> static result<region, none_t>
invoke(location& loc) invoke(location& loc)
{ {
const auto rslt = Combinator::invoke(loc); const auto rslt = Combinator::invoke(loc);
@@ -140,7 +140,7 @@ struct maybe
{ {
return rslt; return rslt;
} }
return ok(region<std::vector<char>>(loc)); return ok(region(loc));
} }
}; };
@@ -150,7 +150,7 @@ struct sequence;
template<typename Head, typename ... Tail> template<typename Head, typename ... Tail>
struct sequence<Head, Tail...> struct sequence<Head, Tail...>
{ {
static result<region<std::vector<char>>, none_t> static result<region, none_t>
invoke(location& loc) invoke(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -165,8 +165,8 @@ struct sequence<Head, Tail...>
// called from the above function only, recursively. // called from the above function only, recursively.
template<typename Iterator> template<typename Iterator>
static result<region<std::vector<char>>, none_t> static result<region, none_t>
invoke(location& loc, region<std::vector<char>> reg, Iterator first) invoke(location& loc, region reg, Iterator first)
{ {
const auto rslt = Head::invoke(loc); const auto rslt = Head::invoke(loc);
if(rslt.is_err()) if(rslt.is_err())
@@ -184,8 +184,8 @@ struct sequence<Head>
{ {
// would be called from sequence<T ...>::invoke only. // would be called from sequence<T ...>::invoke only.
template<typename Iterator> template<typename Iterator>
static result<region<std::vector<char>>, none_t> static result<region, none_t>
invoke(location& loc, region<std::vector<char>> reg, Iterator first) invoke(location& loc, region reg, Iterator first)
{ {
const auto rslt = Head::invoke(loc); const auto rslt = Head::invoke(loc);
if(rslt.is_err()) if(rslt.is_err())
@@ -204,7 +204,7 @@ struct either;
template<typename Head, typename ... Tail> template<typename Head, typename ... Tail>
struct either<Head, Tail...> struct either<Head, Tail...>
{ {
static result<region<std::vector<char>>, none_t> static result<region, none_t>
invoke(location& loc) invoke(location& loc)
{ {
const auto rslt = Head::invoke(loc); const auto rslt = Head::invoke(loc);
@@ -215,7 +215,7 @@ struct either<Head, Tail...>
template<typename Head> template<typename Head>
struct either<Head> struct either<Head>
{ {
static result<region<std::vector<char>>, none_t> static result<region, none_t>
invoke(location& loc) invoke(location& loc)
{ {
return Head::invoke(loc); return Head::invoke(loc);
@@ -232,10 +232,10 @@ struct unlimited{};
template<typename T, std::size_t N> template<typename T, std::size_t N>
struct repeat<T, exactly<N>> struct repeat<T, exactly<N>>
{ {
static result<region<std::vector<char>>, none_t> static result<region, none_t>
invoke(location& loc) invoke(location& loc)
{ {
region<std::vector<char>> retval(loc); region retval(loc);
const auto first = loc.iter(); const auto first = loc.iter();
for(std::size_t i=0; i<N; ++i) for(std::size_t i=0; i<N; ++i)
{ {
@@ -254,10 +254,10 @@ struct repeat<T, exactly<N>>
template<typename T, std::size_t N> template<typename T, std::size_t N>
struct repeat<T, at_least<N>> struct repeat<T, at_least<N>>
{ {
static result<region<std::vector<char>>, none_t> static result<region, none_t>
invoke(location& loc) invoke(location& loc)
{ {
region<std::vector<char>> retval(loc); region retval(loc);
const auto first = loc.iter(); const auto first = loc.iter();
for(std::size_t i=0; i<N; ++i) for(std::size_t i=0; i<N; ++i)
@@ -285,10 +285,10 @@ struct repeat<T, at_least<N>>
template<typename T> template<typename T>
struct repeat<T, unlimited> struct repeat<T, unlimited>
{ {
static result<region<std::vector<char>>, none_t> static result<region, none_t>
invoke(location& loc) invoke(location& loc)
{ {
region<std::vector<char>> retval(loc); region retval(loc);
while(true) while(true)
{ {
auto rslt = T::invoke(loc); auto rslt = T::invoke(loc);

64
toml/parser.hpp
View File

@@ -25,7 +25,7 @@ namespace toml
namespace detail namespace detail
{ {
inline result<std::pair<boolean, region<std::vector<char>>>, std::string> inline result<std::pair<boolean, region>, std::string>
parse_boolean(location& loc) parse_boolean(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -47,7 +47,7 @@ parse_boolean(location& loc)
{{std::addressof(loc), "the next token is not a boolean"}})); {{std::addressof(loc), "the next token is not a boolean"}}));
} }
inline result<std::pair<integer, region<std::vector<char>>>, std::string> inline result<std::pair<integer, region>, std::string>
parse_binary_integer(location& loc) parse_binary_integer(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -76,7 +76,7 @@ parse_binary_integer(location& loc)
{{std::addressof(loc), "the next token is not an integer"}})); {{std::addressof(loc), "the next token is not an integer"}}));
} }
inline result<std::pair<integer, region<std::vector<char>>>, std::string> inline result<std::pair<integer, region>, std::string>
parse_octal_integer(location& loc) parse_octal_integer(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -96,7 +96,7 @@ parse_octal_integer(location& loc)
{{std::addressof(loc), "the next token is not an integer"}})); {{std::addressof(loc), "the next token is not an integer"}}));
} }
inline result<std::pair<integer, region<std::vector<char>>>, std::string> inline result<std::pair<integer, region>, std::string>
parse_hexadecimal_integer(location& loc) parse_hexadecimal_integer(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -116,7 +116,7 @@ parse_hexadecimal_integer(location& loc)
{{std::addressof(loc), "the next token is not an integer"}})); {{std::addressof(loc), "the next token is not an integer"}}));
} }
inline result<std::pair<integer, region<std::vector<char>>>, std::string> inline result<std::pair<integer, region>, std::string>
parse_integer(location& loc) parse_integer(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -125,7 +125,7 @@ parse_integer(location& loc)
const auto second = std::next(first); const auto second = std::next(first);
if(second == loc.end()) // the token is just zero. if(second == loc.end()) // the token is just zero.
{ {
return ok(std::make_pair(0, region<std::vector<char>>(loc, first, second))); return ok(std::make_pair(0, region(loc, first, second)));
} }
if(*second == 'b') {return parse_binary_integer (loc);} // 0b1100 if(*second == 'b') {return parse_binary_integer (loc);} // 0b1100
@@ -161,7 +161,7 @@ parse_integer(location& loc)
{{std::addressof(loc), "the next token is not an integer"}})); {{std::addressof(loc), "the next token is not an integer"}}));
} }
inline result<std::pair<floating, region<std::vector<char>>>, std::string> inline result<std::pair<floating, region>, std::string>
parse_floating(location& loc) parse_floating(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -249,9 +249,7 @@ parse_floating(location& loc)
{{std::addressof(loc), "the next token is not a float"}})); {{std::addressof(loc), "the next token is not a float"}}));
} }
template<typename Container> inline std::string read_utf8_codepoint(const region& reg, const location& loc)
std::string read_utf8_codepoint(const region<Container>& reg,
/* for err msg */ const location& loc)
{ {
const auto str = reg.str().substr(1); const auto str = reg.str().substr(1);
std::uint_least32_t codepoint; std::uint_least32_t codepoint;
@@ -363,7 +361,7 @@ inline result<std::string, std::string> parse_escape_sequence(location& loc)
return err(msg); return err(msg);
} }
inline result<std::pair<toml::string, region<std::vector<char>>>, std::string> inline result<std::pair<toml::string, region>, std::string>
parse_ml_basic_string(location& loc) parse_ml_basic_string(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -442,7 +440,7 @@ parse_ml_basic_string(location& loc)
} }
} }
inline result<std::pair<toml::string, region<std::vector<char>>>, std::string> inline result<std::pair<toml::string, region>, std::string>
parse_basic_string(location& loc) parse_basic_string(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -494,7 +492,7 @@ parse_basic_string(location& loc)
} }
} }
inline result<std::pair<toml::string, region<std::vector<char>>>, std::string> inline result<std::pair<toml::string, region>, std::string>
parse_ml_literal_string(location& loc) parse_ml_literal_string(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -556,7 +554,7 @@ parse_ml_literal_string(location& loc)
} }
} }
inline result<std::pair<toml::string, region<std::vector<char>>>, std::string> inline result<std::pair<toml::string, region>, std::string>
parse_literal_string(location& loc) parse_literal_string(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -596,7 +594,7 @@ parse_literal_string(location& loc)
} }
} }
inline result<std::pair<toml::string, region<std::vector<char>>>, std::string> inline result<std::pair<toml::string, region>, std::string>
parse_string(location& loc) parse_string(location& loc)
{ {
if(loc.iter() != loc.end() && *(loc.iter()) == '"') if(loc.iter() != loc.end() && *(loc.iter()) == '"')
@@ -627,7 +625,7 @@ parse_string(location& loc)
{{std::addressof(loc), "the next token is not a string"}})); {{std::addressof(loc), "the next token is not a string"}}));
} }
inline result<std::pair<local_date, region<std::vector<char>>>, std::string> inline result<std::pair<local_date, region>, std::string>
parse_local_date(location& loc) parse_local_date(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -676,7 +674,7 @@ parse_local_date(location& loc)
} }
} }
inline result<std::pair<local_time, region<std::vector<char>>>, std::string> inline result<std::pair<local_time, region>, std::string>
parse_local_time(location& loc) parse_local_time(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -764,7 +762,7 @@ parse_local_time(location& loc)
} }
} }
inline result<std::pair<local_datetime, region<std::vector<char>>>, std::string> inline result<std::pair<local_datetime, region>, std::string>
parse_local_datetime(location& loc) parse_local_datetime(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -808,7 +806,7 @@ parse_local_datetime(location& loc)
} }
} }
inline result<std::pair<offset_datetime, region<std::vector<char>>>, std::string> inline result<std::pair<offset_datetime, region>, std::string>
parse_offset_datetime(location& loc) parse_offset_datetime(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -856,7 +854,7 @@ parse_offset_datetime(location& loc)
} }
} }
inline result<std::pair<key, region<std::vector<char>>>, std::string> inline result<std::pair<key, region>, std::string>
parse_simple_key(location& loc) parse_simple_key(location& loc)
{ {
if(const auto bstr = parse_basic_string(loc)) if(const auto bstr = parse_basic_string(loc))
@@ -877,7 +875,7 @@ parse_simple_key(location& loc)
} }
// dotted key become vector of keys // dotted key become vector of keys
inline result<std::pair<std::vector<key>, region<std::vector<char>>>, std::string> inline result<std::pair<std::vector<key>, region>, std::string>
parse_key(location& loc) parse_key(location& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -939,7 +937,7 @@ template<typename Value>
result<Value, std::string> parse_value(location&); result<Value, std::string> parse_value(location&);
template<typename Value> template<typename Value>
result<std::pair<typename Value::array_type, region<std::vector<char>>>, std::string> result<std::pair<typename Value::array_type, region>, std::string>
parse_array(location& loc) parse_array(location& loc)
{ {
using value_type = Value; using value_type = Value;
@@ -968,7 +966,7 @@ parse_array(location& loc)
{ {
loc.advance(); // skip ']' loc.advance(); // skip ']'
return ok(std::make_pair(retval, return ok(std::make_pair(retval,
region<std::vector<char>>(loc, first, loc.iter()))); region(loc, first, loc.iter())));
} }
if(auto val = parse_value<value_type>(loc)) if(auto val = parse_value<value_type>(loc))
@@ -1021,7 +1019,7 @@ parse_array(location& loc)
{ {
loc.advance(); // skip ']' loc.advance(); // skip ']'
return ok(std::make_pair(retval, return ok(std::make_pair(retval,
region<std::vector<char>>(loc, first, loc.iter()))); region(loc, first, loc.iter())));
} }
else else
{ {
@@ -1044,7 +1042,7 @@ parse_array(location& loc)
} }
template<typename Value> template<typename Value>
result<std::pair<std::pair<std::vector<key>, region<std::vector<char>>>, Value>, std::string> result<std::pair<std::pair<std::vector<key>, region>, Value>, std::string>
parse_key_value_pair(location& loc) parse_key_value_pair(location& loc)
{ {
using value_type = Value; using value_type = Value;
@@ -1133,7 +1131,7 @@ std::string format_dotted_keys(InputIterator first, const InputIterator last)
} }
// forward decl for is_valid_forward_table_definition // forward decl for is_valid_forward_table_definition
result<std::pair<std::vector<key>, region<std::vector<char>>>, std::string> result<std::pair<std::vector<key>, region>, std::string>
parse_table_key(location& loc); parse_table_key(location& loc);
// The following toml file is allowed. // The following toml file is allowed.
@@ -1205,7 +1203,7 @@ template<typename Value, typename InputIterator>
result<bool, std::string> result<bool, std::string>
insert_nested_key(typename Value::table_type& root, const Value& v, insert_nested_key(typename Value::table_type& root, const Value& v,
InputIterator iter, const InputIterator last, InputIterator iter, const InputIterator last,
region<std::vector<char>> key_reg, region key_reg,
const bool is_array_of_table = false) const bool is_array_of_table = false)
{ {
static_assert(std::is_same<key, static_assert(std::is_same<key,
@@ -1439,7 +1437,7 @@ insert_nested_key(typename Value::table_type& root, const Value& v,
} }
template<typename Value> template<typename Value>
result<std::pair<typename Value::table_type, region<std::vector<char>>>, std::string> result<std::pair<typename Value::table_type, region>, std::string>
parse_inline_table(location& loc) parse_inline_table(location& loc)
{ {
using value_type = Value; using value_type = Value;
@@ -1461,7 +1459,7 @@ parse_inline_table(location& loc)
{ {
loc.advance(); // skip `}` loc.advance(); // skip `}`
return ok(std::make_pair(retval, return ok(std::make_pair(retval,
region<std::vector<char>>(loc, first, loc.iter()))); region(loc, first, loc.iter())));
} }
const auto kv_r = parse_key_value_pair<value_type>(loc); const auto kv_r = parse_key_value_pair<value_type>(loc);
@@ -1492,7 +1490,7 @@ parse_inline_table(location& loc)
{ {
loc.advance(); // skip `}` loc.advance(); // skip `}`
return ok(std::make_pair( return ok(std::make_pair(
retval, region<std::vector<char>>(loc, first, loc.iter()))); retval, region(loc, first, loc.iter())));
} }
else if(*loc.iter() == '#' || *loc.iter() == '\r' || *loc.iter() == '\n') else if(*loc.iter() == '#' || *loc.iter() == '\r' || *loc.iter() == '\n')
{ {
@@ -1709,7 +1707,7 @@ result<Value, std::string> parse_value(location& loc)
} }
} }
inline result<std::pair<std::vector<key>, region<std::vector<char>>>, std::string> inline result<std::pair<std::vector<key>, region>, std::string>
parse_table_key(location& loc) parse_table_key(location& loc)
{ {
if(auto token = lex_std_table::invoke(loc)) if(auto token = lex_std_table::invoke(loc))
@@ -1770,7 +1768,7 @@ parse_table_key(location& loc)
} }
} }
inline result<std::pair<std::vector<key>, region<std::vector<char>>>, std::string> inline result<std::pair<std::vector<key>, region>, std::string>
parse_array_table_key(location& loc) parse_array_table_key(location& loc)
{ {
if(auto token = lex_array_table::invoke(loc)) if(auto token = lex_array_table::invoke(loc))
@@ -1927,7 +1925,7 @@ result<Value, std::string> parse_toml_file(location& loc)
// put the first line as a region of a file // put the first line as a region of a file
// Here first != loc.end(), so taking std::next is okay // Here first != loc.end(), so taking std::next is okay
const region<std::vector<char>> file(loc, first, std::next(loc.iter())); const region file(loc, first, std::next(loc.iter()));
// The first successive comments that are separated from the first value // The first successive comments that are separated from the first value
// by an empty line are for a file itself. // by an empty line are for a file itself.

10
toml/region.hpp
View File

@@ -194,16 +194,10 @@ struct location final : public region_base
// //
// it contains pointer to the file content and iterator that points the first // it contains pointer to the file content and iterator that points the first
// and last location. // and last location.
template<typename Container>
struct region final : public region_base struct region final : public region_base
{ {
using const_iterator = typename Container::const_iterator; using const_iterator = typename std::vector<char>::const_iterator;
using source_ptr = std::shared_ptr<const Container>; using source_ptr = std::shared_ptr<const std::vector<char>>;
static_assert(std::is_same<char, typename Container::value_type>::value,"");
static_assert(std::is_same<std::random_access_iterator_tag,
typename std::iterator_traits<const_iterator>::iterator_category>::value,
"container should be randomly accessible");
// delete default constructor. source_ never be null. // delete default constructor. source_ never be null.
region() = delete; region() = delete;

56
toml/value.hpp
View File

@@ -1056,95 +1056,87 @@ class basic_value
// //
// Those constructors take detail::region that contains parse result. // Those constructors take detail::region that contains parse result.
template<typename Container> basic_value(boolean b, detail::region reg)
basic_value(boolean b, detail::region<Container> reg)
: type_(value_t::boolean), : type_(value_t::boolean),
region_info_(std::make_shared<detail::region<Container>>(std::move(reg))), region_info_(std::make_shared<detail::region>(std::move(reg))),
comments_(region_info_->comments()) comments_(region_info_->comments())
{ {
assigner(this->boolean_, b); assigner(this->boolean_, b);
} }
template<typename T, typename Container, typename std::enable_if< template<typename T, typename std::enable_if<
detail::conjunction< detail::conjunction<
std::is_integral<T>, detail::negation<std::is_same<T, boolean>> std::is_integral<T>, detail::negation<std::is_same<T, boolean>>
>::value, std::nullptr_t>::type = nullptr> >::value, std::nullptr_t>::type = nullptr>
basic_value(T i, detail::region<Container> reg) basic_value(T i, detail::region reg)
: type_(value_t::integer), : type_(value_t::integer),
region_info_(std::make_shared<detail::region<Container>>(std::move(reg))), region_info_(std::make_shared<detail::region>(std::move(reg))),
comments_(region_info_->comments()) comments_(region_info_->comments())
{ {
assigner(this->integer_, static_cast<integer>(i)); assigner(this->integer_, static_cast<integer>(i));
} }
template<typename T, typename Container, typename std::enable_if< template<typename T, typename std::enable_if<
std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr> std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
basic_value(T f, detail::region<Container> reg) basic_value(T f, detail::region reg)
: type_(value_t::floating), : type_(value_t::floating),
region_info_(std::make_shared<detail::region<Container>>(std::move(reg))), region_info_(std::make_shared<detail::region>(std::move(reg))),
comments_(region_info_->comments()) comments_(region_info_->comments())
{ {
assigner(this->floating_, static_cast<floating>(f)); assigner(this->floating_, static_cast<floating>(f));
} }
template<typename Container> basic_value(toml::string s, detail::region reg)
basic_value(toml::string s, detail::region<Container> reg)
: type_(value_t::string), : type_(value_t::string),
region_info_(std::make_shared<detail::region<Container>>(std::move(reg))), region_info_(std::make_shared<detail::region>(std::move(reg))),
comments_(region_info_->comments()) comments_(region_info_->comments())
{ {
assigner(this->string_, std::move(s)); assigner(this->string_, std::move(s));
} }
template<typename Container> basic_value(const local_date& ld, detail::region reg)
basic_value(const local_date& ld, detail::region<Container> reg)
: type_(value_t::local_date), : type_(value_t::local_date),
region_info_(std::make_shared<detail::region<Container>>(std::move(reg))), region_info_(std::make_shared<detail::region>(std::move(reg))),
comments_(region_info_->comments()) comments_(region_info_->comments())
{ {
assigner(this->local_date_, ld); assigner(this->local_date_, ld);
} }
template<typename Container> basic_value(const local_time& lt, detail::region reg)
basic_value(const local_time& lt, detail::region<Container> reg)
: type_(value_t::local_time), : type_(value_t::local_time),
region_info_(std::make_shared<detail::region<Container>>(std::move(reg))), region_info_(std::make_shared<detail::region>(std::move(reg))),
comments_(region_info_->comments()) comments_(region_info_->comments())
{ {
assigner(this->local_time_, lt); assigner(this->local_time_, lt);
} }
template<typename Container> basic_value(const local_datetime& ldt, detail::region reg)
basic_value(const local_datetime& ldt, detail::region<Container> reg)
: type_(value_t::local_datetime), : type_(value_t::local_datetime),
region_info_(std::make_shared<detail::region<Container>>(std::move(reg))), region_info_(std::make_shared<detail::region>(std::move(reg))),
comments_(region_info_->comments()) comments_(region_info_->comments())
{ {
assigner(this->local_datetime_, ldt); assigner(this->local_datetime_, ldt);
} }
template<typename Container> basic_value(const offset_datetime& odt, detail::region reg)
basic_value(const offset_datetime& odt, detail::region<Container> reg)
: type_(value_t::offset_datetime), : type_(value_t::offset_datetime),
region_info_(std::make_shared<detail::region<Container>>(std::move(reg))), region_info_(std::make_shared<detail::region>(std::move(reg))),
comments_(region_info_->comments()) comments_(region_info_->comments())
{ {
assigner(this->offset_datetime_, odt); assigner(this->offset_datetime_, odt);
} }
template<typename Container> basic_value(const array_type& ary, detail::region reg)
basic_value(const array_type& ary, detail::region<Container> reg)
: type_(value_t::array), : type_(value_t::array),
region_info_(std::make_shared<detail::region<Container>>(std::move(reg))), region_info_(std::make_shared<detail::region>(std::move(reg))),
comments_(region_info_->comments()) comments_(region_info_->comments())
{ {
assigner(this->array_, ary); assigner(this->array_, ary);
} }
template<typename Container> basic_value(const table_type& tab, detail::region reg)
basic_value(const table_type& tab, detail::region<Container> reg)
: type_(value_t::table), : type_(value_t::table),
region_info_(std::make_shared<detail::region<Container>>(std::move(reg))), region_info_(std::make_shared<detail::region>(std::move(reg))),
comments_(region_info_->comments()) comments_(region_info_->comments())
{ {
assigner(this->table_, tab); assigner(this->table_, tab);
} }
template<typename T, typename Container, typename std::enable_if< template<typename T, typename std::enable_if<
detail::is_exact_toml_type<T, value_type>::value, detail::is_exact_toml_type<T, value_type>::value,
std::nullptr_t>::type = nullptr> std::nullptr_t>::type = nullptr>
basic_value(std::pair<T, detail::region<Container>> parse_result) basic_value(std::pair<T, detail::region> parse_result)
: basic_value(std::move(parse_result.first), std::move(parse_result.second)) : basic_value(std::move(parse_result.first), std::move(parse_result.second))
{} {}