Remove stale copy of json

cmake_minimum_required(VERSION 3.0.0)

##

## PROJECT

## name and version

##

project(nlohmann_json VERSION 3.1.2 LANGUAGES CXX)

##

## INCLUDE

##

##

include(ExternalProject)

##

## OPTIONS

##

option(JSON_BuildTests "Build the unit tests when BUILD_TESTING is enabled." ON)

option(JSON_MultipleHeaders "Use non-amalgamated version of the library." OFF)

##

## CONFIGURATION

##

set(NLOHMANN_JSON_TARGET_NAME               ${PROJECT_NAME})

set(NLOHMANN_JSON_CONFIG_INSTALL_DIR        "lib/cmake/${PROJECT_NAME}")

set(NLOHMANN_JSON_INCLUDE_INSTALL_DIR       "include")

set(NLOHMANN_JSON_TARGETS_EXPORT_NAME       "${PROJECT_NAME}Targets")

set(NLOHMANN_JSON_CMAKE_CONFIG_TEMPLATE     "cmake/config.cmake.in")

set(NLOHMANN_JSON_CMAKE_CONFIG_DIR          "${CMAKE_CURRENT_BINARY_DIR}/cmake_config")

set(NLOHMANN_JSON_CMAKE_VERSION_CONFIG_FILE "${NLOHMANN_JSON_CMAKE_CONFIG_DIR}/${PROJECT_NAME}ConfigVersion.cmake")

set(NLOHMANN_JSON_CMAKE_PROJECT_CONFIG_FILE "${NLOHMANN_JSON_CMAKE_CONFIG_DIR}/${PROJECT_NAME}Config.cmake")

if (JSON_MultipleHeaders)

    set(NLOHMANN_JSON_INCLUDE_BUILD_DIR "${PROJECT_SOURCE_DIR}/include/")

    message(STATUS "Using the multi-header code from ${NLOHMANN_JSON_INCLUDE_BUILD_DIR}")

else()

    set(NLOHMANN_JSON_INCLUDE_BUILD_DIR "${PROJECT_SOURCE_DIR}/single_include/")

    message(STATUS "Using the single-header code from ${NLOHMANN_JSON_INCLUDE_BUILD_DIR}")

endif()

##

## TARGET

## create target and add include path

##

add_library(${NLOHMANN_JSON_TARGET_NAME} INTERFACE)

target_include_directories(

    ${NLOHMANN_JSON_TARGET_NAME}

    INTERFACE

    $<BUILD_INTERFACE:${NLOHMANN_JSON_INCLUDE_BUILD_DIR}>

    $<INSTALL_INTERFACE:include>

)

## add debug view defintion file for msvc (natvis) [cmake <= 3.2.2 does not support export of source files]

if (MSVC AND CMAKE_VERSION VERSION_GREATER "3.2.2")

    set(NLOHMANN_ADD_NATVIS TRUE)

    set(NLOHMANN_NATVIS_FILE "nlohmann_json.natvis")

    target_sources(

        ${NLOHMANN_JSON_TARGET_NAME} 

        INTERFACE 

            $<INSTALL_INTERFACE:${NLOHMANN_NATVIS_FILE}>

            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/${NLOHMANN_NATVIS_FILE}>  

    )

endif()

##

## TESTS

## create and configure the unit test target

##

include(CTest) #adds option BUILD_TESTING (default ON)

if(BUILD_TESTING AND JSON_BuildTests)

    enable_testing()

    add_subdirectory(test)

endif()

##

## INSTALL

## install header files, generate and install cmake config files for find_package()

##

include(CMakePackageConfigHelpers)

write_basic_package_version_file(

    ${NLOHMANN_JSON_CMAKE_VERSION_CONFIG_FILE} COMPATIBILITY SameMajorVersion

)

configure_package_config_file(

    ${NLOHMANN_JSON_CMAKE_CONFIG_TEMPLATE}

    ${NLOHMANN_JSON_CMAKE_PROJECT_CONFIG_FILE}

    INSTALL_DESTINATION ${NLOHMANN_JSON_CONFIG_INSTALL_DIR}

)

install(

    DIRECTORY ${NLOHMANN_JSON_INCLUDE_BUILD_DIR}

    DESTINATION ${NLOHMANN_JSON_INCLUDE_INSTALL_DIR}

)

install(

    FILES ${NLOHMANN_JSON_CMAKE_PROJECT_CONFIG_FILE} ${NLOHMANN_JSON_CMAKE_VERSION_CONFIG_FILE}

    DESTINATION ${NLOHMANN_JSON_CONFIG_INSTALL_DIR}

)

if (NLOHMANN_ADD_NATVIS)

    install(

        FILES ${NLOHMANN_NATVIS_FILE}

        DESTINATION .

)

endif()

install(

    TARGETS ${NLOHMANN_JSON_TARGET_NAME}

    EXPORT ${NLOHMANN_JSON_TARGETS_EXPORT_NAME}

    INCLUDES DESTINATION ${NLOHMANN_JSON_INCLUDE_INSTALL_DIR}

)

install(

    EXPORT ${NLOHMANN_JSON_TARGETS_EXPORT_NAME}

    DESTINATION ${NLOHMANN_JSON_CONFIG_INSTALL_DIR}

)

MIT License 

Copyright (c) 2013-2018 Niels Lohmann

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.

@PACKAGE_INIT@

include("${CMAKE_CURRENT_LIST_DIR}/@NLOHMANN_JSON_TARGETS_EXPORT_NAME@.cmake")

check_required_components("@PROJECT_NAME@")

#pragma once

#include <utility>

#include <nlohmann/detail/conversions/from_json.hpp>

#include <nlohmann/detail/conversions/to_json.hpp>

namespace nlohmann

{

template<typename, typename>

struct adl_serializer

{

    /*!

    @brief convert a JSON value to any value type

    This function is usually called by the `get()` function of the

    @ref basic_json class (either explicit or via conversion operators).

    @param[in] j         JSON value to read from

    @param[in,out] val  value to write to

    */

    template<typename BasicJsonType, typename ValueType>

    static void from_json(BasicJsonType&& j, ValueType& val) noexcept(

        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))

    {

        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);

    }

    /*!

    @brief convert any value type to a JSON value

    This function is usually called by the constructors of the @ref basic_json

    class.

    @param[in,out] j  JSON value to write to

    @param[in] val     value to read from

    */

    template<typename BasicJsonType, typename ValueType>

    static void to_json(BasicJsonType& j, ValueType&& val) noexcept(

        noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))

    {

        ::nlohmann::to_json(j, std::forward<ValueType>(val));

    }

};

}

#pragma once

#include <algorithm> // transform

#include <array> // array

#include <ciso646> // and, not

#include <forward_list> // forward_list

#include <iterator> // inserter, front_inserter, end

#include <string> // string

#include <tuple> // tuple, make_tuple

#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible

#include <utility> // pair, declval

#include <valarray> // valarray

#include <nlohmann/detail/exceptions.hpp>

#include <nlohmann/detail/macro_scope.hpp>

#include <nlohmann/detail/meta.hpp>

#include <nlohmann/detail/value_t.hpp>

namespace nlohmann

{

namespace detail

{

// overloads for basic_json template parameters

template<typename BasicJsonType, typename ArithmeticType,

         enable_if_t<std::is_arithmetic<ArithmeticType>::value and

                     not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,

                     int> = 0>

void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)

{

    switch (static_cast<value_t>(j))

    {

        case value_t::number_unsigned:

        {

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());

            break;

        }

        case value_t::number_integer:

        {

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());

            break;

        }

        case value_t::number_float:

        {

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());

            break;

        }

        default:

            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));

    }

}

template<typename BasicJsonType>

void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)

{

    if (JSON_UNLIKELY(not j.is_boolean()))

    {

        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));

    }

    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();

}

template<typename BasicJsonType>

void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)

{

    if (JSON_UNLIKELY(not j.is_string()))

    {

        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));

    }

    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();

}

template<typename BasicJsonType>

void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)

{

    get_arithmetic_value(j, val);

}

template<typename BasicJsonType>

void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)

{

    get_arithmetic_value(j, val);

}

template<typename BasicJsonType>

void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)

{

    get_arithmetic_value(j, val);

}

template<typename BasicJsonType, typename EnumType,

         enable_if_t<std::is_enum<EnumType>::value, int> = 0>

void from_json(const BasicJsonType& j, EnumType& e)

{

    typename std::underlying_type<EnumType>::type val;

    get_arithmetic_value(j, val);

    e = static_cast<EnumType>(val);

}

template<typename BasicJsonType>

void from_json(const BasicJsonType& j, typename BasicJsonType::array_t& arr)

{

    if (JSON_UNLIKELY(not j.is_array()))

    {

        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));

    }

    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();

}

// forward_list doesn't have an insert method

template<typename BasicJsonType, typename T, typename Allocator,

         enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>

void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)

{

    if (JSON_UNLIKELY(not j.is_array()))

    {

        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));

    }

    std::transform(j.rbegin(), j.rend(),

                   std::front_inserter(l), [](const BasicJsonType & i)

    {

        return i.template get<T>();

    });

}

// valarray doesn't have an insert method

template<typename BasicJsonType, typename T,

         enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>

void from_json(const BasicJsonType& j, std::valarray<T>& l)

{

    if (JSON_UNLIKELY(not j.is_array()))

    {

        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));

    }

    l.resize(j.size());

    std::copy(j.m_value.array->begin(), j.m_value.array->end(), std::begin(l));

}

template<typename BasicJsonType, typename CompatibleArrayType>

void from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<0> /*unused*/)

{

    using std::end;

    std::transform(j.begin(), j.end(),

                   std::inserter(arr, end(arr)), [](const BasicJsonType & i)

    {

        // get<BasicJsonType>() returns *this, this won't call a from_json

        // method when value_type is BasicJsonType

        return i.template get<typename CompatibleArrayType::value_type>();

    });

}

template<typename BasicJsonType, typename CompatibleArrayType>

auto from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<1> /*unused*/)

-> decltype(

    arr.reserve(std::declval<typename CompatibleArrayType::size_type>()),

    void())

{

    using std::end;

    arr.reserve(j.size());

    std::transform(j.begin(), j.end(),

                   std::inserter(arr, end(arr)), [](const BasicJsonType & i)

    {

        // get<BasicJsonType>() returns *this, this won't call a from_json

        // method when value_type is BasicJsonType

        return i.template get<typename CompatibleArrayType::value_type>();

    });

}

template<typename BasicJsonType, typename T, std::size_t N>

void from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr, priority_tag<2> /*unused*/)

{

    for (std::size_t i = 0; i < N; ++i)

    {

        arr[i] = j.at(i).template get<T>();

    }

}

template <

    typename BasicJsonType, typename CompatibleArrayType,

    enable_if_t <

        is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value and

        not std::is_same<typename BasicJsonType::array_t,

                         CompatibleArrayType>::value and

        std::is_constructible <

            BasicJsonType, typename CompatibleArrayType::value_type >::value,

        int > = 0 >

void from_json(const BasicJsonType& j, CompatibleArrayType& arr)

{

    if (JSON_UNLIKELY(not j.is_array()))

    {

        JSON_THROW(type_error::create(302, "type must be array, but is " +

                                      std::string(j.type_name())));

    }

    from_json_array_impl(j, arr, priority_tag<2> {});

}

template<typename BasicJsonType, typename CompatibleObjectType,

         enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value, int> = 0>

void from_json(const BasicJsonType& j, CompatibleObjectType& obj)

{

    if (JSON_UNLIKELY(not j.is_object()))

    {

        JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));

    }

    auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();

    using value_type = typename CompatibleObjectType::value_type;

    std::transform(

        inner_object->begin(), inner_object->end(),

        std::inserter(obj, obj.begin()),

        [](typename BasicJsonType::object_t::value_type const & p)

    {

        return value_type(p.first, p.second.template get<typename CompatibleObjectType::mapped_type>());

    });

}

// overload for arithmetic types, not chosen for basic_json template arguments

// (BooleanType, etc..); note: Is it really necessary to provide explicit

// overloads for boolean_t etc. in case of a custom BooleanType which is not

// an arithmetic type?

template<typename BasicJsonType, typename ArithmeticType,

         enable_if_t <

             std::is_arithmetic<ArithmeticType>::value and

             not std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value and

             not std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value and

             not std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value and

             not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,

             int> = 0>

void from_json(const BasicJsonType& j, ArithmeticType& val)

{

    switch (static_cast<value_t>(j))

    {

        case value_t::number_unsigned:

        {

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());

            break;

        }

        case value_t::number_integer:

        {

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());

            break;

        }

        case value_t::number_float:

        {

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());

            break;

        }

        case value_t::boolean:

        {

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());

            break;

        }

        default:

            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));

    }

}

template<typename BasicJsonType, typename A1, typename A2>

void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)

{

    p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};

}

template<typename BasicJsonType, typename Tuple, std::size_t... Idx>

void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...>)

{

    t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);

}

template<typename BasicJsonType, typename... Args>

void from_json(const BasicJsonType& j, std::tuple<Args...>& t)

{

    from_json_tuple_impl(j, t, index_sequence_for<Args...> {});

}

struct from_json_fn

{

  private:

    template<typename BasicJsonType, typename T>

    auto call(const BasicJsonType& j, T& val, priority_tag<1> /*unused*/) const

    noexcept(noexcept(from_json(j, val)))

    -> decltype(from_json(j, val), void())

    {

        return from_json(j, val);

    }

    template<typename BasicJsonType, typename T>

    void call(const BasicJsonType& /*unused*/, T& /*unused*/, priority_tag<0> /*unused*/) const noexcept

    {

        static_assert(sizeof(BasicJsonType) == 0,

                      "could not find from_json() method in T's namespace");

#ifdef _MSC_VER

        // MSVC does not show a stacktrace for the above assert

        using decayed = uncvref_t<T>;

        static_assert(sizeof(typename decayed::force_msvc_stacktrace) == 0,

                      "forcing MSVC stacktrace to show which T we're talking about.");

#endif

    }

  public:

    template<typename BasicJsonType, typename T>

    void operator()(const BasicJsonType& j, T& val) const

    noexcept(noexcept(std::declval<from_json_fn>().call(j, val, priority_tag<1> {})))

    {

        return call(j, val, priority_tag<1> {});

    }

};

}

/// namespace to hold default `from_json` function

/// to see why this is required:

/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html

namespace

{

constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;

}

}