cpptoml Namespace Reference

Namespaces
namespace	ARRAY_
namespace	detail
namespace	TABLE_ARRAY_

Classes
class	array
class	array_exception
struct	array_of_trait
struct	array_of_trait< array >
class	base
struct	base_type_traits
	Type traits class to convert C++ types to enum member. More...
struct	base_type_traits< array >
struct	base_type_traits< double >
struct	base_type_traits< int >
struct	base_type_traits< int64_t >
struct	base_type_traits< local_date >
struct	base_type_traits< local_datetime >
struct	base_type_traits< local_time >
struct	base_type_traits< MBool >
struct	base_type_traits< offset_datetime >
struct	base_type_traits< std::string >
struct	base_type_traits< table >
struct	base_type_traits< table_array >
class	consumer
class	fill_guard
struct	is_one_of
struct	is_one_of< T, V >
struct	is_one_of< T, V, Ts... >
struct	local_date
struct	local_datetime
struct	local_time
class	make_shared_enabler
struct	offset_datetime
class	option
class	parse_exception
class	parser
class	table
class	table_array
class	toml_writer
struct	valid_value
struct	valid_value_or_string_convertible
class	value
struct	value_accept
struct	value_accept< T, Ts... >
struct	value_accept<>
struct	value_traits
struct	value_traits< T, typename std::enable_if< valid_value_or_string_convertible< T >::value >::type >
struct	value_traits< T, typename std::enable_if<!valid_value_or_string_convertible< T >::value &&std::is_floating_point< typename std::decay< T >::type >::value >::type >
struct	value_traits< T, typename std::enable_if<!valid_value_or_string_convertible< T >::value &&std::is_signed< typename std::decay< T >::type >::value >::type >
struct	value_traits< T, typename std::enable_if<!valid_value_or_string_convertible< T >::value &&std::is_unsigned< typename std::decay< T >::type >::value >::type >
struct	zone_offset

Typedefs
using	string_to_base_map = std::map< std::string, std::shared_ptr< base > >

Enumerations
enum class	base_type {   NONE , STRING , LOCAL_TIME , LOCAL_DATE ,   LOCAL_DATETIME , OFFSET_DATETIME , INT , FLOAT ,   BOOL , TABLE , ARRAY , TABLE_ARRAY }
	Base type used to store underlying data type explicitly if RTTI is disabled. More...

Functions
void	die (const std::string &reason, const std::string &file, const int line)
void	die (const std::string &reason, const int input_line, const std::string &file, const int line)
	CPPTOML_DEPRECATED ("datetime has been renamed to offset_datetime") typedef offset_datetime datetime
std::ostream &	operator<< (std::ostream &os, const local_date &dt)
std::ostream &	operator<< (std::ostream &os, const local_time &ltime)
std::ostream &	operator<< (std::ostream &os, const zone_offset &zo)
std::ostream &	operator<< (std::ostream &os, const local_datetime &dt)
std::ostream &	operator<< (std::ostream &os, const offset_datetime &dt)
template<class T >
std::shared_ptr< typename value_traits< T >::type >	make_value (T &&val)
std::shared_ptr< array >	make_array ()
template<class T >
std::shared_ptr< T >	make_element ()
std::shared_ptr< table >	make_table ()
std::shared_ptr< table_array >	make_table_array ()
template<>
std::shared_ptr< array >	make_element< array > ()
template<>
std::shared_ptr< table_array >	make_element< table_array > ()
template<class T >
std::enable_if<!std::is_floating_point< T >::value &&std::is_signed< T >::value, option< T > >::type	get_impl (const std::shared_ptr< base > &elem)
template<class T >
std::enable_if<!std::is_same< T, MBool >::value &&std::is_unsigned< T >::value, option< T > >::type	get_impl (const std::shared_ptr< base > &elem)
template<class T >
std::enable_if<!std::is_integral< T >::value||std::is_same< T, MBool >::value, option< T > >::type	get_impl (const std::shared_ptr< base > &elem)
template<>
std::shared_ptr< table >	make_element< table > ()
MBool	is_number (char c)
template<class OnError >
consumer< OnError >	make_consumer (std::string::iterator &it, const std::string::iterator &end, OnError &&on_error)
std::shared_ptr< table >	parse_file (const std::string &filename)
std::ostream &	operator<< (std::ostream &stream, const base &b)
template<class T >
std::ostream &	operator<< (std::ostream &stream, const value< T > &v)
std::ostream &	operator<< (std::ostream &stream, const table &t)
std::ostream &	operator<< (std::ostream &stream, const table_array &t)
std::ostream &	operator<< (std::ostream &stream, const array &a)

Typedef Documentation

string_to_base_map

typedef std::unordered_map< std::string, std::shared_ptr< base > > cpptoml::string_to_base_map

Definition at line 72 of file cpptoml.h.

Enumeration Type Documentation

base_type

enum class cpptoml::base_type

strong

Enumerator
NONE
STRING
LOCAL_TIME
LOCAL_DATE
LOCAL_DATETIME
OFFSET_DATETIME
INT
FLOAT
BOOL
TABLE
ARRAY
TABLE_ARRAY

Definition at line 368 of file cpptoml.h.

                     {
  NONE,
  STRING,
  LOCAL_TIME,
  LOCAL_DATE,
  LOCAL_DATETIME,
  OFFSET_DATETIME,
  INT,
  FLOAT,
  BOOL,
  TABLE,
  ARRAY,
  TABLE_ARRAY
};

Function Documentation

CPPTOML_DEPRECATED()

cpptoml::CPPTOML_DEPRECATED

(

"datetime has been renamed to offset_datetime"

)

die() [1/2]

void cpptoml::die ( const std::string &  reason, const int  input_line, const std::string &  file, const int  line  )

inline

Definition at line 94 of file cpptoml.h.

                                                                                                                   {
  std::cerr << file << ":" << std::to_string(line) << ": error: " << reason << " at line " << input_line << std::endl;
  TERM(-1);
}

die() [2/2]

void cpptoml::die ( const std::string &  reason, const std::string &  file, const int  line  )

inline

Definition at line 89 of file cpptoml.h.

                                                                                             {
  std::cerr << file << ":" << std::to_string(line) << ": error: " << reason << std::endl;
  TERM(-1);
}

get_impl() [1/3]

template<class T >

std::enable_if<!std::is_floating_point< T >::value &&std::is_signed< T >::value, option< T > >::type cpptoml::get_impl

(

const std::shared_ptr< base > &

elem

)

Definition at line 1021 of file cpptoml.h.

                                          {
  if(auto v = elem->as<int64_t>()) {
    if(v->get() < std::numeric_limits<T>::min())
      THROW_(std::underflow_error, "T cannot represent the value requested in get");
 
    if(v->get() > std::numeric_limits<T>::max())
      THROW_(std::overflow_error, "T cannot represent the value requested in get");
 
    return {static_cast<T>(v->get())};
  } else {
    return {};
  }
}

get_impl() [2/3]

template<class T >

std::enable_if<!std::is_same< T, MBool >::value &&std::is_unsigned< T >::value, option< T > >::type cpptoml::get_impl

(

const std::shared_ptr< base > &

elem

)

Definition at line 1037 of file cpptoml.h.

                                          {
  if(auto v = elem->as<int64_t>()) {
    if(v->get() < 0) THROW_(std::underflow_error, "T cannot store negative value in get");
 
    if(static_cast<uint64_t>(v->get()) > std::numeric_limits<T>::max())
      THROW_(std::overflow_error, "T cannot represent the value requested in get");
 
    return {static_cast<T>(v->get())};
  } else {
    return {};
  }
}

get_impl() [3/3]

template<class T >

std::enable_if<!std::is_integral< T >::value||std::is_same< T, MBool >::value, option< T > >::type cpptoml::get_impl

(

const std::shared_ptr< base > &

elem

)

Definition at line 1052 of file cpptoml.h.

                                          {
  if(auto v = elem->as<T>()) {
    return {v->get()};
  } else {
    return {};
  }
}

is_number()

MBool cpptoml::is_number ( char  c )

inline

Definition at line 1471 of file cpptoml.h.

{ return c >= '0' && c <= '9'; }

make_array()

std::shared_ptr< array > cpptoml::make_array ( )

inline

Definition at line 873 of file cpptoml.h.

                                         {
#if not defined(MAIA_INTEL_COMPILER)
  struct make_shared_enabler : public array {
    make_shared_enabler() = default;
  };
 
  return std::make_shared<make_shared_enabler>();
#else
  return std::make_shared<ARRAY_::make_shared_enabler>();
#endif
}

make_consumer()

template<class OnError >

consumer< OnError > cpptoml::make_consumer	(	std::string::iterator &	it,
		const std::string::iterator &	end,
		OnError &&	on_error
	)

Definition at line 1512 of file cpptoml.h.

                                                                                                         {
  return consumer<OnError>(it, end, std::forward<OnError>(on_error));
}

make_element()

template<class T >

std::shared_ptr< T > cpptoml::make_element ( )

inline

make_element< array >()

template<>

std::shared_ptr< array > cpptoml::make_element< array > ( )

inline

Definition at line 873 of file cpptoml.h.

                                                  {
  return make_array();
}

make_element< table >()

template<>

std::shared_ptr< table > cpptoml::make_element< table > ( )

inline

Definition at line 1417 of file cpptoml.h.

                                                  {
  return make_table();
}

make_element< table_array >()

template<>

std::shared_ptr< table_array > cpptoml::make_element< table_array > ( )

inline

Definition at line 999 of file cpptoml.h.

                                                              {
  return make_table_array();
}

make_table()

std::shared_ptr< table > cpptoml::make_table ( )

inline

Definition at line 1417 of file cpptoml.h.

                                  {
#if not defined(MAIA_INTEL_COMPILER)
  struct make_shared_enabler : public table {
    make_shared_enabler() = default;
  };
#endif
 
  return std::make_shared<make_shared_enabler>();
}

make_table_array()

std::shared_ptr< table_array > cpptoml::make_table_array ( )

inline

Definition at line 999 of file cpptoml.h.

                                                     {
#if not defined(MAIA_INTEL_COMPILER)
  struct make_shared_enabler : public table_array {
    make_shared_enabler() = default;
  };
 
  return std::make_shared<make_shared_enabler>();
#else
  return std::make_shared<TABLE_ARRAY_::make_shared_enabler>();
#endif
}

make_value()

template<class T >

std::shared_ptr< typename value_traits< T >::type > cpptoml::make_value ( T &&  val )

inline

Definition at line 588 of file cpptoml.h.

                                                                {
  using value_type = typename value_traits<T>::type;
  using enabler = typename value_type::make_shared_enabler;
  return std::make_shared<value_type>(enabler{}, value_traits<T>::construct(std::forward<T>(val)));
}

operator<<() [1/10]

std::ostream & cpptoml::operator<< ( std::ostream &  os, const local_date &  dt  )

inline

Definition at line 202 of file cpptoml.h.

                                                                    {
  fill_guard g{os};
  os.fill('0');
 
  using std::setw;
  os << setw(4) << dt.year << "-" << setw(2) << dt.month << "-" << setw(2) << dt.day;
 
  return os;
}

operator<<() [2/10]

std::ostream & cpptoml::operator<< ( std::ostream &  os, const local_datetime &  dt  )

inline

Definition at line 252 of file cpptoml.h.

                                                                        {
  return os << static_cast<const local_date&>(dt) << "T" << static_cast<const local_time&>(dt);
}

operator<<() [3/10]

std::ostream & cpptoml::operator<< ( std::ostream &  os, const local_time &  ltime  )

inline

Definition at line 212 of file cpptoml.h.

                                                                       {
  fill_guard g{os};
  os.fill('0');
 
  using std::setw;
  os << setw(2) << ltime.hour << ":" << setw(2) << ltime.minute << ":" << setw(2) << ltime.second;
 
  if(ltime.microsecond > 0) {
    os << ".";
    int power = 100000;
    for(int curr_us = ltime.microsecond; curr_us; power /= 10) {
      auto num = curr_us / power;
      os << num;
      curr_us -= num * power;
    }
  }
 
  return os;
}

operator<<() [4/10]

std::ostream & cpptoml::operator<< ( std::ostream &  os, const offset_datetime &  dt  )

inline

Definition at line 256 of file cpptoml.h.

                                                                         {
  return os << static_cast<const local_datetime&>(dt) << static_cast<const zone_offset&>(dt);
}

operator<<() [5/10]

std::ostream & cpptoml::operator<< ( std::ostream &  os, const zone_offset &  zo  )

inline

Definition at line 232 of file cpptoml.h.

                                                                     {
  fill_guard g{os};
  os.fill('0');
 
  using std::setw;
 
  if(zo.hour_offset != 0 || zo.minute_offset != 0) {
    if(zo.hour_offset > 0) {
      os << "+";
    } else {
      os << "-";
    }
    os << setw(2) << std::abs(zo.hour_offset) << ":" << setw(2) << std::abs(zo.minute_offset);
  } else {
    os << "Z";
  }
 
  return os;
}

operator<<() [6/10]

std::ostream & cpptoml::operator<< ( std::ostream &  stream, const array &  a  )

inline

Definition at line 2850 of file cpptoml.h.

                                                                  {
  toml_writer writer{stream};
  a.accept(writer);
  return stream;
}

operator<<() [7/10]

std::ostream & cpptoml::operator<< ( std::ostream &  stream, const base &  b  )

inline

Definition at line 2825 of file cpptoml.h.

                                                                 {
  toml_writer writer{stream};
  b.accept(writer);
  return stream;
}

operator<<() [8/10]

std::ostream & cpptoml::operator<< ( std::ostream &  stream, const table &  t  )

inline

Definition at line 2838 of file cpptoml.h.

                                                                  {
  toml_writer writer{stream};
  t.accept(writer);
  return stream;
}

operator<<() [9/10]

std::ostream & cpptoml::operator<< ( std::ostream &  stream, const table_array &  t  )

inline

Definition at line 2844 of file cpptoml.h.

                                                                        {
  toml_writer writer{stream};
  t.accept(writer);
  return stream;
}

operator<<() [10/10]

template<class T >

std::ostream & cpptoml::operator<<	(	std::ostream &	stream,
		const value< T > &	v
	)

Definition at line 2832 of file cpptoml.h.

                                                              {
  toml_writer writer{stream};
  v.accept(writer);
  return stream;
}

parse_file()

std::shared_ptr< table > cpptoml::parse_file ( const std::string &  filename )

inline

Utility function to parse a file as a TOML file. Returns the root table. Throws a parse_exception if the file cannot be opened.

Definition at line 2502 of file cpptoml.h.

                                                                  {
#if defined(BOOST_NOWIDE_FSTREAM_INCLUDED_HPP)
  boost::nowide::ifstream file{filename.c_str()};
#elif defined(NOWIDE_FSTREAM_INCLUDED_HPP)
  nowide::ifstream file{filename.c_str()};
#else
  std::ifstream file{filename};
#endif
  if(!file.is_open()) THROW_(parse_exception, filename + " could not be opened for parsing");
  parser p{file};
  return p.parse();
}