TinyJSON.h

#pragma once
// Licensed to Florent Guelfucci under one or more agreements.
// Florent Guelfucci licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
#ifndef TJ_INCLUDED 
#define TJ_INCLUDED

// Assume that we do not want std::string
#ifndef TJ_INCLUDE_STD_STRING
#define TJ_INCLUDE_STD_STRING 0
#endif

// use the std vector or not, (use the custom array).
// using the vector can cause performance issue as the
// array is optimised for deep searches.
#ifndef TJ_INCLUDE_STDVECTOR
#define TJ_INCLUDE_STDVECTOR 0
#endif

#include <algorithm>
#include <functional>
#include <exception>
#include <iterator>
#include <type_traits>
#include <vector>

#if TJ_INCLUDE_STDVECTOR == 0
#include <stdexcept>
#endif

#if TJ_INCLUDE_STD_STRING == 1
#include <string>
#endif

// https://semver.org/
// Semantic Versioning 2.0.0
//   MAJOR version when you make incompatible API changes
//   MINOR version when you add functionality in a backward compatible manner
//   PATCH version when you make backward compatible bug fixes
// v0.1.1 - added some add( ... ) and set( ... ) methods
// v0.1.2 - added a bit of get/set( ... ) for values and objects.
// v0.1.3 - added iterator.
// v0.1.4 - added copy/move constructors and operators.
// v0.2.0 - Breaking change: get_* methods no longer take throw parameters, use parse_options::strict instead.
// v0.2.1 - added remove_at to TJValueArray.
// v0.2.2 - added support for Json5 https://github.com/json5/
// v0.2.3 - added atomic file saving
// v0.2.4 - added operator[] and as<T>() accessor to TJValue
// v0.2.5 - added raise warning when key is not found.
// v0.2.6 - fixed a bug in the resizing of string buffers.
// v0.2.7 - improved parse_file error reporting with specific system errors and file name.
// v0.2.8 - conformed empty input parsing to RFC specifications (returns nullptr / throws instead of empty string).
// v0.2.9 - added line and column numbers to parse messages and TJParseException.
// v0.2.10 - fixed number overflows when parsing, dumping and getting numbers, (issues #53, #54 and #55).
static const short TJ_VERSION_MAJOR = 0;
static const short TJ_VERSION_MINOR = 2;
static const short TJ_VERSION_PATCH = 10;
static const char TJ_VERSION_STRING[] = "0.2.10";

#ifndef TJ_USE_CHAR
#  define TJ_USE_CHAR 1
#endif

#if TJ_USE_CHAR == 1
#  define TJCHAR char
#  define TJCHARPREFIX(x) x
#elif TJ_USE_CHAR == 8
#  define TJCHAR char8_t
#  define TJCHARPREFIX(x) u8 ## x
#elif TJ_USE_CHAR == 16
#  define TJCHAR char16_t
#  define TJCHARPREFIX(x) u ## x
#elif TJ_USE_CHAR == 32
#  define TJCHAR char32_t
#  define TJCHARPREFIX(x) U ## x
#endif

#define TJ_TEMPLATE_FLOAT                           \
  typename std::enable_if<                          \
    std::is_same<T, float>::value ||                \
    std::is_same<T, double>::value ||               \
    std::is_same<T, long double>::value,            \
  T >

#define TJ_TEMPLATE_NUMBER                          \
  typename std::enable_if<                          \
    std::is_same<T, signed>::value ||               \
    std::is_same<T, unsigned>::value ||             \
    std::is_same<T, short>::value ||                \
    std::is_same<T, long>::value ||                 \
    std::is_same<T, int>::value ||                  \
    std::is_same<T, unsigned int>::value ||         \
    std::is_same<T, signed int>::value ||           \
    std::is_same<T, unsigned short int>::value ||   \
    std::is_same<T, signed short int>::value ||     \
    std::is_same<T, long int>::value ||             \
    std::is_same<T, signed long int>::value ||      \
    std::is_same<T, unsigned long int>::value ||    \
    std::is_same<T, long long int>::value ||        \
    std::is_same<T, unsigned long long int>::value, \
  T >

namespace TinyJSON
{
#if TJ_INCLUDE_STDVECTOR == 1
#define TJDICTIONARY std::vector<TJMember*>
#define TJLIST std::vector<TJValue*>
#else
class TJList;
class TJDictionary;
#define TJDICTIONARY TJDictionary
#define TJLIST TJList
#endif
 
  // optional class
  template<typename T>
  class Optional
  {
  public:
    Optional() noexcept : _has_value(false) {}

    Optional(const T& value) noexcept(std::is_nothrow_copy_constructible<T>::value) :
      _has_value(true)
    {
      new(&_storage.value) T(value);
    }

    Optional(T&& value) noexcept(std::is_nothrow_move_constructible<T>::value) :
      _has_value(true)
    {
      new(&_storage.value) T(std::move(value));
    }

    Optional(const Optional& other) noexcept(std::is_nothrow_copy_constructible<T>::value) :
      _has_value(other._has_value)
    {
      if (_has_value)
      {
        new(&_storage.value) T(other._storage.value);
      }
    }

    Optional(Optional&& other) noexcept(std::is_nothrow_move_constructible<T>::value) :
      _has_value(other._has_value)
    {
      if (_has_value)
      {
        new(&_storage.value) T(std::move(other._storage.value));
      }
    }

    ~Optional()
    {
      reset();
    }

    [[nodiscard]] inline bool operator!() const noexcept
    {
      if (!has_value())
      {
        return true;
      }
      return !(value());
    }

    [[nodiscard]] inline bool operator==(const Optional& other) const noexcept
    {
      if (!other.has_value() && !has_value())
      {
        return true;
      }
      if (!has_value() || !other.has_value())
      {
        return false;
      }
      return other.value() == value();
    }

    [[nodiscard]] inline bool operator!=(const Optional& other) const noexcept
    {
      return !(other == *this);
    }

    [[nodiscard]] inline bool operator==(const T& other) const noexcept
    {
      if (!has_value())
      {
        return false;
      }
      return value() == other;
    }

    [[nodiscard]] inline bool operator!=(const T& other) const noexcept
    {
      return !(*this == other);
    }

    Optional& operator=(const Optional& other) noexcept(std::is_nothrow_copy_constructible<T>::value)
    {
      if (this != &other)
      {
        if (other._has_value)
        {
          if (_has_value)
          {
            _storage.value = other._storage.value;
          }
          else
          {
            new(&_storage.value) T(other._storage.value);
            _has_value = true;
          }
        }
        else
        {
          reset();
        }
      }
      return *this;
    }

    Optional& operator=(Optional&& other) noexcept(std::is_nothrow_move_constructible<T>::value)
    {
      if (this != &other)
      {
        if (other._has_value)
        {
          if (_has_value)
          {
            _storage.value = std::move(other._storage.value);
          }
          else
          {
            new(&_storage.value) T(std::move(other._storage.value));
            _has_value = true;
          }
        }
        else
        {
          reset();
        }
      }
      return *this;
    }

    void reset() noexcept
    {
      if (_has_value)
      {
        _storage.value.~T();
        _has_value = false;
      }
    }

    [[nodiscard]] inline T& value() &
    {
      if (!_has_value) throw std::logic_error("Optional has no value");
      return _storage.value;
    }

    [[nodiscard]] inline const T& value() const &
    {
      if (!_has_value) throw std::logic_error("Optional has no value");
      return _storage.value;
    }

    [[nodiscard]] inline const T& value_or(const T& if_has_no_value) const noexcept
    {
      return _has_value ? _storage.value : if_has_no_value;
    }

    [[nodiscard]] inline bool has_value() const noexcept
    {
      return _has_value;
    }

    [[nodiscard]] inline explicit operator bool() const noexcept
    {
      return _has_value;
    }

    [[nodiscard]] inline T& operator*() & noexcept
    {
      return _storage.value;
    }

    [[nodiscard]] inline const T& operator*() const & noexcept
    {
      return _storage.value;
    }

    [[nodiscard]] inline T* operator->() noexcept
    {
      return &_storage.value;
    }

    [[nodiscard]] inline const T* operator->() const noexcept
    {
      return &_storage.value;
    }

  private:
    union Storage
    {
      T value;
      char dummy;
      Storage() : dummy(0) {}
      ~Storage() {}
    } _storage;
    bool _has_value;
  };

  template<typename T>
  inline bool operator==(const T& lhs, const Optional<T>& rhs)
  {
    return rhs == lhs;
  }

  template<typename T>
  inline bool operator!=(const T& lhs, const Optional<T>& rhs)
  {
    return rhs != lhs;
  }

  // the various types of formatting.
  enum class formatting
  {
    minify,
    indented
  };

  template<typename T> struct is_vector : std::false_type {};
  template<typename T, typename A> struct is_vector<std::vector<T, A>> : std::true_type {};

  /// <summary>
  /// The parsing options.
  /// </summary>
  struct parse_options
  {
    enum specification
    {
      rfc4627,
      rfc7159,
      rfc8259,
      json5_1_0_0   //  https://spec.json5.org/ v1.0.0
    };

    enum message_type
    {
      trace,
      debug,
      info,
      warning,
      error,
      fatal
    };

    /// <summary>
    /// The RFC specification we want to follow.
    /// </summary>
    specification specification = rfc8259;

    /// <summary>
    /// If we want to throw an exception or not.
    /// </summary>
    bool throw_exception = false;

    /// <summary>
    /// If we want to be strict or not when calling getter methods.
    /// </summary>
    bool strict = false;

    /// <summary>
    /// How deep we want to allow the array/objects to recuse.
    /// </summary>
    unsigned int max_depth = 64;

    /// <summary>
    /// The callback function that will be called on errors/warnings/etc.
    //  0 = trace
    //  1 = debug
    //  2 = info
    //  3 = warning
    //  4 = error
    //  5 = fatal/panic/exception
    //  The line and column are 1-based and point to where in the source the message was raised.
    //  If there is no position, (the source is null, the file could not be opened, a key was not found etc.)
    //  then both the line and column are -1.
    /// <summary>
    std::function<void(message_type, const TJCHAR*, int, int)> callback_function = [] (message_type, const TJCHAR*, int, int) {
      // do nothing
    };
  };

  /// <summary>
  /// The write options.
  /// </summary>
  struct write_options
  {
    enum byte_order_mark
    {
      none,
      utf8
    };

    /// <summary>
    /// If we want to throw an exception or not.
    /// </summary>
    bool throw_exception = false;

    /// <summary>
    /// The formatting type we want to use.
    /// </summary>
    formatting write_formatting = formatting::indented;

    /// <summary>
    /// The byte order mark we will be using.
    /// </summary>
    byte_order_mark byte_order_mark = none;
  };

  class TJWriteException : public std::exception
  {
  public:
    TJWriteException(const char* message);
    TJWriteException(const TJWriteException& exception);
    TJWriteException& operator=(const TJWriteException& exception);
    virtual ~TJWriteException() noexcept;

    virtual const char* what() const noexcept;

  private:
    void free_message() noexcept;
    void assign_message(const char* message);
    char* _message;
  };

  class TJParseException : public std::exception
  {
  public:
    TJParseException(const char* message, int line = -1, int column = -1);
    TJParseException(const TJParseException& exception);
    TJParseException& operator=(const TJParseException& exception);
    virtual ~TJParseException() noexcept;

    virtual const char* what() const noexcept;

    /// <summary>
    /// The 1-based line number where the error happened, -1 if unknown.
    /// </summary>
    int line() const noexcept;

    /// <summary>
    /// The 1-based column number where the error happened, -1 if unknown.
    /// </summary>
    int column() const noexcept;

  private:
    void free_message() noexcept;
    void assign_message(const char* message);
    char* _message;
    int _line;
    int _column;
  };

  struct internal_dump_configuration;
  class TJHelper;
  class TJValueArray;
  class TJValueObject;

  // A simple JSON value, the base of all items in a json
  class TJValue
  {
    friend TJValueArray;
    friend TJValueObject;
  private:
    template<bool IsConst>
    class base_iterator
    {
      friend TJValue;
      int _current;
      const int _size;
#if __cplusplus >= 201402L  // C++14 or later
      using TJValueType = std::conditional_t<IsConst, const TJValue, TJValue>;
#else
      using TJValueType = typename std::conditional<IsConst, const TJValue, TJValue>::type;
#endif            
      TJValueType& _type;

      static base_iterator make_begin(TJValueType& value)
      {
        base_iterator it(value);
        it._current = 0;
        return it;
      }
      static base_iterator make_end(TJValueType& value)
      {
        base_iterator it(value);
        it._current = it._size;
        return it;
      }
    public:
      base_iterator(TJValueType& type) :
        _current(0),
        _size(type.internal_size()),
        _type(type)
      {
      }

      const TJValueType& operator*() const noexcept
      {
        return _type.internal_at(_current);
      }
      TJValueType& operator*() noexcept
      {
        return _type.internal_at(_current);
      }
      base_iterator& operator++() noexcept
      {
        ++_current;
        if (_current >= _size)
        {
          _current = _size;
        }
        return *this;
      }
      base_iterator& operator--() noexcept
      {
        --_current;
        if (_current < 0)
        {
          _current = 0;
        }
        return *this;
      }

      bool operator!=(const base_iterator& other) const noexcept
      {
        return _current != other._current;
      }
      bool operator==(const base_iterator& other) const noexcept
      {
        return _current == other._current;
      }
    };

  public:
    TJValue(const parse_options& options = {});
    TJValue(const TJValue& other);
    TJValue(TJValue&& other) noexcept;
    TJValue& operator=(const TJValue& other);
    TJValue& operator=(TJValue&& other) noexcept;
    virtual ~TJValue();

    virtual bool is_object() const;
    virtual bool is_array() const;
    virtual bool is_string() const;
    virtual bool is_number() const;
    virtual bool is_true() const;
    virtual bool is_false() const;
    virtual bool is_null() const;
    virtual bool is_comment() const;
    virtual bool is_numeric(bool strict = false) const;

    const TJCHAR* dump(formatting formatting = formatting::indented, const TJCHAR* indent = TJCHARPREFIX("  ")) const;
    const TJCHAR* dump_string() const;

    /// <summary>
    /// Allow each derived class to create a copy of itself.
    /// </summary>
    /// <returns></returns>
    TJValue* clone() const;

    virtual void set_parse_options(const parse_options& options);

    bool get_boolean() const;
    const TJCHAR* get_string() const;
    
    // Non-template overload for ambiguous case - default to long long
    inline std::vector<long long> get_numbers() const
    {
      return get_raw_numbers();
    }
    inline long long get_number() const
    {
      return get_raw_number();
    }

    // Non-template overload for ambiguous case - default to long double
    inline std::vector<long double> get_floats() const
    {
      return get_raw_floats();
    }
    inline long double get_float() const
    {
      return get_raw_float();
    }

    template<typename T>
    std::vector<TJ_TEMPLATE_NUMBER::type>
    get_numbers() const
    {
      auto llVector = get_raw_numbers();
      std::vector<T> tVector;
      tVector.reserve(llVector.size());

      // Transform and move the values
      std::transform(std::make_move_iterator(llVector.begin()),
                     std::make_move_iterator(llVector.end()),
        std::back_inserter(tVector),
        [](long long value) { return static_cast<T>(value); });
      return tVector;
    }

    template<typename T>
    TJ_TEMPLATE_FLOAT::type
    get_floats() const
    {
      auto ldVector = get_raw_floats();
      std::vector<T> tVector;
      tVector.reserve(ldVector.size());

      // Transform and move the values
      std::transform(std::make_move_iterator(ldVector.begin()),
        std::make_move_iterator(ldVector.end()),
        std::back_inserter(tVector),
        [](long double value) { return static_cast<T>(value); });
      return tVector;
    }

    template<typename T>
    TJ_TEMPLATE_NUMBER::type
    get_number() const
    {
      return static_cast<T>(get_raw_number());
    }

    template<typename T>
    TJ_TEMPLATE_FLOAT::type
    get_float() const
    {
      return static_cast<T>(get_raw_float());
    }

    // For integral types (excluding bool)
    template<typename T>
    typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value, T>::type
    get() const
    {
      return get_number<T>();
    }

    // For floating point types
    template<typename T>
    typename std::enable_if<std::is_floating_point<T>::value, T>::type
    get() const
    {
      return get_float<T>();
    }

    // For boolean
    template<typename T>
    typename std::enable_if<std::is_same<T, bool>::value, bool>::type
    get() const
    {
      return get_boolean();
    }

    // For strings (const TJCHAR*)
    template<typename T>
    typename std::enable_if<std::is_same<T, const TJCHAR*>::value, const TJCHAR*>::type
    get() const
    {
      return get_string();
    }

#if TJ_INCLUDE_STD_STRING == 1
    // For std::string
    template<typename T>
    typename std::enable_if<std::is_same<T, std::string>::value, std::string>::type
    get() const
    {
      const TJCHAR* str = get_string();
      return str ? std::string(str) : std::string();
    }
#endif

    // For vectors
    template<typename T>
    typename std::enable_if<is_vector<T>::value, T>::type
    get() const
    {
      typedef typename T::value_type V;
      return get_vector_internal<V>(std::is_integral<V>());
    }

    /// <summary>
    /// Casting the value to a specific type.
    /// it behaves exactly as the get() methods.
    /// </summary>
    /// <returns></returns>
    template<typename T>
    auto as() const -> decltype(this->get<T>())
    {
      return get<T>();
    }

    /// <summary>
    /// Access a member of an object by its key.
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    const TJValue& operator[](const TJCHAR* key) const;

#if TJ_INCLUDE_STD_STRING == 1
    /// <summary>
    /// Access a member of an object by its key.
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    const TJValue& operator[](const std::string& key) const;
#endif

  public:
    static const TJValue& null_value();

  private:
    template<typename V>
    std::vector<V> get_vector_internal(std::true_type) const
    {
      return get_numbers<V>();
    }

    template<typename V>
    std::vector<V> get_vector_internal(std::false_type) const
    {
      return get_floats<V>();
    }

  public:
    using iterator = base_iterator<false>;
    using const_iterator = base_iterator<true>;

    inline iterator begin()
    {
      return iterator::make_begin(*this);
    }
    inline iterator end()
    {
      return iterator::make_end(*this);
    }
    inline const_iterator begin() const
    {
      return const_iterator::make_begin(*this);
    }
    inline const_iterator end() const
    {
      return const_iterator::make_end(*this);
    }

  protected:
    parse_options _parse_options;
    long long get_raw_number() const;
    long double get_raw_float() const;
    std::vector<long long> get_raw_numbers() const;
    std::vector<long double> get_raw_floats() const;

    /// <summary>
    /// Allow each derived class to create a copy of itself.
    /// </summary>
    /// <returns></returns>
    virtual TJValue* internal_clone() const = 0;

    virtual void internal_dump(internal_dump_configuration& configuration, const TJCHAR* current_indent) const = 0;

    virtual int internal_size() const;
    virtual const TJValue& internal_at(int index) const;
    virtual TJValue& internal_at(int index);

  private:
    mutable TJCHAR* _last_dump;
    void free_last_dump() const;
  };

  // The parser class
  class TJ
  {
  public:
    virtual ~TJ() = default;

    /// <summary>
    /// Return if the given source is valid or not.
    /// </summary>
    /// <param name="source"></param>
    /// <param name="parse_options"></param>
    /// <returns></returns>
    static bool is_valid(const TJCHAR* source, const parse_options& parse_options = {});

    /// <summary>
    /// Parse a json string
    /// </summary>
    /// <param name="source">The source we are trying to parse.</param>
    /// <param name="parse_options">The option we want to use when parsing this.</param>
    /// <returns></returns>
    static TJValue* parse(const TJCHAR* source, const parse_options& parse_options = {});

    /// <summary>
    /// Parse a json5 string
    /// </summary>
    /// <param name="source">The source we are trying to parse.</param>
    /// <param name="parse_options">The option we want to use when parsing this.</param>
    /// <returns></returns>
    static TJValue* parse5(const TJCHAR* source, const parse_options& parse_options = {});

    /// <summary>
    /// Parse a json file
    /// </summary>
    /// <param name="file_path">The source file we are trying to parse.</param>
    /// <param name="parse_options">The option we want to use when parsing this.</param>
    /// <returns></returns>
    static TJValue* parse_file(const TJCHAR* file_path, const parse_options& parse_options = {});

    /// <summary>
    /// Write a value to a file.
    /// </summary>
    /// <param name="file_path">The path of the file.</param>
    /// <param name="root">the value we are writing</param>
    /// <param name="write_options">The options we will be using to write</param>
    /// <returns></returns>
    static bool write_file(const TJCHAR* file_path, const TJValue& root, const write_options& write_options = {});

  protected:
    /// <summary>
    /// Internal parsing of a json source
    /// We will use the option to throw, (or not).
    /// </summary>
    /// <param name="source"></param>
    /// <param name="parse_options"></param>
    /// <returns></returns>
    static TJValue* internal_parse(const TJCHAR* source, const parse_options& parse_options);

    /// <summary>
    /// Write a value to a file.
    /// </summary>
    /// <param name="file_path">The path of the file.</param>
    /// <param name="root">the value we are writing</param>
    /// <param name="write_options">The options we will be using to write</param>
    /// <returns></returns>
    static bool internal_write_file(const TJCHAR* file_path, const TJValue& root, const write_options& write_options);

  private:
    TJ() = delete;
    TJ(TJ&&) = delete;
    TJ(const TJ&) = delete;
    TJ& operator=(const TJ&) = delete;
    TJ& operator=(TJ&&) = delete;
  };

  // A TJMember is a key value pair, (name/value), that belong to an object.
  class TJMember
  {
    friend TJHelper;
    friend TJValueObject;
  public:
    TJMember(const TJCHAR* string, const TJValue* value, const parse_options& options = {});
    TJMember(const TJMember& src);
    TJMember(TJMember&& src) noexcept;
    TJMember& operator=(const TJMember& src);
    TJMember& operator=(TJMember&& src) noexcept;
    virtual ~TJMember();

    const TJCHAR* name() const;
    const TJValue* value() const;
    TJValue* value();

    /// <summary>
    /// Casting the value to a specific type.
    /// it behaves exactly as the get() methods.
    /// </summary>
    /// <returns></returns>
    template<typename T>
    auto as() const -> decltype(this->value()->template as<T>())
    {
      return value()->template as<T>();
    }

    static const TJMember& null_member();

  protected:
    /// <summary>
    /// Move the value ownership to the member.
    /// The caller will _not_ delete!
    /// </summary>
    /// <param name="string"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    static TJMember* move(TJCHAR*& string, TJValue*& value, const parse_options& options = {});

    /// <summary>
    /// Move a value to the member
    /// </summary>
    void move_value(TJValue*& value);

  private:
    TJCHAR* _string;
    TJValue* _value;
    parse_options _parse_options;
    void free_string();
    void free_value();
  };

  class TJNumberedValues
  {
  protected:
    TJNumberedValues() noexcept : _number_of_items(-1)
    {
    }
    TJNumberedValues(const TJNumberedValues& other) noexcept : _number_of_items(other._number_of_items)
    {
    }
    TJNumberedValues(TJNumberedValues&& other) noexcept : _number_of_items(other._number_of_items)
    {
      other._number_of_items = 0;
    }
    TJNumberedValues& operator=(const TJNumberedValues& other) noexcept
    {
      if (this != &other)
      {
        _number_of_items = other._number_of_items;
      }
      return *this;
    }
    TJNumberedValues& operator=(TJNumberedValues&& other) noexcept
    {
      if (this != &other)
      {
        _number_of_items = other._number_of_items;
        other._number_of_items = 0;
      }
      return *this;
    }
    int get_number_of_items() const noexcept {
      return _number_of_items;
    };
    void reset_number_of_items() noexcept {
      _number_of_items = -1;
    }
    void set_number_of_items(int number_of_items) const noexcept {
      _number_of_items = number_of_items;
    }
  private:
    mutable int _number_of_items;
  };


  // A Json object that contain an array of key/value pairs.
  class TJValueObject : public TJValue, protected TJNumberedValues
  {
    friend TJHelper;
  public:
    TJValueObject(const parse_options& options = {});
    TJValueObject(const TJValueObject& other);
    TJValueObject(TJValueObject&& other) noexcept;
    TJValueObject& operator=(const TJValueObject& other);
    TJValueObject& operator=(TJValueObject&& other) noexcept;
    virtual ~TJValueObject();

    void set_parse_options(const parse_options& options) override;

    /// <summary>
    /// Get the number of items in this array
    /// </summary>
    /// <returns></returns>
    unsigned int get_number_of_items() const;

    /// <summary>
    /// Get the number of elements in this object (including comments)
    /// </summary>
    /// <returns></returns>
    unsigned int get_number_of_elements() const;
    bool is_numeric(bool strict = false) const override;

    /// <summary>
    /// Try and get a string value, if it does not exist, then we return null.
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    const TJCHAR* try_get_string(const TJCHAR* key, bool case_sensitive = true) const;

#if TJ_INCLUDE_STD_STRING == 1
    /// <summary>
    /// Try and get a string value, if it does not exist, then we return null.
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    inline const TJCHAR* try_get_string(const std::string& key, bool case_sensitive = true) const
    {
      return try_get_string(key.c_str(), case_sensitive);
    }
#endif

    /// <summary>
    /// Try and get the value of this member if it exists.
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    virtual const TJValue* try_get_value(const TJCHAR* key, bool case_sensitive = true) const;

    /// <summary>
    /// Check if a key exists in this object.
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    bool has_key(const TJCHAR* key, bool case_sensitive = true) const;

#if TJ_INCLUDE_STD_STRING == 1
    /// <summary>
    /// Check if a key exists in this object.
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    inline bool has_key(const std::string& key, bool case_sensitive = true) const
    {
      return has_key(key.c_str(), case_sensitive);
    }
#endif

    bool get_boolean(const TJCHAR* key, bool case_sensitive = true) const;
    const TJCHAR* get_string(const TJCHAR* key, bool case_sensitive = true) const;

    // Non-template overload for ambiguous case - default to long long
    inline long long get_number(const TJCHAR* key, bool case_sensitive = true) const
    {
      auto value = get_raw_number(key, case_sensitive);
      return static_cast<long long>(value.has_value() ? value.value() : 0.0);
    }
    inline std::vector<long long> get_numbers(const TJCHAR* key, bool case_sensitive = true) const
    {
      auto value = get_raw_numbers(key, case_sensitive);
      return value.has_value() ? value.value() : std::vector<long long>();
    }

    // Non-template overload for ambiguous case - default to long double
    inline long double get_float(const TJCHAR* key, bool case_sensitive = true) const
    {
      auto value = get_raw_float(key, case_sensitive);
      return static_cast<long double>(value.has_value() ? value.value() : 0.0);
    }
    inline std::vector<long double> get_floats(const TJCHAR* key, bool case_sensitive = true) const
    {
      auto value = get_raw_floats(key, case_sensitive);
      return value.has_value() ? value.value() : std::vector<long double>();
    }

    template<typename T>
    TJ_TEMPLATE_NUMBER::type
    get_number(const TJCHAR* key, bool case_sensitive = true) const
    {
      auto value = get_raw_number(key, case_sensitive);
      return static_cast<T>(value.has_value() ? value.value() : 0.0);
    }
    template<typename T>
    std::vector<TJ_TEMPLATE_NUMBER::type>
    get_numbers(const TJCHAR* key, bool case_sensitive = true) const
    {
      auto llVector = get_raw_numbers(key, case_sensitive);
      if (!llVector.has_value())
      {
        return {};
      }
      std::vector<T> tVector;
      tVector.reserve(llVector.value().size());

      // Transform and move the values
      std::transform(std::make_move_iterator(llVector.value().begin()),
        std::make_move_iterator(llVector.value().end()),
        std::back_inserter(tVector),
        [](long long value) { return static_cast<T>(value); });
      return tVector;
    }

    template<typename T>
    TJ_TEMPLATE_FLOAT::type
    get_float(const TJCHAR* key, bool case_sensitive = true) const
    {
      auto value = get_raw_float(key, case_sensitive);
      return static_cast<T>(value.has_value() ? value.value() : 0.0);
    }
    template<typename T>
    std::vector<TJ_TEMPLATE_FLOAT::type>
    get_floats(const TJCHAR* key, bool case_sensitive = true) const
    {
      auto ldVector = get_raw_floats(key, case_sensitive);
      if (!ldVector.has_value())
      {
        return {};
      }
      std::vector<T> tVector;
      tVector.reserve(ldVector.value().size());

      // Transform and move the values
      std::transform(std::make_move_iterator(ldVector.value().begin()),
        std::make_move_iterator(ldVector.value().end()),
        std::back_inserter(tVector),
        [](long double value) { return static_cast<T>(value); });
      return tVector;
    }

    // For integral types (excluding bool)
    template<typename T>
    typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value, T>::type
    get(const TJCHAR* key, bool case_sensitive = true) const
    {
      return get_number<T>(key, case_sensitive);
    }

    // For floating point types
    template<typename T>
    typename std::enable_if<std::is_floating_point<T>::value, T>::type
    get(const TJCHAR* key, bool case_sensitive = true) const
    {
      return get_float<T>(key, case_sensitive);
    }

    // For boolean
    template<typename T>
    typename std::enable_if<std::is_same<T, bool>::value, bool>::type
    get(const TJCHAR* key, bool case_sensitive = true) const
    {
      return get_boolean(key, case_sensitive);
    }

    // For strings (const TJCHAR*)
    template<typename T>
    typename std::enable_if<std::is_same<T, const TJCHAR*>::value, const TJCHAR*>::type
    get(const TJCHAR* key, bool case_sensitive = true) const
    {
      return get_string(key, case_sensitive);
    }

#if TJ_INCLUDE_STD_STRING == 1
    // For std::string
    template<typename T>
    typename std::enable_if<std::is_same<T, std::string>::value, std::string>::type
    get(const TJCHAR* key, bool case_sensitive = true) const
    {
      const TJCHAR* str = get_string(key, case_sensitive);
      return str ? std::string(str) : std::string();
    }

    // Overloads for std::string key
    template<typename T>
    T get(const std::string& key, bool case_sensitive = true) const
    {
      return get<T>(key.c_str(), case_sensitive);
    }
#endif

    // For vectors
    template<typename T>
    typename std::enable_if<is_vector<T>::value, T>::type
    get(const TJCHAR* key, bool case_sensitive = true) const
    {
      typedef typename T::value_type V;
      return get_vector_internal<V>(key, case_sensitive, std::is_integral<V>());
    }

    template<typename T>
    T get_or(const TJCHAR* key, const T& if_has_no_value, bool case_sensitive = true) const noexcept
    {
      if (!has_key(key, case_sensitive))
      {
        raise_key_not_found(key, parse_options::message_type::trace);
        return if_has_no_value;
      }
      try
      {
        return get<T>(key, case_sensitive);
      }
      catch (...)
      {
        return if_has_no_value;
      }
    }

  private:
    void raise_key_not_found(const TJCHAR* key, bool is_strict) const;
    void raise_key_not_found(const TJCHAR* key, parse_options::message_type type) const;
    template<typename V>
    std::vector<V> get_vector_internal(const TJCHAR* key, bool case_sensitive, std::true_type) const
    {
      return get_numbers<V>(key, case_sensitive);
    }

    template<typename V>
    std::vector<V> get_vector_internal(const TJCHAR* key, bool case_sensitive, std::false_type) const
    {
      return get_floats<V>(key, case_sensitive);
    }

  public:
    template<typename T>
    void set_floats(const TJCHAR* key, const std::vector<T>& values)
    {
      static_assert(std::is_floating_point<T>::value,
        "set_floats() only accepts floating-point types like float or double.");

      std::vector<long double> ldValues;
      ldValues.reserve(values.size());
      // Transform and move the values
      std::transform(values.begin(), values.end(), std::back_inserter(ldValues),
        [](T value) { return static_cast<long double>(value); });
      set_raw_floats(key, ldValues);
    }

    template<typename T>
    void set_numbers(const TJCHAR* key, const std::vector<T>& values)
    {
      static_assert(std::is_integral<T>::value,
        "set_numbers() only accepts integers like ints and longs.");

      std::vector<long long> llValues;
      llValues.reserve(values.size());
      // Transform and move the values
      std::transform(values.begin(), values.end(), std::back_inserter(llValues),
        [](TJ_TEMPLATE_NUMBER::type value) { return static_cast<long long>(value); });
      set_raw_numbers(key, llValues);
    }

    void set_floats(const TJCHAR* key, const std::vector<long double>& values)
    {
      set_raw_floats(key, values);
    }

    void set_numbers(const TJCHAR* key, const std::vector<long long>& values)
    {
      set_raw_numbers(key, values);
    }
        
#if TJ_INCLUDE_STD_STRING == 1
    inline bool get_boolean(const std::string& key, bool case_sensitive = true) const
    {
      return get_boolean(key.c_str(), case_sensitive);
    }
    inline long double get_float(const std::string& key, bool case_sensitive = true) const
    {
      return get_float(key.c_str(), case_sensitive);
    }
    inline long long get_number(const std::string& key, bool case_sensitive = true) const
    {
      return get_number(key.c_str(), case_sensitive);
    }
    inline const TJCHAR* get_string(const std::string& key, bool case_sensitive = true) const
    {
      return get_string(key.c_str(), case_sensitive);
    }
    inline std::vector<long double> get_floats(const std::string& key,bool case_sensitive = true) const
    {
      return get_floats(key.c_str(), case_sensitive);
    }
    inline std::vector<long long> get_numbers(const std::string& key, bool case_sensitive = true) const
    {
      return get_numbers(key.c_str(), case_sensitive);
    }

    template<typename T>
    std::vector<TJ_TEMPLATE_NUMBER::type>
      get_numbers(const std::string& key, bool case_sensitive = true) const
    {
      return get_numbers(key, case_sensitive);
    }

    template<typename T>
    std::vector<TJ_TEMPLATE_FLOAT::type>
    get_floats(const std::string& key, bool case_sensitive = true) const
    {
      return get_floats(key, case_sensitive);
    }

    /// <summary>
    /// Try and get the value of this member if it exists.
    /// </summary>
    /// <param name="name"></param>
    /// <returns></returns>
    inline const TJValue* try_get_value(const std::string& key, bool case_sensitive = true) const
    {
      return try_get_value(key.c_str(), case_sensitive);
    }

    template<typename T>
    void set_floats(const std::string& key, const std::vector<T>& values)
    {
      set_float(key.c_str(), values);
    }

    template<typename T>
    void set_numbers(const std::string& key, const std::vector<T>& values)
    {
      set_numbers(key.c_str(), values);
    }

    template<typename T>
    T get_or(const std::string& key, const T& if_has_no_value, bool case_sensitive = true) const noexcept
    {
      return get_or<T>(key.c_str(), if_has_no_value, case_sensitive);
    }
#endif

    const TJMember& operator [](int idx) const;
    using TJValue::operator[];
    TJMember* at(int idx) const;
    TJMember* element_at(int idx) const;

    bool is_object() const override;

    /// <summary>
    /// Set the value of a ... value
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    void set(const TJCHAR* key, const TJValue* value);

    /// <summary>
    /// Set the value of a ... value
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    inline void set(const TJCHAR* key, const TJValue& value)
    {
      set(key, &value);
    }

    /// <summary>
    /// Set the value of a ... value
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    template<typename T>
    typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value, void>::type
    set(const TJCHAR* key, T value)
    {
      set_number(key, static_cast<long long>(value));
    }

    /// <summary>
    /// Set the value of a ... value
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    template<typename T>
    typename std::enable_if<std::is_floating_point<T>::value, void>::type
    set(const TJCHAR* key, T value)
    {
      set_float(key, static_cast<long double>(value));
    }

    /// <summary>
    /// Set the value of a ... value
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    template<typename T>
    typename std::enable_if<std::is_same<T, bool>::value, void>::type
    set(const TJCHAR* key, T value)
    {
      set_boolean(key, value);
    }

    /// <summary>
    /// Set the value of a ... value
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    template<typename T>
    typename std::enable_if<std::is_same<T, const TJCHAR*>::value, void>::type
    set(const TJCHAR* key, T value)
    {
      set_string(key, value);
    }

#if TJ_INCLUDE_STD_STRING == 1
    /// <summary>
    /// Set the value of a ... value
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    template<typename T>
    typename std::enable_if<std::is_same<T, std::string>::value, void>::type
    set(const TJCHAR* key, const T& value)
    {
      set_string(key, value.c_str());
    }

    /// <summary>
    /// Set the value of a ... value
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    template<typename T>
    void set(const std::string& key, const T& value)
    {
      set<T>(key.c_str(), value);
    }
#endif

    /// <summary>
    /// Set the value of a ... value
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    template<typename T>
    typename std::enable_if<is_vector<T>::value, void>::type
    set(const TJCHAR* key, const T& value)
    {
      typedef typename T::value_type V;
      set_vector_internal<V>(key, value, std::is_integral<V>());
    }

    /// <summary>
    /// Set the value of a number
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    void set_number(const TJCHAR* key, long long value);

    /// <summary>
    /// Set the value of a number
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    void set_float(const TJCHAR* key, long double value);

    /// <summary>
    /// Set the value a boolean
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    void set_boolean(const TJCHAR* key, bool value);

    /// <summary>
    /// Set the value of a string.
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    void set_string(const TJCHAR* key, const TJCHAR* value);

    /// <summary>
    /// Set the value to null.
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    void set_null(const TJCHAR* key);

#if TJ_INCLUDE_STD_STRING == 1
    /// <summary>
    /// Set the value of a string.
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    inline void set_string(const std::string& key, const std::string& value)
    {
      set_string(key.c_str(), value.c_str());
    }
#endif

    /// <summary>
    /// Pop a value out of the list of items
    /// </summary>
    /// <param name="key"></param>
    void pop(const TJCHAR* key);

#if TJ_INCLUDE_STD_STRING == 1
    /// <summary>
    /// Pop a value out of the list of items
    /// </summary>
    /// <param name="key"></param>
    inline void pop(const std::string& key)
    {
      pop(key.c_str());
    }
#endif
  protected:
    Optional<long double> get_raw_float(const TJCHAR* key, bool case_sensitive) const;
    Optional<long long> get_raw_number(const TJCHAR* key, bool case_sensitive) const;
    Optional<std::vector<long double>> get_raw_floats(const TJCHAR* key, bool case_sensitive) const;
    Optional<std::vector<long long>> get_raw_numbers(const TJCHAR* key, bool case_sensitive) const;

    void set_raw_numbers(const TJCHAR* key, const std::vector<long long>& values);
    void set_raw_floats(const TJCHAR* key, const std::vector<long double>& values);

    /// <summary>
    /// Clone an array into an identical array
    /// </summary>
    TJValue* internal_clone() const override;

    /// <summary>
    /// Move the value ownership to the members.
    /// The caller will _not_ delete!
    /// </summary>
    /// <param name="members"></param>
    /// <returns></returns>
    static TJValueObject* move(TJDICTIONARY*& members, const parse_options& options = {});

    void internal_dump(internal_dump_configuration& configuration, const TJCHAR* current_indent) const override;

    virtual int internal_size() const override;
    virtual const TJValue& internal_at(int index) const override;
    virtual TJValue& internal_at(int index) override;

  private:
    template<typename V>
    void set_vector_internal(const TJCHAR* key, const std::vector<V>& values, std::true_type)
    {
      set_numbers<V>(key, values);
    }

    template<typename V>
    void set_vector_internal(const TJCHAR* key, const std::vector<V>& values, std::false_type)
    {
      set_floats<V>(key, values);
    }

    // All the key value pairs in this object.
    TJDICTIONARY* _members;

    void move_member_to_members(TJMember* member);
    void free_members();
  };

  // A Json object that contain an array of key/value pairs.
  class TJValueArray : public TJValue, protected TJNumberedValues
  {
    friend TJHelper;
  public:
    TJValueArray(const parse_options& options = {});
    TJValueArray(const TJValueArray& other);
    TJValueArray(TJValueArray&& other) noexcept;
    TJValueArray& operator=(const TJValueArray& other);
    TJValueArray& operator=(TJValueArray&& other) noexcept;
    virtual ~TJValueArray();

    void set_parse_options(const parse_options& options) override;

    /// <summary>
    /// Get the number of items in this array (excluding comments)
    /// </summary>
    /// <returns></returns>
    unsigned int get_number_of_items() const;

    /// <summary>
    /// Get the number of elements in this array (including comments)
    /// </summary>
    /// <returns></returns>
    unsigned int get_number_of_elements() const;

    const TJValue& operator [](int idx) const;
    using TJValue::operator[];
    TJValue* at(int idx) const;
    TJValue* element_at(int idx) const;

    bool is_array() const override;
    bool is_numeric(bool strict = false) const override;

    void add(const TJValue* value);
    void add_boolean(bool value);
    void add_string(const char* value);

    /// <summary>
    /// Remove an item from the array at a certain location.
    /// </summary>
    /// <param name="index"></param>
    void remove_at(unsigned int index);

    // Non-template overload for ambiguous case - default to long long
    inline void add_number(long long value)
    {
      add_raw_number(value);
    }
    inline void add_numbers(const std::vector<long long>& values)
    {
      add_raw_numbers(values);
    }
    inline void add_numbers(std::vector<long long>& values)
    {
      add_raw_numbers(values);
    }
    inline void add_numbers(std::vector<long long>&& values)
    {
      add_raw_numbers(values);
    }

    // Non-template overload for ambiguous case - default to long double
    inline void add_float(long double value)
    {
      add_raw_float(value);
    }
    inline void add_floats(const std::vector<long double>& values)
    {
      add_raw_floats(values);
    }

    template<typename T>
    void add_numbers(const std::vector<T>& values)
    {
      static_assert(std::is_integral<T>::value,
        "add_numbers() only accepts integers like ints and longs.");

      std::vector<long long> llValues;
      llValues.reserve(values.size());
      // Transform and move the values
      std::transform(values.begin(), values.end(), std::back_inserter(llValues),
        [](TJ_TEMPLATE_NUMBER::type value) { return static_cast<long long>(value); });
      add_raw_numbers(llValues);
    }

    template<typename T>
    void add_number(TJ_TEMPLATE_NUMBER::type value)
    {
      add_raw_number(static_cast<long long>(value));
    }

    template<typename T>
    void add_floats(const std::vector<T>& values)
    {
      static_assert(std::is_floating_point<T>::value,
        "add_floats() only accepts floating-point types like float or double.");

      std::vector<long double> ldValues;
      ldValues.reserve(values.size());
      // Transform and move the values
      std::transform(values.begin(), values.end(), std::back_inserter(ldValues),
        [](T value) { return static_cast<long double>(value); });
      add_raw_floats(ldValues);
    }

    template<typename T>
    void add_float(TJ_TEMPLATE_FLOAT::type value)
    {
      return add_raw_float(static_cast<long double>(value));
    }

    std::vector<long double> get_floats() const;
    std::vector<long long> get_numbers() const;

#if TJ_INCLUDE_STD_STRING == 1
    void add_string(const std::string& value)
    {
      add_string(value.c_str());
    }
#endif

  protected:
    void add_raw_number(long long value);
    void add_raw_float(long double value);
    void add_raw_numbers(const std::vector<long long>& values);
    void add_raw_floats(const std::vector<long double>& values);

    std::vector<long double> get_raw_floats() const;
    std::vector<long long> get_raw_numbers() const;

    void add_move(TJValue* value);

    /// <summary>
    /// Clone an array into an identical array
    /// </summary>
    TJValue* internal_clone() const override;

    /// <summary>
    /// Move the value ownership to the values.
    /// The caller will _not_ delete!
    /// </summary>
    /// <param name="values"></param>
    /// <returns></returns>
    static TJValueArray* move(TJLIST*& values, const parse_options& options = {});

    void internal_dump(internal_dump_configuration& configuration, const TJCHAR* current_indent) const override;
    
    virtual int internal_size() const override;
    virtual const TJValue& internal_at(int index) const override;
    virtual TJValue& internal_at(int index) override;

  private:
    // All the key value pairs in this object.
    TJLIST* _values;

    void free_values();
  };

  // A string JSon
  class TJValueString : public TJValue
  {
    friend TJHelper;
  public:
    TJValueString(const TJCHAR* value, const parse_options& options = {});
    TJValueString(const TJValueString& other);
    TJValueString(TJValueString&& other) noexcept;
    TJValueString& operator=(const TJValueString& other);
    TJValueString& operator=(TJValueString&& other) noexcept;
    virtual ~TJValueString();

    bool is_string() const override;
    bool is_numeric(bool strict = false) const override;

    const TJCHAR* raw_value() const;

  protected:
    /// <summary>
    /// Clone an array into an identical array
    /// </summary>
    TJValue* internal_clone() const override;

    /// <summary>
    /// Move the value ownership of the string.
    /// The caller will _not_ delete!
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    static TJValueString* move(TJCHAR*& value, const parse_options& options = {});

    void internal_dump(internal_dump_configuration& configuration, const TJCHAR* current_indent) const override;

  private:
    TJCHAR* _value;
    void free_value();
  };

  // A bolean JSon
  class TJValueBoolean : public TJValue
  {
  public:
    TJValueBoolean(bool is_true, const parse_options& options = {});
    TJValueBoolean(const TJValueBoolean& other);
    TJValueBoolean(TJValueBoolean&& other) noexcept;
    TJValueBoolean& operator=(const TJValueBoolean& other);
    TJValueBoolean& operator=(TJValueBoolean&& other) noexcept;
    virtual ~TJValueBoolean() = default;

    bool is_true() const override;
    bool is_false() const override;
    bool is_numeric(bool strict = false) const override;

  protected:
    /// <summary>
    /// Clone an array into an identical array
    /// </summary>
    TJValue* internal_clone() const override;

    void internal_dump(internal_dump_configuration& configuration, const TJCHAR* current_indent) const override;

  private:
    bool _is_true;
  };

  // A null JSon
  class TJValueNull : public TJValue
  {
  public:
    TJValueNull(const parse_options& options = {});
    TJValueNull(const TJValueNull& other);
    TJValueNull(TJValueNull&& other) noexcept;
    TJValueNull& operator=(const TJValueNull& other);
    TJValueNull& operator=(TJValueNull&& other) noexcept;
    virtual ~TJValueNull() = default;

    bool is_null() const override;
    bool is_numeric(bool strict = false) const override;

  protected:
    /// <summary>
    /// Clone an array into an identical array
    /// </summary>
    TJValue* internal_clone() const override;

    void internal_dump(internal_dump_configuration& configuration, const TJCHAR* current_indent) const override;
  };

  // A number JSon, float or int
  class TJValueNumber : public TJValue
  {
  protected:
    TJValueNumber(bool is_negative, const parse_options& options = {});
    TJValueNumber(const TJValueNumber& other);
    TJValueNumber(TJValueNumber&& other) noexcept;
    TJValueNumber& operator=(const TJValueNumber& other);
    TJValueNumber& operator=(TJValueNumber&& other) noexcept;
    virtual ~TJValueNumber() = default;

  public:
    bool is_number() const override;
    bool is_numeric(bool strict = false) const override;

    long double get_float() const;
    long long get_number() const;

  protected:
    bool _is_negative;
  };

  // A number JSon, float or int
  class TJValueNumberInt : public TJValueNumber
  {
  public:
    TJValueNumberInt(const long long& number, const parse_options& options = {});
    TJValueNumberInt(const unsigned long long& number, const bool is_negative, const parse_options& options = {});
    TJValueNumberInt(const TJValueNumberInt& other);
    TJValueNumberInt(TJValueNumberInt&& other) noexcept;
    TJValueNumberInt& operator=(const TJValueNumberInt& other);
    TJValueNumberInt& operator=(TJValueNumberInt&& other) noexcept;
    virtual ~TJValueNumberInt() = default;

    long long get_number() const;
    long double get_float() const;

  protected:
    /// <summary>
    /// Clone an array into an identical array
    /// </summary>
    TJValue* internal_clone() const override;

    void internal_dump(internal_dump_configuration& configuration, const TJCHAR* current_indent) const override;

  private:
    unsigned long long _number;
  };

  // A number JSon, float or int
  class TJValueNumberFloat : public TJValueNumber
  {
  public:
    TJValueNumberFloat(long double number, const parse_options& options = {});
    TJValueNumberFloat(const unsigned long long& number, const unsigned long long& fraction, const unsigned int fraction_exponent, bool is_negative, const parse_options& options = {});
    TJValueNumberFloat(const TJValueNumberFloat& other);
    TJValueNumberFloat(TJValueNumberFloat&& other) noexcept;
    TJValueNumberFloat& operator=(const TJValueNumberFloat& other);
    TJValueNumberFloat& operator=(TJValueNumberFloat&& other) noexcept;
    virtual ~TJValueNumberFloat();

    long double get_number() const;

  protected:
    /// <summary>
    /// Clone an array into an identical array
    /// </summary>
    TJValue* internal_clone() const override;

    void internal_dump(internal_dump_configuration& configuration, const TJCHAR* current_indent) const override;

  private:
    void make_string_if_needed() const;
    mutable TJCHAR* _string;
    unsigned long long _number;
    unsigned long long _fraction;
    unsigned int _fraction_exponent;
  };

  // A number JSon, float or int
  class TJValueNumberExponent : public TJValueNumber
  {
  public:
    TJValueNumberExponent(const unsigned long long& number, const unsigned long long& fraction, const unsigned int fraction_exponent, const int exponent,bool is_negative, const parse_options& options = {});
    TJValueNumberExponent(const TJValueNumberExponent& other);
    TJValueNumberExponent(TJValueNumberExponent&& other) noexcept;
    TJValueNumberExponent& operator=(const TJValueNumberExponent& other);
    TJValueNumberExponent& operator=(TJValueNumberExponent&& other) noexcept;
    virtual ~TJValueNumberExponent();

    long double get_number() const;

  protected:
    /// <summary>
    /// Clone an array into an identical value object
    /// </summary>
    TJValue* internal_clone() const override;

    void internal_dump(internal_dump_configuration& configuration, const TJCHAR* current_indent) const override;

  private:
    void make_string_if_needed() const;
    mutable TJCHAR* _string;
    unsigned long long _number;
    unsigned long long _fraction;
    unsigned int _fraction_exponent;
    int _exponent;
  };

  // A comment JSon
  class TJValueComment : public TJValue
  {
    friend TJHelper;
  public:
    TJValueComment(const TJCHAR* value, const parse_options& options = {});
    TJValueComment(const TJValueComment& other);
    TJValueComment(TJValueComment&& other) noexcept;
    TJValueComment& operator=(const TJValueComment& other);
    TJValueComment& operator=(TJValueComment&& other) noexcept;
    virtual ~TJValueComment();

    bool is_comment() const override;
    bool is_numeric(bool strict = false) const override;

    const TJCHAR* raw_value() const;

  protected:
    /// <summary>
    /// Clone a comment into an identical comment object
    /// </summary>
    TJValue* internal_clone() const override;

    /// <summary>
    /// Move the value ownership of the comment string.
    /// </summary>
    static TJValueComment* move(TJCHAR*& value, const parse_options& options = {});

    void internal_dump(internal_dump_configuration& configuration, const TJCHAR* current_indent) const override;

  private:
    TJCHAR* _value;
    void free_value();
  };

  // user_literals
  inline TJValue* operator ""_tj(const TJCHAR * source, std::size_t)
  {
    parse_options options = {};
    options.throw_exception = true;
    return TJ::parse(source, options);
  }

  #if TJ_INCLUDE_STD_STRING == 1
  inline std::string operator ""_tj_indent(const TJCHAR * source, std::size_t)
  {
    parse_options options = {};
    options.throw_exception = true;
    auto* tj = TJ::parse(source, options);
    if (nullptr == tj)
    {
      //  exception will throw.
      return TJCHARPREFIX("");
    }
    std::string json(tj->dump(formatting::indented));
    delete tj;
    return json;
  }  

  inline std::string operator ""_tj_minify(const TJCHAR * source, std::size_t)
  {
    parse_options options = {};
    options.throw_exception = true;
    auto* tj = TJ::parse(source, options);
    if (nullptr == tj)
    {
      //  exception will throw.
      return TJCHARPREFIX("");
    }
    std::string json(tj->dump(formatting::minify));
    delete tj;
    return json;
  }
  #endif
} // TinyJSON
#endif // !TJ_INCLUDED