Allow use of cpptoml with RTTI disabled (#77)

* Create enum class "base_type" and add as member to base class

* Add base_type_traits class and extent base_type enums by TABLE, ARRAY, and TABLE_ARRAY

* Add macro "CPPTOML_NO_RTTI" to disable reliance on runtime type information

* Guard all code snippets for supporting non-RTTI compilation by macros

Author: sloede

include/cpptoml.h

@@ -51,6 +51,10 @@ using string_to_base_map
     = std::unordered_map<std::string, std::shared_ptr<base>>;
 #endif
 
+// if defined, `base` will retain type information in form of an enum class
+// such that static_cast can be used instead of dynamic_cast
+// #define CPPTOML_NO_RTTI
+
 template <class T>
 class option
 {
@@ -396,6 +400,95 @@ inline std::shared_ptr<T> make_element();
 inline std::shared_ptr<table> make_table();
 inline std::shared_ptr<table_array> make_table_array();
 
+#if defined(CPPTOML_NO_RTTI)
+/// Base type used to store underlying data type explicitly if RTTI is disabled
+enum class base_type
+{
+    NONE,
+    STRING,
+    LOCAL_TIME,
+    LOCAL_DATE,
+    LOCAL_DATETIME,
+    OFFSET_DATETIME,
+    INT,
+    FLOAT,
+    BOOL,
+    TABLE,
+    ARRAY,
+    TABLE_ARRAY
+};
+
+/// Type traits class to convert C++ types to enum member
+template <class T>
+struct base_type_traits;
+
+template <>
+struct base_type_traits<std::string>
+{
+    static const base_type type = base_type::STRING;
+};
+
+template <>
+struct base_type_traits<local_time>
+{
+    static const base_type type = base_type::LOCAL_TIME;
+};
+
+template <>
+struct base_type_traits<local_date>
+{
+    static const base_type type = base_type::LOCAL_DATE;
+};
+
+template <>
+struct base_type_traits<local_datetime>
+{
+    static const base_type type = base_type::LOCAL_DATETIME;
+};
+
+template <>
+struct base_type_traits<offset_datetime>
+{
+    static const base_type type = base_type::OFFSET_DATETIME;
+};
+
+template <>
+struct base_type_traits<int64_t>
+{
+    static const base_type type = base_type::INT;
+};
+
+template <>
+struct base_type_traits<double>
+{
+    static const base_type type = base_type::FLOAT;
+};
+
+template <>
+struct base_type_traits<bool>
+{
+    static const base_type type = base_type::BOOL;
+};
+
+template <>
+struct base_type_traits<table>
+{
+    static const base_type type = base_type::TABLE;
+};
+
+template <>
+struct base_type_traits<array>
+{
+    static const base_type type = base_type::ARRAY;
+};
+
+template <>
+struct base_type_traits<table_array>
+{
+    static const base_type type = base_type::TABLE_ARRAY;
+};
+#endif
+
 /**
  * A generic base TOML value used for type erasure.
  */
@@ -480,11 +573,28 @@ class base : public std::enable_shared_from_this<base>
     template <class Visitor, class... Args>
     void accept(Visitor&& visitor, Args&&... args) const;
 
+#if defined(CPPTOML_NO_RTTI)
+    base_type type() const
+    {
+      return type_;
+    }
+
+  protected:
+    base(const base_type t) : type_(t)
+    {
+        // nothing
+    }
+
+  private:
+    const base_type type_ = base_type::NONE;
+
+#else
   protected:
     base()
     {
         // nothing
     }
+#endif
 };
 
 /**
@@ -540,9 +650,15 @@ class value : public base
     /**
      * Constructs a value from the given data.
      */
+#if defined(CPPTOML_NO_RTTI)
+    value(const T& val) : base(base_type_traits<T>::type), data_(val)
+    {
+    }
+#else
     value(const T& val) : data_(val)
     {
     }
+#endif
 
     value(const value& val) = delete;
     value& operator=(const value& val) = delete;
@@ -560,34 +676,71 @@ std::shared_ptr<typename value_traits<T>::type> make_value(T&& val)
 template <class T>
 inline std::shared_ptr<value<T>> base::as()
 {
+#if defined(CPPTOML_NO_RTTI)
+    if (type() == base_type_traits<T>::type)
+        return std::static_pointer_cast<value<T>>(shared_from_this());
+    else
+        return nullptr;
+#else
     return std::dynamic_pointer_cast<value<T>>(shared_from_this());
+#endif
 }
 
 // special case value<double> to allow getting an integer parameter as a
 // double value
 template <>
 inline std::shared_ptr<value<double>> base::as()
 {
+#if defined(CPPTOML_NO_RTTI)
+    if (type() == base_type::FLOAT)
+        return std::static_pointer_cast<value<double>>(shared_from_this());
+
+    if (type() == base_type::INT)
+    {
+        auto v = std::static_pointer_cast<value<int64_t>>(shared_from_this());
+        return make_value<double>(static_cast<double>(v->get()));;
+    }
+#else
     if (auto v = std::dynamic_pointer_cast<value<double>>(shared_from_this()))
         return v;
 
     if (auto v = std::dynamic_pointer_cast<value<int64_t>>(shared_from_this()))
         return make_value<double>(static_cast<double>(v->get()));
+#endif
 
     return nullptr;
 }
 
 template <class T>
 inline std::shared_ptr<const value<T>> base::as() const
 {
+#if defined(CPPTOML_NO_RTTI)
+    if (type() == base_type_traits<T>::type)
+        return std::static_pointer_cast<const value<T>>(shared_from_this());
+    else
+        return nullptr;
+#else
     return std::dynamic_pointer_cast<const value<T>>(shared_from_this());
+#endif
 }
 
 // special case value<double> to allow getting an integer parameter as a
 // double value
 template <>
 inline std::shared_ptr<const value<double>> base::as() const
 {
+#if defined(CPPTOML_NO_RTTI)
+    if (type() == base_type::FLOAT)
+        return std::static_pointer_cast<const value<double>>(shared_from_this());
+
+    if (type() == base_type::INT)
+    {
+        auto v = as<int64_t>();
+        // the below has to be a non-const value<double> due to a bug in
+        // libc++: https://llvm.org/bugs/show_bug.cgi?id=18843
+        return make_value<double>(static_cast<double>(v->get()));
+    }
+#else
     if (auto v
         = std::dynamic_pointer_cast<const value<double>>(shared_from_this()))
         return v;
@@ -598,6 +751,7 @@ inline std::shared_ptr<const value<double>> base::as() const
         // libc++: https://llvm.org/bugs/show_bug.cgi?id=18843
         return make_value<double>(static_cast<double>(v->get()));
     }
+#endif
 
     return nullptr;
 }
@@ -839,7 +993,14 @@ class array : public base
     }
 
   private:
+#if defined(CPPTOML_NO_RTTI)
+    array() : base(base_type::ARRAY)
+    {
+        // empty
+    }
+#else
     array() = default;
+#endif
 
     template <class InputIterator>
     array(InputIterator begin, InputIterator end) : values_{begin, end}
@@ -992,10 +1153,17 @@ class table_array : public base
     }
 
   private:
+#if defined(CPPTOML_NO_RTTI)
+    table_array() : base(base_type::TABLE_ARRAY)
+    {
+        // nothing
+    }
+#else
     table_array()
     {
         // nothing
     }
+#endif
 
     table_array(const table_array& obj) = delete;
     table_array& operator=(const table_array& rhs) = delete;
@@ -1369,10 +1537,17 @@ class table : public base
     }
 
   private:
+#if defined(CPPTOML_NO_RTTI)
+    table() : base(base_type::TABLE)
+    {
+        // nothing
+    }
+#else
     table()
     {
         // nothing
     }
+#endif
 
     table(const table& obj) = delete;
     table& operator=(const table& rhs) = delete;