cpptoml::table Class Reference

#include <cpptoml.h>

Inheritance diagram for cpptoml::table:

Collaboration diagram for cpptoml::table:

Public Types
using	iterator = string_to_base_map::iterator
using	const_iterator = string_to_base_map::const_iterator

Public Member Functions
std::shared_ptr< base >	clone () const override
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
MBool	is_table () const override
MBool	empty () const
MBool	contains (const std::string &key) const
MBool	contains_qualified (const std::string &key) const
std::shared_ptr< base >	get (const std::string &key) const
std::shared_ptr< base >	get_qualified (const std::string &key) const
std::shared_ptr< table >	get_table (const std::string &key) const
std::shared_ptr< table >	get_table_qualified (const std::string &key) const
std::shared_ptr< array >	get_array (const std::string &key) const
std::shared_ptr< array >	get_array_qualified (const std::string &key) const
std::shared_ptr< table_array >	get_table_array (const std::string &key) const
std::shared_ptr< table_array >	get_table_array_qualified (const std::string &key) const
template<class T >
option< T >	get_as (const std::string &key) const
template<class T >
option< T >	get_qualified_as (const std::string &key) const
template<class T >
array_of_trait< T >::return_type	get_array_of (const std::string &key) const
template<class T >
array_of_trait< T >::return_type	get_qualified_array_of (const std::string &key) const
void	insert (const std::string &key, const std::shared_ptr< base > &value)
template<class T >
void	insert (const std::string &key, T &&val, typename value_traits< T >::type *=0)
void	erase (const std::string &key)
	table (const table &obj)=delete
table &	operator= (const table &rhs)=delete
template<>
array_of_trait< array >::return_type	get_array_of (const std::string &key) const
template<>
array_of_trait< array >::return_type	get_qualified_array_of (const std::string &key) const
Public Member Functions inherited from cpptoml::base
virtual	~base ()=default
virtual std::shared_ptr< base >	clone () const =0
virtual MBool	is_value () const
virtual MBool	is_table () const
std::shared_ptr< table >	as_table ()
virtual MBool	is_array () const
std::shared_ptr< array >	as_array ()
virtual MBool	is_table_array () const
std::shared_ptr< table_array >	as_table_array ()
template<class T >
std::shared_ptr< value< T > >	as ()
template<class T >
std::shared_ptr< const value< T > >	as () const
template<class Visitor , class... Args>
void	accept (Visitor &&visitor, Args &&... args) const
base_type	type () const
template<>
std::shared_ptr< value< double > >	as ()
template<>
std::shared_ptr< const value< double > >	as () const

Private Member Functions
	table ()
	table ()
std::vector< std::string >	split (const std::string &value, char separator) const
MBool	resolve_qualified (const std::string &key, std::shared_ptr< base > *p=nullptr) const

Private Attributes
string_to_base_map	map_

Friends
class	table_array
std::shared_ptr< table >	make_table ()

Additional Inherited Members
Protected Member Functions inherited from cpptoml::base
	base (const base_type t)
	base ()

Detailed Description

Represents a TOML keytable.

Definition at line 1063 of file cpptoml.h.

Member Typedef Documentation

const_iterator

using cpptoml::table::const_iterator = string_to_base_map::const_iterator

tables can be iterated over. Const version.

Definition at line 1078 of file cpptoml.h.

iterator

using cpptoml::table::iterator = string_to_base_map::iterator

tables can be iterated over.

Definition at line 1073 of file cpptoml.h.

Constructor & Destructor Documentation

table() [1/3]

cpptoml::table::table ( )

inlineprivate

Definition at line 1295 of file cpptoml.h.

          : base(base_type::TABLE) {
    // nothing
  }

table() [2/3]

cpptoml::table::table ( )

inlineprivate

Definition at line 1299 of file cpptoml.h.

          {
    // nothing
  }

table() [3/3]

cpptoml::table::table ( const table &  obj )

delete

Member Function Documentation

begin() [1/2]

iterator cpptoml::table::begin ( )

inline

Definition at line 1080 of file cpptoml.h.

{ return map_.begin(); }

begin() [2/2]

const_iterator cpptoml::table::begin ( ) const

inline

Definition at line 1082 of file cpptoml.h.

{ return map_.begin(); }

clone()

std::shared_ptr< base > cpptoml::table::clone ( ) const

inlineoverridevirtual

Implements cpptoml::base.

Definition at line 1453 of file cpptoml.h.

                                              {
  auto result = make_table();
  for(const auto& pr : map_)
    result->insert(pr.first, pr.second->clone());
  return result;
}

contains()

MBool cpptoml::table::contains ( const std::string &  key ) const

inline

Determines if this key table contains the given key.

Definition at line 1095 of file cpptoml.h.

{ return map_.find(key) != map_.end(); }

contains_qualified()

MBool cpptoml::table::contains_qualified ( const std::string &  key ) const

inline

Determines if this key table contains the given key. Will resolve "qualified keys". Qualified keys are the full access path separated with dots like "grandparent.parent.child".

Definition at line 1102 of file cpptoml.h.

{ return resolve_qualified(key); }

empty()

MBool cpptoml::table::empty ( ) const

inline

Definition at line 1090 of file cpptoml.h.

{ return map_.empty(); }

end() [1/2]

iterator cpptoml::table::end ( )

inline

Definition at line 1084 of file cpptoml.h.

{ return map_.end(); }

end() [2/2]

const_iterator cpptoml::table::end ( ) const

inline

Definition at line 1086 of file cpptoml.h.

{ return map_.end(); }

erase()

void cpptoml::table::erase ( const std::string &  key )

inline

Removes an element from the table.

Definition at line 1289 of file cpptoml.h.

{ map_.erase(key); }

get()

std::shared_ptr< base > cpptoml::table::get ( const std::string &  key ) const

inline

Obtains the base for a given key.

Exceptions

std::out_of_range

if the key does not exist

Definition at line 1108 of file cpptoml.h.

{ return map_.at(key); }

get_array()

std::shared_ptr< array > cpptoml::table::get_array ( const std::string &  key ) const

inline

Obtains an array for a given key.

Definition at line 1144 of file cpptoml.h.

                                                             {
    if(!contains(key)) return nullptr;
    return get(key)->as_array();
  }

get_array_of() [1/2]

template<class T >

array_of_trait< T >::return_type cpptoml::table::get_array_of ( const std::string &  key ) const

inline

Helper function that attempts to get an array of values of a given type corresponding to the template parameter for a given key.

If the key doesn't exist, doesn't exist as an array type, or one or more keys inside the array type are not of type T, an empty option is returned. Otherwise, an option containing a vector of the values is returned.

Definition at line 1227 of file cpptoml.h.

                                                                                        {
    if(auto v = get_array(key)) {
      std::vector<T> result;
      result.reserve(v->get().size());
 
      for(const auto& b : v->get()) {
        if(auto val = b->as<T>())
          result.push_back(val->get());
        else
          return {};
      }
      return {std::move(result)};
    }
 
    return {};
  }

get_array_of() [2/2]

template<>

array_of_trait< array >::return_type cpptoml::table::get_array_of ( const std::string &  key ) const

inline

Helper function that attempts to get an array of arrays for a given key.

If the key doesn't exist, doesn't exist as an array type, or one or more keys inside the array type are not of type T, an empty option is returned. Otherwise, an option containing a vector of the values is returned.

Definition at line 1364 of file cpptoml.h.

                                                                                                      {
  if(auto v = get_array(key)) {
    std::vector<std::shared_ptr<array>> result;
    result.reserve(v->get().size());
 
    for(const auto& b : v->get()) {
      if(auto val = b->as_array())
        result.push_back(val);
      else
        return {};
    }
 
    return {std::move(result)};
  }
 
  return {};
}

get_array_qualified()

std::shared_ptr< array > cpptoml::table::get_array_qualified ( const std::string &  key ) const

inline

Obtains an array for a given key. Will resolve "qualified keys".

Definition at line 1152 of file cpptoml.h.

                                                                       {
    if(!contains_qualified(key)) return nullptr;
    return get_qualified(key)->as_array();
  }

get_as()

template<class T >

option< T > cpptoml::table::get_as ( const std::string &  key ) const

inline

Helper function that attempts to get a value corresponding to the template parameter from a given key.

Definition at line 1179 of file cpptoml.h.

                                               {
#ifndef CPPTOML_NO_EXCEPTIONS
    try {
      return get_impl<T>(get(key));
    } catch(const std::out_of_range&) {
      return {};
    }
#else
    if(contains(key)) {
      return get_impl<T>(get(key));
    } else {
      return {};
    }
#endif
  }

get_qualified()

std::shared_ptr< base > cpptoml::table::get_qualified ( const std::string &  key ) const

inline

Obtains the base for a given key. Will resolve "qualified keys". Qualified keys are the full access path separated with dots like "grandparent.parent.child".

Exceptions

std::out_of_range

if the key does not exist

Definition at line 1117 of file cpptoml.h.

                                                                {
    std::shared_ptr<base> p;
    resolve_qualified(key, &p);
    return p;
  }

get_qualified_array_of() [1/2]

template<class T >

array_of_trait< T >::return_type cpptoml::table::get_qualified_array_of ( const std::string &  key ) const

inline

Helper function that attempts to get an array of values of a given type corresponding to the template parameter for a given key. Will resolve "qualified keys".

If the key doesn't exist, doesn't exist as an array type, or one or more keys inside the array type are not of type T, an empty option is returned. Otherwise, an option containing a vector of the values is returned.

Definition at line 1255 of file cpptoml.h.

                                                                                                  {
    if(auto v = get_array_qualified(key)) {
      std::vector<T> result;
      result.reserve(v->get().size());
 
      for(const auto& b : v->get()) {
        if(auto val = b->as<T>())
          result.push_back(val->get());
        else
          return {};
      }
      return {std::move(result)};
    }
 
    return {};
  }

get_qualified_array_of() [2/2]

template<>

array_of_trait< array >::return_type cpptoml::table::get_qualified_array_of ( const std::string &  key ) const

inline

Helper function that attempts to get an array of arrays for a given key. Will resolve "qualified keys".

If the key doesn't exist, doesn't exist as an array type, or one or more keys inside the array type are not of type T, an empty option is returned. Otherwise, an option containing a vector of the values is returned.

Definition at line 1392 of file cpptoml.h.

                                                                                                                {
  if(auto v = get_array_qualified(key)) {
    std::vector<std::shared_ptr<array>> result;
    result.reserve(v->get().size());
 
    for(const auto& b : v->get()) {
      if(auto val = b->as_array())
        result.push_back(val);
      else
        return {};
    }
 
    return {std::move(result)};
  }
 
  return {};
}

get_qualified_as()

template<class T >

option< T > cpptoml::table::get_qualified_as ( const std::string &  key ) const

inline

Helper function that attempts to get a value corresponding to the template parameter from a given key. Will resolve "qualified keys".

Definition at line 1201 of file cpptoml.h.

                                                         {
#ifndef CPPTOML_NO_EXCEPTIONS
    try {
      return get_impl<T>(get_qualified(key));
    } catch(const std::out_of_range&) {
      return {};
    }
#else
    if(contains_qualified(key)) {
      return get_impl<T>(get_qualified(key));
    } else {
      return {};
    }
#endif
  }

get_table()

std::shared_ptr< table > cpptoml::table::get_table ( const std::string &  key ) const

inline

Obtains a table for a given key, if possible.

Definition at line 1126 of file cpptoml.h.

                                                             {
    if(contains(key) && get(key)->is_table()) return std::static_pointer_cast<table>(get(key));
    return nullptr;
  }

get_table_array()

std::shared_ptr< table_array > cpptoml::table::get_table_array ( const std::string &  key ) const

inline

Obtains a table_array for a given key, if possible.

Definition at line 1160 of file cpptoml.h.

                                                                         {
    if(!contains(key)) return nullptr;
    return get(key)->as_table_array();
  }

get_table_array_qualified()

std::shared_ptr< table_array > cpptoml::table::get_table_array_qualified ( const std::string &  key ) const

inline

Obtains a table_array for a given key, if possible. Will resolve "qualified keys".

Definition at line 1169 of file cpptoml.h.

                                                                                   {
    if(!contains_qualified(key)) return nullptr;
    return get_qualified(key)->as_table_array();
  }

get_table_qualified()

std::shared_ptr< table > cpptoml::table::get_table_qualified ( const std::string &  key ) const

inline

Obtains a table for a given key, if possible. Will resolve "qualified keys".

Definition at line 1135 of file cpptoml.h.

                                                                       {
    if(contains_qualified(key) && get_qualified(key)->is_table())
      return std::static_pointer_cast<table>(get_qualified(key));
    return nullptr;
  }

insert() [1/2]

void cpptoml::table::insert ( const std::string &  key, const std::shared_ptr< base > &  value  )

inline

Adds an element to the keytable.

Definition at line 1275 of file cpptoml.h.

{ map_[key] = value; }

insert() [2/2]

template<class T >

void cpptoml::table::insert ( const std::string &  key, T &&  val, typename value_traits< T >::type *  = 0  )

inline

Convenience shorthand for adding a simple element to the keytable.

Definition at line 1282 of file cpptoml.h.

                                                                                {
    insert(key, make_value(std::forward<T>(val)));
  }

is_table()

MBool cpptoml::table::is_table ( ) const

inlineoverridevirtual

Determines if the given TOML element is a table.

Reimplemented from cpptoml::base.

Definition at line 1088 of file cpptoml.h.

{ return true; }

operator=()

table & cpptoml::table::operator= ( const table &  rhs )

delete

resolve_qualified()

MBool cpptoml::table::resolve_qualified ( const std::string &  key, std::shared_ptr< base > *  p = nullptr  ) const

inlineprivate

Definition at line 1326 of file cpptoml.h.

                                                                                        {
    auto parts = split(key, '.');
    auto last_key = parts.back();
    parts.pop_back();
 
    auto cur_table = this;
    for(const auto& part : parts) {
      cur_table = cur_table->get_table(part).get();
      if(!cur_table) {
#ifndef CPPTOML_NO_EXCEPTIONS
        if(!p) return false;
 
        throw std::out_of_range{key + " is not a valid key"};
#else
        return false;
#endif
      }
    }
 
    if(!p) return cur_table->map_.count(last_key) != 0;
 
    *p = cur_table->map_.at(last_key);
    return true;
  }

split()

std::vector< std::string > cpptoml::table::split ( const std::string &  value, char  separator  ) const

inlineprivate

Definition at line 1309 of file cpptoml.h.

                                                                           {
    std::vector<std::string> result;
    std::string::size_type p = 0;
    std::string::size_type q;
    while((q = value.find(separator, p)) != std::string::npos) {
      result.emplace_back(value, p, q - p);
      p = q + 1;
    }
    result.emplace_back(value, p);
    return result;
  }

Friends And Related Function Documentation

make_table

std::shared_ptr< table > make_table ( )

friend

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>();
}

table_array

friend class table_array

friend

Definition at line 1065 of file cpptoml.h.

Member Data Documentation

map_

string_to_base_map cpptoml::table::map_

private

Definition at line 1351 of file cpptoml.h.

---

The documentation for this class was generated from the following file:

• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/IO/cpptoml.h