mirror of
https://github.com/ToruNiina/toml11.git
synced 2024-11-09 22:30:07 +00:00
1087 lines
41 KiB
C++
1087 lines
41 KiB
C++
// Copyright Toru Niina 2017.
|
|
// Distributed under the MIT License.
|
|
#ifndef TOML11_VALUE_HPP
|
|
#define TOML11_VALUE_HPP
|
|
#include "traits.hpp"
|
|
#include "into.hpp"
|
|
#include "utility.hpp"
|
|
#include "exception.hpp"
|
|
#include "storage.hpp"
|
|
#include "region.hpp"
|
|
#include "types.hpp"
|
|
#include <vector>
|
|
#include <tuple>
|
|
#include <unordered_map>
|
|
#include <cassert>
|
|
#include <cstdint>
|
|
#if __cplusplus >= 201703L
|
|
#include <string_view>
|
|
#endif
|
|
|
|
namespace toml
|
|
{
|
|
|
|
namespace detail
|
|
{
|
|
// to show error messages. not recommended for users.
|
|
region_base const& get_region(const value&);
|
|
template<typename Region>
|
|
void change_region(value&, Region&&);
|
|
}// detail
|
|
|
|
template<typename T>
|
|
struct value_traits
|
|
{
|
|
constexpr static value_t type_index = detail::check_type<T>();
|
|
constexpr static bool is_toml_type = detail::is_valid(detail::check_type<T>());
|
|
typedef typename detail::toml_default_type<type_index>::type type;
|
|
};
|
|
template<typename T>
|
|
constexpr value_t value_traits<T>::type_index;
|
|
template<typename T>
|
|
constexpr bool value_traits<T>::is_toml_type;
|
|
|
|
class value
|
|
{
|
|
template<typename T, typename U>
|
|
static void assigner(T& dst, U&& v)
|
|
{
|
|
const auto tmp = ::new(std::addressof(dst)) T(std::forward<U>(v));
|
|
assert(tmp == std::addressof(dst));
|
|
(void)tmp;
|
|
}
|
|
|
|
using region_base = detail::region_base;
|
|
|
|
public:
|
|
|
|
value() noexcept
|
|
: type_(value_t::Empty),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{}
|
|
|
|
~value() noexcept {this->cleanup();}
|
|
|
|
value(const value& v): type_(v.type()), region_info_(v.region_info_)
|
|
{
|
|
switch(v.type())
|
|
{
|
|
case value_t::Boolean : assigner(boolean_ , v.boolean_ ); break;
|
|
case value_t::Integer : assigner(integer_ , v.integer_ ); break;
|
|
case value_t::Float : assigner(floating_ , v.floating_ ); break;
|
|
case value_t::String : assigner(string_ , v.string_ ); break;
|
|
case value_t::OffsetDatetime: assigner(offset_datetime_, v.offset_datetime_); break;
|
|
case value_t::LocalDatetime : assigner(local_datetime_ , v.local_datetime_ ); break;
|
|
case value_t::LocalDate : assigner(local_date_ , v.local_date_ ); break;
|
|
case value_t::LocalTime : assigner(local_time_ , v.local_time_ ); break;
|
|
case value_t::Array : assigner(array_ , v.array_ ); break;
|
|
case value_t::Table : assigner(table_ , v.table_ ); break;
|
|
default: break;
|
|
}
|
|
}
|
|
value(value&& v): type_(v.type()), region_info_(std::move(v.region_info_))
|
|
{
|
|
switch(this->type_)
|
|
{
|
|
case value_t::Boolean : assigner(boolean_ , std::move(v.boolean_ )); break;
|
|
case value_t::Integer : assigner(integer_ , std::move(v.integer_ )); break;
|
|
case value_t::Float : assigner(floating_ , std::move(v.floating_ )); break;
|
|
case value_t::String : assigner(string_ , std::move(v.string_ )); break;
|
|
case value_t::OffsetDatetime: assigner(offset_datetime_, std::move(v.offset_datetime_)); break;
|
|
case value_t::LocalDatetime : assigner(local_datetime_ , std::move(v.local_datetime_ )); break;
|
|
case value_t::LocalDate : assigner(local_date_ , std::move(v.local_date_ )); break;
|
|
case value_t::LocalTime : assigner(local_time_ , std::move(v.local_time_ )); break;
|
|
case value_t::Array : assigner(array_ , std::move(v.array_ )); break;
|
|
case value_t::Table : assigner(table_ , std::move(v.table_ )); break;
|
|
default: break;
|
|
}
|
|
}
|
|
value& operator=(const value& v)
|
|
{
|
|
this->cleanup();
|
|
this->region_info_ = v.region_info_;
|
|
this->type_ = v.type();
|
|
switch(this->type_)
|
|
{
|
|
case value_t::Boolean : assigner(boolean_ , v.boolean_ ); break;
|
|
case value_t::Integer : assigner(integer_ , v.integer_ ); break;
|
|
case value_t::Float : assigner(floating_ , v.floating_ ); break;
|
|
case value_t::String : assigner(string_ , v.string_ ); break;
|
|
case value_t::OffsetDatetime: assigner(offset_datetime_, v.offset_datetime_); break;
|
|
case value_t::LocalDatetime : assigner(local_datetime_ , v.local_datetime_ ); break;
|
|
case value_t::LocalDate : assigner(local_date_ , v.local_date_ ); break;
|
|
case value_t::LocalTime : assigner(local_time_ , v.local_time_ ); break;
|
|
case value_t::Array : assigner(array_ , v.array_ ); break;
|
|
case value_t::Table : assigner(table_ , v.table_ ); break;
|
|
default: break;
|
|
}
|
|
return *this;
|
|
}
|
|
value& operator=(value&& v)
|
|
{
|
|
this->cleanup();
|
|
this->region_info_ = std::move(v.region_info_);
|
|
this->type_ = v.type();
|
|
switch(this->type_)
|
|
{
|
|
case value_t::Boolean : assigner(boolean_ , std::move(v.boolean_ )); break;
|
|
case value_t::Integer : assigner(integer_ , std::move(v.integer_ )); break;
|
|
case value_t::Float : assigner(floating_ , std::move(v.floating_ )); break;
|
|
case value_t::String : assigner(string_ , std::move(v.string_ )); break;
|
|
case value_t::OffsetDatetime: assigner(offset_datetime_, std::move(v.offset_datetime_)); break;
|
|
case value_t::LocalDatetime : assigner(local_datetime_ , std::move(v.local_datetime_ )); break;
|
|
case value_t::LocalDate : assigner(local_date_ , std::move(v.local_date_ )); break;
|
|
case value_t::LocalTime : assigner(local_time_ , std::move(v.local_time_ )); break;
|
|
case value_t::Array : assigner(array_ , std::move(v.array_ )); break;
|
|
case value_t::Table : assigner(table_ , std::move(v.table_ )); break;
|
|
default: break;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
// boolean ==============================================================
|
|
|
|
value(boolean b)
|
|
: type_(value_t::Boolean),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->boolean_, b);
|
|
}
|
|
|
|
value& operator=(boolean b)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::Boolean;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->boolean_, b);
|
|
return *this;
|
|
}
|
|
|
|
template<typename Container>
|
|
value(boolean b, detail::region<Container> reg)
|
|
: type_(value_t::Boolean),
|
|
region_info_(std::make_shared<detail::region<Container>>(std::move(reg)))
|
|
{
|
|
assigner(this->boolean_, b);
|
|
}
|
|
|
|
// integer ==============================================================
|
|
|
|
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>
|
|
value(T i)
|
|
: type_(value_t::Integer),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->integer_, static_cast<integer>(i));
|
|
}
|
|
|
|
template<typename T, typename Container, typename std::enable_if<
|
|
detail::conjunction<std::is_integral<T>,
|
|
detail::negation<std::is_same<T, boolean>>
|
|
>::value, std::nullptr_t>::type = nullptr>
|
|
value(T i, detail::region<Container> reg)
|
|
: type_(value_t::Integer),
|
|
region_info_(std::make_shared<detail::region<Container>>(std::move(reg)))
|
|
{
|
|
assigner(this->integer_, static_cast<integer>(i));
|
|
}
|
|
|
|
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>
|
|
value& operator=(T i)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::Integer;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->integer_, static_cast<integer>(i));
|
|
return *this;
|
|
}
|
|
|
|
// floating =============================================================
|
|
|
|
template<typename T, typename std::enable_if<
|
|
std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
|
|
value(T f)
|
|
: type_(value_t::Float),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->floating_, f);
|
|
}
|
|
|
|
template<typename T, typename Container, typename std::enable_if<
|
|
std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
|
|
value(T f, detail::region<Container> reg)
|
|
: type_(value_t::Float),
|
|
region_info_(std::make_shared<detail::region<Container>>(std::move(reg)))
|
|
{
|
|
assigner(this->floating_, f);
|
|
}
|
|
|
|
template<typename T, typename std::enable_if<
|
|
std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
|
|
value& operator=(T f)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::Float;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->floating_, f);
|
|
return *this;
|
|
}
|
|
|
|
// string ===============================================================
|
|
|
|
value(toml::string s)
|
|
: type_(value_t::String),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->string_, std::move(s));
|
|
}
|
|
template<typename Container>
|
|
value(toml::string s, detail::region<Container> reg)
|
|
: type_(value_t::String),
|
|
region_info_(std::make_shared<detail::region<Container>>(std::move(reg)))
|
|
{
|
|
assigner(this->string_, std::move(s));
|
|
}
|
|
value& operator=(toml::string s)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::String;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->string_, s);
|
|
return *this;
|
|
}
|
|
|
|
value(std::string s)
|
|
: type_(value_t::String),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->string_, toml::string(std::move(s)));
|
|
}
|
|
value& operator=(std::string s)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::String;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->string_, toml::string(std::move(s)));
|
|
return *this;
|
|
}
|
|
value(std::string s, string_t kind)
|
|
: type_(value_t::String),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->string_, toml::string(std::move(s), kind));
|
|
}
|
|
|
|
value(const char* s)
|
|
: type_(value_t::String),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->string_, toml::string(std::string(s)));
|
|
}
|
|
value& operator=(const char* s)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::String;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->string_, toml::string(std::string(s)));
|
|
return *this;
|
|
}
|
|
value(const char* s, string_t kind)
|
|
: type_(value_t::String),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->string_, toml::string(std::string(s), kind));
|
|
}
|
|
|
|
#if __cplusplus >= 201703L
|
|
value(std::string_view s)
|
|
: type_(value_t::String),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->string_, toml::string(s));
|
|
}
|
|
value& operator=(std::string_view s)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::String;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->string_, toml::string(s));
|
|
return *this;
|
|
}
|
|
value(std::string_view s, string_t kind)
|
|
: type_(value_t::String),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->string_, toml::string(s, kind));
|
|
}
|
|
#endif
|
|
|
|
// local date ===========================================================
|
|
|
|
value(const local_date& ld)
|
|
: type_(value_t::LocalDate),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->local_date_, ld);
|
|
}
|
|
template<typename Container>
|
|
value(const local_date& ld, detail::region<Container> reg)
|
|
: type_(value_t::LocalDate),
|
|
region_info_(std::make_shared<detail::region<Container>>(std::move(reg)))
|
|
{
|
|
assigner(this->local_date_, ld);
|
|
}
|
|
value& operator=(const local_date& ld)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::LocalDate;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->local_date_, ld);
|
|
return *this;
|
|
}
|
|
|
|
// local time ===========================================================
|
|
|
|
value(const local_time& lt)
|
|
: type_(value_t::LocalTime),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->local_time_, lt);
|
|
}
|
|
template<typename Container>
|
|
value(const local_time& lt, detail::region<Container> reg)
|
|
: type_(value_t::LocalTime),
|
|
region_info_(std::make_shared<detail::region<Container>>(std::move(reg)))
|
|
{
|
|
assigner(this->local_time_, lt);
|
|
}
|
|
value& operator=(const local_time& lt)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::LocalTime;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->local_time_, lt);
|
|
return *this;
|
|
}
|
|
template<typename Rep, typename Period>
|
|
value(const std::chrono::duration<Rep, Period>& dur)
|
|
: type_(value_t::LocalTime),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->local_time_, local_time(dur));
|
|
}
|
|
template<typename Rep, typename Period>
|
|
value& operator=(const std::chrono::duration<Rep, Period>& dur)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::LocalTime;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->local_time_, local_time(dur));
|
|
return *this;
|
|
}
|
|
|
|
// local datetime =======================================================
|
|
|
|
value(const local_datetime& ldt)
|
|
: type_(value_t::LocalDatetime),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->local_datetime_, ldt);
|
|
}
|
|
template<typename Container>
|
|
value(const local_datetime& ldt, detail::region<Container> reg)
|
|
: type_(value_t::LocalDatetime),
|
|
region_info_(std::make_shared<detail::region<Container>>(std::move(reg)))
|
|
{
|
|
assigner(this->local_datetime_, ldt);
|
|
}
|
|
value& operator=(const local_datetime& ldt)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::LocalDatetime;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->local_datetime_, ldt);
|
|
return *this;
|
|
}
|
|
|
|
// offset datetime ======================================================
|
|
|
|
value(const offset_datetime& odt)
|
|
: type_(value_t::OffsetDatetime),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->offset_datetime_, odt);
|
|
}
|
|
template<typename Container>
|
|
value(const offset_datetime& odt, detail::region<Container> reg)
|
|
: type_(value_t::OffsetDatetime),
|
|
region_info_(std::make_shared<detail::region<Container>>(std::move(reg)))
|
|
{
|
|
assigner(this->offset_datetime_, odt);
|
|
}
|
|
value& operator=(const offset_datetime& odt)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::OffsetDatetime;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->offset_datetime_, odt);
|
|
return *this;
|
|
}
|
|
value(const std::chrono::system_clock::time_point& tp)
|
|
: type_(value_t::OffsetDatetime),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->offset_datetime_, offset_datetime(tp));
|
|
}
|
|
value& operator=(const std::chrono::system_clock::time_point& tp)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::OffsetDatetime;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->offset_datetime_, offset_datetime(tp));
|
|
return *this;
|
|
}
|
|
|
|
// array ================================================================
|
|
|
|
value(const array& ary)
|
|
: type_(value_t::Array),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->array_, ary);
|
|
}
|
|
template<typename Container>
|
|
value(const array& ary, detail::region<Container> reg)
|
|
: type_(value_t::Array),
|
|
region_info_(std::make_shared<detail::region<Container>>(std::move(reg)))
|
|
{
|
|
assigner(this->array_, ary);
|
|
}
|
|
value& operator=(const array& ary)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::Array;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->array_, ary);
|
|
return *this;
|
|
}
|
|
|
|
template<typename T, typename std::enable_if<value_traits<T>::is_toml_type,
|
|
std::nullptr_t>::type = nullptr>
|
|
value(std::initializer_list<T> list)
|
|
: type_(value_t::Array),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
array ary; ary.reserve(list.size());
|
|
for(auto& elem : list) {ary.emplace_back(std::move(elem));}
|
|
assigner(this->array_, std::move(ary));
|
|
}
|
|
template<typename T, typename std::enable_if<value_traits<T>::is_toml_type,
|
|
std::nullptr_t>::type = nullptr>
|
|
value& operator=(std::initializer_list<T> list)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::Array;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
|
|
array ary; ary.reserve(list.size());
|
|
for(auto& elem : list) {ary.emplace_back(std::move(elem));}
|
|
assigner(this->array_, std::move(ary));
|
|
return *this;
|
|
}
|
|
|
|
template<typename T, typename std::enable_if<detail::is_container<T>::value,
|
|
std::nullptr_t>::type = nullptr>
|
|
value(T&& list)
|
|
: type_(value_t::Array),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
array ary; ary.reserve(list.size());
|
|
for(const auto& elem : list) {ary.emplace_back(elem);}
|
|
assigner(this->array_, std::move(ary));
|
|
}
|
|
template<typename T, typename std::enable_if<detail::is_container<T>::value,
|
|
std::nullptr_t>::type = nullptr>
|
|
value& operator=(T&& list)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::Array;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
|
|
array ary; ary.reserve(list.size());
|
|
for(const auto& elem : list) {ary.emplace_back(elem);}
|
|
assigner(this->array_, std::move(ary));
|
|
return *this;
|
|
}
|
|
|
|
// table ================================================================
|
|
|
|
value(const table& tab)
|
|
: type_(value_t::Table),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
assigner(this->table_, tab);
|
|
}
|
|
template<typename Container>
|
|
value(const table& tab, detail::region<Container> reg)
|
|
: type_(value_t::Table),
|
|
region_info_(std::make_shared<detail::region<Container>>(std::move(reg)))
|
|
{
|
|
assigner(this->table_, tab);
|
|
}
|
|
value& operator=(const table& tab)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::Table;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
assigner(this->table_, tab);
|
|
return *this;
|
|
}
|
|
value(std::initializer_list<std::pair<key, value>> list)
|
|
: type_(value_t::Table),
|
|
region_info_(std::make_shared<region_base>(region_base{}))
|
|
{
|
|
table tab;
|
|
for(const auto& elem : list) {tab[elem.first] = elem.second;}
|
|
assigner(this->table_, std::move(tab));
|
|
}
|
|
value& operator=(std::initializer_list<std::pair<key, value>> list)
|
|
{
|
|
this->cleanup();
|
|
this->type_ = value_t::Array;
|
|
this->region_info_ = std::make_shared<region_base>(region_base{});
|
|
|
|
table tab;
|
|
for(const auto& elem : list) {tab[elem.first] = elem.second;}
|
|
assigner(this->table_, std::move(tab));
|
|
return *this;
|
|
}
|
|
|
|
// user-defined =========================================================
|
|
|
|
// convert using into_toml() method -------------------------------------
|
|
|
|
template<typename T, typename std::enable_if<detail::conjunction<
|
|
detail::negation<detail::is_exact_toml_type<T>>, // not a toml::value
|
|
detail::has_into_toml_method<T> // but has `into_toml` method
|
|
>::value, std::nullptr_t>::type = nullptr>
|
|
value(const T& ud): value(ud.into_toml()) {}
|
|
|
|
template<typename T, typename std::enable_if<detail::conjunction<
|
|
detail::negation<detail::is_exact_toml_type<T>>, // not a toml::value
|
|
detail::has_into_toml_method<T> // but has `into_toml` method
|
|
>::value, std::nullptr_t>::type = nullptr>
|
|
value& operator=(const T& ud)
|
|
{
|
|
*this = ud.into_toml();
|
|
return *this;
|
|
}
|
|
|
|
// convert using into<T> struct -----------------------------------------
|
|
|
|
template<typename T, typename std::enable_if<
|
|
detail::negation<detail::is_exact_toml_type<T>>::value,
|
|
std::nullptr_t>::type = nullptr,
|
|
std::size_t S = sizeof(::toml::into<T>)>
|
|
value(const T& ud): value(::toml::into<T>::into_toml(ud)) {}
|
|
|
|
template<typename T, typename std::enable_if<
|
|
detail::negation<detail::is_exact_toml_type<T>>::value,
|
|
std::nullptr_t>::type = nullptr,
|
|
std::size_t S = sizeof(::toml::into<T>)>
|
|
value& operator=(const T& ud)
|
|
{
|
|
*this = ::toml::into<T>::into_toml(ud);
|
|
return *this;
|
|
}
|
|
|
|
// for internal use ------------------------------------------------------
|
|
|
|
template<typename T, typename Container, typename std::enable_if<
|
|
detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
|
|
value(std::pair<T, detail::region<Container>> parse_result)
|
|
: value(std::move(parse_result.first), std::move(parse_result.second))
|
|
{}
|
|
|
|
// type checking and casting ============================================
|
|
|
|
template<typename T>
|
|
bool is() const noexcept {return value_traits<T>::type_index == this->type_;}
|
|
bool is(value_t t) const noexcept {return t == this->type_;}
|
|
|
|
bool is_uninitialized() const noexcept {return this->is(value_t::Empty );}
|
|
bool is_boolean() const noexcept {return this->is(value_t::Boolean );}
|
|
bool is_integer() const noexcept {return this->is(value_t::Integer );}
|
|
bool is_float() const noexcept {return this->is(value_t::Float );}
|
|
bool is_string() const noexcept {return this->is(value_t::String );}
|
|
bool is_offset_datetime() const noexcept {return this->is(value_t::OffsetDatetime);}
|
|
bool is_local_datetime() const noexcept {return this->is(value_t::LocalDatetime );}
|
|
bool is_local_date() const noexcept {return this->is(value_t::LocalDate );}
|
|
bool is_local_time() const noexcept {return this->is(value_t::LocalTime );}
|
|
bool is_array() const noexcept {return this->is(value_t::Array );}
|
|
bool is_table() const noexcept {return this->is(value_t::Table );}
|
|
|
|
value_t type() const {return type_;}
|
|
|
|
template<value_t T>
|
|
typename detail::toml_default_type<T>::type& cast() &;
|
|
template<value_t T>
|
|
typename detail::toml_default_type<T>::type const& cast() const&;
|
|
template<value_t T>
|
|
typename detail::toml_default_type<T>::type&& cast() &&;
|
|
|
|
boolean const& as_boolean() const& noexcept {return this->boolean_;}
|
|
integer const& as_integer() const& noexcept {return this->integer_;}
|
|
floating const& as_float() const& noexcept {return this->floating_;}
|
|
string const& as_string() const& noexcept {return this->string_;}
|
|
offset_datetime const& as_offset_datetime() const& noexcept {return this->offset_datetime_;}
|
|
local_datetime const& as_local_datetime() const& noexcept {return this->local_datetime_;}
|
|
local_date const& as_local_date() const& noexcept {return this->local_date_;}
|
|
local_time const& as_local_time() const& noexcept {return this->local_time_;}
|
|
array const& as_array() const& noexcept {return this->array_.value();}
|
|
table const& as_table() const& noexcept {return this->table_.value();}
|
|
|
|
boolean & as_boolean() & noexcept {return this->boolean_;}
|
|
integer & as_integer() & noexcept {return this->integer_;}
|
|
floating & as_float() & noexcept {return this->floating_;}
|
|
string & as_string() & noexcept {return this->string_;}
|
|
offset_datetime& as_offset_datetime() & noexcept {return this->offset_datetime_;}
|
|
local_datetime & as_local_datetime() & noexcept {return this->local_datetime_;}
|
|
local_date & as_local_date() & noexcept {return this->local_date_;}
|
|
local_time & as_local_time() & noexcept {return this->local_time_;}
|
|
array & as_array() & noexcept {return this->array_.value();}
|
|
table & as_table() & noexcept {return this->table_.value();}
|
|
|
|
boolean && as_boolean() && noexcept {return std::move(this->boolean_);}
|
|
integer && as_integer() && noexcept {return std::move(this->integer_);}
|
|
floating && as_float() && noexcept {return std::move(this->floating_);}
|
|
string && as_string() && noexcept {return std::move(this->string_);}
|
|
offset_datetime&& as_offset_datetime() && noexcept {return std::move(this->offset_datetime_);}
|
|
local_datetime && as_local_datetime() && noexcept {return std::move(this->local_datetime_);}
|
|
local_date && as_local_date() && noexcept {return std::move(this->local_date_);}
|
|
local_time && as_local_time() && noexcept {return std::move(this->local_time_);}
|
|
array && as_array() && noexcept {return std::move(this->array_.value());}
|
|
table && as_table() && noexcept {return std::move(this->table_.value());}
|
|
|
|
std::string comment() const
|
|
{
|
|
return this->region_info_->comment();
|
|
}
|
|
std::string comment_before() const
|
|
{
|
|
return this->region_info_->comment_before();
|
|
}
|
|
std::string comment_inline() const
|
|
{
|
|
return this->region_info_->comment_inline();
|
|
}
|
|
|
|
private:
|
|
|
|
void cleanup() noexcept
|
|
{
|
|
switch(this->type_)
|
|
{
|
|
case value_t::String : {string_.~string(); return;}
|
|
case value_t::Array : {array_.~array_storage(); return;}
|
|
case value_t::Table : {table_.~table_storage(); return;}
|
|
default : return;
|
|
}
|
|
}
|
|
|
|
// for error messages
|
|
friend region_base const& detail::get_region(const value&);
|
|
|
|
template<typename Region>
|
|
friend void detail::change_region(value&, Region&&);
|
|
|
|
private:
|
|
|
|
using array_storage = detail::storage<array>;
|
|
using table_storage = detail::storage<table>;
|
|
|
|
value_t type_;
|
|
|
|
// for error message information.
|
|
std::shared_ptr<region_base> region_info_;
|
|
|
|
union
|
|
{
|
|
boolean boolean_;
|
|
integer integer_;
|
|
floating floating_;
|
|
string string_;
|
|
offset_datetime offset_datetime_;
|
|
local_datetime local_datetime_;
|
|
local_date local_date_;
|
|
local_time local_time_;
|
|
array_storage array_;
|
|
table_storage table_;
|
|
};
|
|
};
|
|
|
|
namespace detail
|
|
{
|
|
inline region_base const& get_region(const value& v)
|
|
{
|
|
return *(v.region_info_);
|
|
}
|
|
|
|
template<typename Region>
|
|
void change_region(value& v, Region&& reg)
|
|
{
|
|
using region_type = typename std::remove_reference<
|
|
typename std::remove_cv<Region>::type
|
|
>::type;
|
|
|
|
std::shared_ptr<region_base> new_reg =
|
|
std::make_shared<region_type>(std::forward<region_type>(reg));
|
|
v.region_info_ = new_reg;
|
|
return;
|
|
}
|
|
|
|
template<value_t Expected>
|
|
[[noreturn]] inline void throw_bad_cast(value_t actual, const ::toml::value& v)
|
|
{
|
|
throw type_error(detail::format_underline(concat_to_string(
|
|
"[error] toml::value bad_cast to ", Expected), {
|
|
{std::addressof(get_region(v)),
|
|
concat_to_string("the actual type is ", actual)}
|
|
}));
|
|
}
|
|
|
|
template<value_t T>
|
|
struct switch_cast;
|
|
template<>
|
|
struct switch_cast<value_t::Boolean>
|
|
{
|
|
static ::toml::boolean& invoke(value& v) {return v.as_boolean();}
|
|
static ::toml::boolean const& invoke(value const& v) {return v.as_boolean();}
|
|
static ::toml::boolean&& invoke(value&& v) {return std::move(v).as_boolean();}
|
|
};
|
|
template<>
|
|
struct switch_cast<value_t::Integer>
|
|
{
|
|
static ::toml::integer& invoke(value& v) {return v.as_integer();}
|
|
static ::toml::integer const& invoke(value const& v) {return v.as_integer();}
|
|
static ::toml::integer&& invoke(value&& v) {return std::move(v).as_integer();}
|
|
};
|
|
template<>
|
|
struct switch_cast<value_t::Float>
|
|
{
|
|
static ::toml::floating& invoke(value& v) {return v.as_float();}
|
|
static ::toml::floating const& invoke(value const& v) {return v.as_float();}
|
|
static ::toml::floating&& invoke(value&& v) {return std::move(v).as_float();}
|
|
};
|
|
template<>
|
|
struct switch_cast<value_t::String>
|
|
{
|
|
static ::toml::string& invoke(value& v) {return v.as_string();}
|
|
static ::toml::string const& invoke(value const& v) {return v.as_string();}
|
|
static ::toml::string&& invoke(value&& v) {return std::move(v).as_string();}
|
|
};
|
|
template<>
|
|
struct switch_cast<value_t::OffsetDatetime>
|
|
{
|
|
static ::toml::offset_datetime& invoke(value& v) {return v.as_offset_datetime();}
|
|
static ::toml::offset_datetime const& invoke(value const& v) {return v.as_offset_datetime();}
|
|
static ::toml::offset_datetime&& invoke(value&& v) {return std::move(v).as_offset_datetime();}
|
|
};
|
|
template<>
|
|
struct switch_cast<value_t::LocalDatetime>
|
|
{
|
|
static ::toml::local_datetime& invoke(value& v) {return v.as_local_datetime();}
|
|
static ::toml::local_datetime const& invoke(value const& v) {return v.as_local_datetime();}
|
|
static ::toml::local_datetime&& invoke(value&& v) {return std::move(v).as_local_datetime();}
|
|
};
|
|
template<>
|
|
struct switch_cast<value_t::LocalDate>
|
|
{
|
|
static ::toml::local_date& invoke(value& v) {return v.as_local_date();}
|
|
static ::toml::local_date const& invoke(value const& v) {return v.as_local_date();}
|
|
static ::toml::local_date&& invoke(value&& v) {return std::move(v).as_local_date();}
|
|
};
|
|
template<>
|
|
struct switch_cast<value_t::LocalTime>
|
|
{
|
|
static ::toml::local_time& invoke(value& v) {return v.as_local_time();}
|
|
static ::toml::local_time const& invoke(value const& v) {return v.as_local_time();}
|
|
static ::toml::local_time&& invoke(value&& v) {return std::move(v).as_local_time();}
|
|
};
|
|
template<>
|
|
struct switch_cast<value_t::Array>
|
|
{
|
|
static ::toml::array& invoke(value& v) {return v.as_array();}
|
|
static ::toml::array const& invoke(value const& v) {return v.as_array();}
|
|
static ::toml::array&& invoke(value&& v) {return std::move(v).as_array();}
|
|
};
|
|
template<>
|
|
struct switch_cast<value_t::Table>
|
|
{
|
|
static ::toml::table& invoke(value& v) {return v.as_table();}
|
|
static ::toml::table const& invoke(value const& v) {return v.as_table();}
|
|
static ::toml::table&& invoke(value&& v) {return std::move(v).as_table();}
|
|
};
|
|
}// detail
|
|
|
|
template<value_t T>
|
|
typename detail::toml_default_type<T>::type& value::cast() &
|
|
{
|
|
if(T != this->type_)
|
|
{
|
|
detail::throw_bad_cast<T>(this->type_, *this);
|
|
}
|
|
return detail::switch_cast<T>::invoke(*this);
|
|
}
|
|
template<value_t T>
|
|
typename detail::toml_default_type<T>::type const& value::cast() const&
|
|
{
|
|
if(T != this->type_)
|
|
{
|
|
detail::throw_bad_cast<T>(this->type_, *this);
|
|
}
|
|
return detail::switch_cast<T>::invoke(*this);
|
|
}
|
|
template<value_t T>
|
|
typename detail::toml_default_type<T>::type&& value::cast() &&
|
|
{
|
|
if(T != this->type_)
|
|
{
|
|
detail::throw_bad_cast<T>(this->type_, *this);
|
|
}
|
|
return detail::switch_cast<T>::invoke(std::move(*this));
|
|
}
|
|
|
|
inline bool operator==(const toml::value& lhs, const toml::value& rhs)
|
|
{
|
|
if(lhs.type() != rhs.type()){return false;}
|
|
switch(lhs.type())
|
|
{
|
|
case value_t::Boolean :
|
|
{
|
|
return lhs.as_boolean() == rhs.as_boolean();
|
|
}
|
|
case value_t::Integer :
|
|
{
|
|
return lhs.as_integer() == rhs.as_integer();
|
|
}
|
|
case value_t::Float :
|
|
{
|
|
return lhs.as_float() == rhs.as_float();
|
|
}
|
|
case value_t::String :
|
|
{
|
|
return lhs.as_string() == rhs.as_string();
|
|
}
|
|
case value_t::OffsetDatetime:
|
|
{
|
|
return lhs.as_offset_datetime() == rhs.as_offset_datetime();
|
|
}
|
|
case value_t::LocalDatetime:
|
|
{
|
|
return lhs.as_local_datetime() == rhs.as_local_datetime();
|
|
}
|
|
case value_t::LocalDate:
|
|
{
|
|
return lhs.as_local_date() == rhs.as_local_date();
|
|
}
|
|
case value_t::LocalTime:
|
|
{
|
|
return lhs.as_local_time() == rhs.as_local_time();
|
|
}
|
|
case value_t::Array :
|
|
{
|
|
return lhs.as_array() == rhs.as_array();
|
|
}
|
|
case value_t::Table :
|
|
{
|
|
return lhs.as_table() == rhs.as_table();
|
|
}
|
|
case value_t::Empty : {return true; }
|
|
case value_t::Unknown : {return false;}
|
|
default: {return false;}
|
|
}
|
|
}
|
|
inline bool operator<(const toml::value& lhs, const toml::value& rhs)
|
|
{
|
|
if(lhs.type() != rhs.type()){return (lhs.type() < rhs.type());}
|
|
switch(lhs.type())
|
|
{
|
|
case value_t::Boolean :
|
|
{
|
|
return lhs.as_boolean() < rhs.as_boolean();
|
|
}
|
|
case value_t::Integer :
|
|
{
|
|
return lhs.as_integer() < rhs.as_integer();
|
|
}
|
|
case value_t::Float :
|
|
{
|
|
return lhs.as_float() < rhs.as_float();
|
|
}
|
|
case value_t::String :
|
|
{
|
|
return lhs.as_string() < rhs.as_string();
|
|
}
|
|
case value_t::OffsetDatetime:
|
|
{
|
|
return lhs.as_offset_datetime() < rhs.as_offset_datetime();
|
|
}
|
|
case value_t::LocalDatetime:
|
|
{
|
|
return lhs.as_local_datetime() < rhs.as_local_datetime();
|
|
}
|
|
case value_t::LocalDate:
|
|
{
|
|
return lhs.as_local_date() < rhs.as_local_date();
|
|
}
|
|
case value_t::LocalTime:
|
|
{
|
|
return lhs.as_local_time() < rhs.as_local_time();
|
|
}
|
|
case value_t::Array :
|
|
{
|
|
return lhs.as_array() < rhs.as_array();
|
|
}
|
|
case value_t::Table :
|
|
{
|
|
return lhs.as_table() < rhs.as_table();
|
|
}
|
|
case value_t::Empty : {return false;}
|
|
case value_t::Unknown : {return false;}
|
|
default: {return false;}
|
|
}
|
|
}
|
|
|
|
inline bool operator!=(const toml::value& lhs, const toml::value& rhs)
|
|
{
|
|
return !(lhs == rhs);
|
|
}
|
|
inline bool operator<=(const toml::value& lhs, const toml::value& rhs)
|
|
{
|
|
return (lhs < rhs) || (lhs == rhs);
|
|
}
|
|
inline bool operator>(const toml::value& lhs, const toml::value& rhs)
|
|
{
|
|
return !(lhs <= rhs);
|
|
}
|
|
inline bool operator>=(const toml::value& lhs, const toml::value& rhs)
|
|
{
|
|
return !(lhs < rhs);
|
|
}
|
|
|
|
inline std::string format_error(const std::string& err_msg,
|
|
const toml::value& v, const std::string& comment,
|
|
std::vector<std::string> hints = {})
|
|
{
|
|
return detail::format_underline(err_msg,
|
|
std::vector<std::pair<detail::region_base const*, std::string>>{
|
|
{std::addressof(detail::get_region(v)), comment}
|
|
}, std::move(hints));
|
|
}
|
|
|
|
inline std::string format_error(const std::string& err_msg,
|
|
const toml::value& v1, const std::string& comment1,
|
|
const toml::value& v2, const std::string& comment2,
|
|
std::vector<std::string> hints = {})
|
|
{
|
|
return detail::format_underline(err_msg,
|
|
std::vector<std::pair<detail::region_base const*, std::string>>{
|
|
{std::addressof(detail::get_region(v1)), comment1},
|
|
{std::addressof(detail::get_region(v2)), comment2}
|
|
}, std::move(hints));
|
|
}
|
|
|
|
inline std::string format_error(const std::string& err_msg,
|
|
const toml::value& v1, const std::string& comment1,
|
|
const toml::value& v2, const std::string& comment2,
|
|
const toml::value& v3, const std::string& comment3,
|
|
std::vector<std::string> hints = {})
|
|
{
|
|
return detail::format_underline(err_msg,
|
|
std::vector<std::pair<detail::region_base const*, std::string>>{
|
|
{std::addressof(detail::get_region(v1)), comment1},
|
|
{std::addressof(detail::get_region(v2)), comment2},
|
|
{std::addressof(detail::get_region(v3)), comment3}
|
|
}, std::move(hints));
|
|
}
|
|
|
|
template<typename Visitor>
|
|
detail::return_type_of_t<Visitor, const toml::boolean&>
|
|
visit(Visitor&& visitor, const toml::value& v)
|
|
{
|
|
switch(v.type())
|
|
{
|
|
case value_t::Boolean : {return visitor(v.as_boolean ());}
|
|
case value_t::Integer : {return visitor(v.as_integer ());}
|
|
case value_t::Float : {return visitor(v.as_float ());}
|
|
case value_t::String : {return visitor(v.as_string ());}
|
|
case value_t::OffsetDatetime: {return visitor(v.as_offset_datetime());}
|
|
case value_t::LocalDatetime : {return visitor(v.as_local_datetime ());}
|
|
case value_t::LocalDate : {return visitor(v.as_local_date ());}
|
|
case value_t::LocalTime : {return visitor(v.as_local_time ());}
|
|
case value_t::Array : {return visitor(v.as_array ());}
|
|
case value_t::Table : {return visitor(v.as_table ());}
|
|
case value_t::Empty : break;
|
|
case value_t::Unknown : break;
|
|
default: break;
|
|
}
|
|
throw std::runtime_error(format_error("[error] toml::visit: toml::value "
|
|
"does not have any valid value.", v, "here"));
|
|
}
|
|
|
|
template<typename Visitor>
|
|
detail::return_type_of_t<Visitor, toml::boolean&>
|
|
visit(Visitor&& visitor, toml::value& v)
|
|
{
|
|
switch(v.type())
|
|
{
|
|
case value_t::Boolean : {return visitor(v.as_boolean ());}
|
|
case value_t::Integer : {return visitor(v.as_integer ());}
|
|
case value_t::Float : {return visitor(v.as_float ());}
|
|
case value_t::String : {return visitor(v.as_string ());}
|
|
case value_t::OffsetDatetime: {return visitor(v.as_offset_datetime());}
|
|
case value_t::LocalDatetime : {return visitor(v.as_local_datetime ());}
|
|
case value_t::LocalDate : {return visitor(v.as_local_date ());}
|
|
case value_t::LocalTime : {return visitor(v.as_local_time ());}
|
|
case value_t::Array : {return visitor(v.as_array ());}
|
|
case value_t::Table : {return visitor(v.as_table ());}
|
|
case value_t::Empty : break;
|
|
case value_t::Unknown : break;
|
|
default: break;
|
|
}
|
|
throw std::runtime_error(format_error("[error] toml::visit: toml::value "
|
|
"does not have any valid value.", v, "here"));
|
|
}
|
|
|
|
template<typename Visitor>
|
|
detail::return_type_of_t<Visitor, toml::boolean&&>
|
|
visit(Visitor&& visitor, toml::value&& v)
|
|
{
|
|
switch(v.type())
|
|
{
|
|
case value_t::Boolean : {return visitor(std::move(v.as_boolean ()));}
|
|
case value_t::Integer : {return visitor(std::move(v.as_integer ()));}
|
|
case value_t::Float : {return visitor(std::move(v.as_float ()));}
|
|
case value_t::String : {return visitor(std::move(v.as_string ()));}
|
|
case value_t::OffsetDatetime: {return visitor(std::move(v.as_offset_datetime()));}
|
|
case value_t::LocalDatetime : {return visitor(std::move(v.as_local_datetime ()));}
|
|
case value_t::LocalDate : {return visitor(std::move(v.as_local_date ()));}
|
|
case value_t::LocalTime : {return visitor(std::move(v.as_local_time ()));}
|
|
case value_t::Array : {return visitor(std::move(v.as_array ()));}
|
|
case value_t::Table : {return visitor(std::move(v.as_table ()));}
|
|
case value_t::Empty : break;
|
|
case value_t::Unknown : break;
|
|
default: break;
|
|
}
|
|
throw std::runtime_error(format_error("[error] toml::visit: toml::value "
|
|
"does not have any valid value.", v, "here"));
|
|
}
|
|
|
|
}// toml
|
|
#endif// TOML11_VALUE
|