aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--.gitignore2
-rw-r--r--CMakeLists.txt49
-rw-r--r--conf/areas.json (renamed from src/db/areas.db)0
-rw-r--r--conf/layers.json54
-rw-r--r--conf/old_roles.db (renamed from src/db/old_roles.db)0
-rw-r--r--include/json.hpp13003
-rw-r--r--policy_manager/db/roles.db2
-rw-r--r--policy_manager/db/roles.db.zipc2
-rw-r--r--policy_manager/db/roles.db.zipc.split2
-rw-r--r--policy_manager/policy_manager.cpp10
-rw-r--r--protocol/ivi-wm.xml608
-rw-r--r--src/CMakeLists.txt26
-rw-r--r--src/applist.cpp36
-rw-r--r--src/applist.hpp7
-rw-r--r--src/controller_hooks.hpp41
-rw-r--r--src/json_helper.cpp65
-rw-r--r--src/json_helper.hpp3
-rw-r--r--src/layers.cpp343
-rw-r--r--src/layers.hpp158
-rw-r--r--src/layout.cpp17
-rw-r--r--src/layout.hpp41
-rw-r--r--src/main.cpp249
-rw-r--r--src/pm_wrapper.cpp9
-rw-r--r--src/request.hpp6
-rw-r--r--src/util.cpp2
-rw-r--r--src/util.hpp29
-rw-r--r--src/wayland_ivi_wm.cpp721
-rw-r--r--src/wayland_ivi_wm.hpp326
-rw-r--r--src/window_manager.cpp922
-rw-r--r--src/window_manager.hpp115
-rw-r--r--src/wm_client.cpp280
-rw-r--r--src/wm_client.hpp47
-rw-r--r--src/wm_layer.cpp260
-rw-r--r--src/wm_layer.hpp97
-rw-r--r--src/wm_layer_control.cpp645
-rw-r--r--src/wm_layer_control.hpp105
36 files changed, 1722 insertions, 16560 deletions
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..5acb669
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+build
+.vscode
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e1cb0db..8a69a43 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -26,55 +26,6 @@ set(PACKAGE_VERSION "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}.${PACKAGE
find_package(PkgConfig REQUIRED)
include(GNUInstallDirs)
-pkg_check_modules(WLC wayland-client>=1.11.0 REQUIRED)
-
-macro(wlproto var_basename proto_xml_basename)
- if("${WLSCAN}" STREQUAL "")
- find_program(WLSCAN NAMES wayland-scanner)
- endif()
-
- if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/protocol)
- set(proto_dir "${CMAKE_CURRENT_SOURCE_DIR}/protocol")
- elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../protocol)
- set(proto_dir "${CMAKE_CURRENT_SOURCE_DIR}/../protocol")
- else()
- message(FATAL_ERROR "Could not find ${CMAKE_CURRENT_SOURCE_DIR}/protocol or ${CMAKE_CURRENT_SOURCE_DIR}/../protocol")
- endif()
-
- add_custom_command(
- OUTPUT
- ${proto_xml_basename}-protocol.c
- #${proto_xml_basename}-server-protocol.h
- ${proto_xml_basename}-client-protocol.h
- MAIN_DEPENDENCY ${proto_dir}/${proto_xml_basename}.xml
- COMMAND ${WLSCAN} code < ${proto_dir}/${proto_xml_basename}.xml > ${proto_xml_basename}-protocol.c
- #COMMAND ${WLSCAN} server-header < ${proto_dir}/${proto_xml_basename}.xml > ${proto_xml_basename}-server-protocol.h
- COMMAND ${WLSCAN} client-header < ${proto_dir}/${proto_xml_basename}.xml > ${proto_xml_basename}-client-protocol.h
- )
-
- set(${var_basename}_PROTO ${CMAKE_CURRENT_BINARY_DIR}/${proto_xml_basename}-protocol.c)
- set(${var_basename}_CLIENT ${CMAKE_CURRENT_BINARY_DIR}/${proto_xml_basename}-client-protocol.h)
- #set(${var_basename}_SERVER ${CMAKE_CURRENT_BINARY_DIR}/${proto_xml_basename}-server-protocol.h)
-
- include_directories(${CMAKE_CURRENT_BINARY_DIR})
-endmacro()
-
-# Should modernize the following somehow...
-set(ENABLE_DEBUG_OUTPUT OFF CACHE BOOL "Enable debug logging")
-if(ENABLE_DEBUG_OUTPUT)
- add_definitions(-DDEBUG_OUTPUT)
-else()
- remove_definitions(-DDEBUG_OUTPUT)
-endif()
-
-# Should modernize the following somehow...
-set(ENABLE_SCOPE_TRACING OFF CACHE BOOL "Enable scope enter/leave messages for certain parts of the code.")
-if(ENABLE_SCOPE_TRACING)
- add_definitions(-DSCOPE_TRACING)
-else()
- remove_definitions(-DSCOPE_TRACING)
-endif()
-
set(SANITIZER_MODE "none" CACHE STRING "Build using a specific sanitizer (e.g. 'address', 'thread', 'leak', 'undefined'), depends on compiler; default none")
set(LINK_LIBCXX OFF CACHE BOOL "Link against LLVMs libc++")
diff --git a/src/db/areas.db b/conf/areas.json
index 03ddfe4..03ddfe4 100644
--- a/src/db/areas.db
+++ b/conf/areas.json
diff --git a/conf/layers.json b/conf/layers.json
new file mode 100644
index 0000000..539846a
--- /dev/null
+++ b/conf/layers.json
@@ -0,0 +1,54 @@
+{
+ "description": "Layer mapping",
+ "mappings": [
+ {
+ "name": "BackGroundLayer",
+ "role" : "navigation|radio|music|video",
+ "id_range_begin": 0,
+ "id_range_end": 0,
+ "comment": "Work Around: This is a special fallback layer that not stopping wayland event loop."
+ },
+ {
+ "name": "FarHomeScreen",
+ "role": "homescreen",
+ "id_range_begin": 100,
+ "id_range_end": 199,
+ "comment": "FarHomeScreen is the part of HomeScreen. The z order of this layer is lower than NearHomeScreen"
+ },
+ {
+ "name": "Apps",
+ "role": "music|video|browser|radio|phone|navigation|map|hvac|settings|dashboard|poi|mixer|sdl|launcher|fallback",
+ "id_range_begin": 1000,
+ "id_range_end": 2999,
+ "comment": "Application layer"
+ },
+ {
+ "name": "NearHomeScreen",
+ "role": "software_keyboard",
+ "id_range_begin": 3000,
+ "id_range_end": 3999,
+ "comment": "NearHomeScreen is the part of HomeScreen. The usecase is used by software_keyboard etc"
+ },
+ {
+ "name": "Popup",
+ "role": "popup*",
+ "id_range_begin": 4000,
+ "id_range_end": 4999,
+ "comment": "This layer is for popup application layer"
+ },
+ {
+ "name": "Restriction",
+ "role": "restriction",
+ "id_range_begin": 5000,
+ "id_range_end": 5999,
+ "comment": "This layer is for restriction notification on driving. This is used by restriction role"
+ },
+ {
+ "name": "OnScreen",
+ "role": "^on_screen.*",
+ "id_range_begin": 6000,
+ "id_range_end": 6999,
+ "comment": "System notification layer. For example, on_screen_low_battery_alert to notify user"
+ }
+ ]
+}
diff --git a/src/db/old_roles.db b/conf/old_roles.db
index 02a4c2d..02a4c2d 100644
--- a/src/db/old_roles.db
+++ b/conf/old_roles.db
diff --git a/include/json.hpp b/include/json.hpp
deleted file mode 100644
index 6dfc183..0000000
--- a/include/json.hpp
+++ /dev/null
@@ -1,13003 +0,0 @@
-/*
- __ _____ _____ _____
- __| | __| | | | JSON for Modern C++
-| | |__ | | | | | | version 2.1.1
-|_____|_____|_____|_|___| https://github.com/nlohmann/json
-
-Licensed under the MIT License <http://opensource.org/licenses/MIT>.
-Copyright (c) 2013-2017 Niels Lohmann <http://nlohmann.me>.
-
-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.
-*/
-
-#ifndef NLOHMANN_JSON_HPP
-#define NLOHMANN_JSON_HPP
-
-#include <algorithm> // all_of, copy, fill, find, for_each, none_of, remove, reverse, transform
-#include <array> // array
-#include <cassert> // assert
-#include <cctype> // isdigit
-#include <ciso646> // and, not, or
-#include <cmath> // isfinite, labs, ldexp, signbit
-#include <cstddef> // nullptr_t, ptrdiff_t, size_t
-#include <cstdint> // int64_t, uint64_t
-#include <cstdlib> // abort, strtod, strtof, strtold, strtoul, strtoll, strtoull
-#include <cstring> // strlen
-#include <forward_list> // forward_list
-#include <functional> // function, hash, less
-#include <initializer_list> // initializer_list
-#include <iomanip> // setw
-#include <iostream> // istream, ostream
-#include <iterator> // advance, begin, back_inserter, bidirectional_iterator_tag, distance, end, inserter, iterator, iterator_traits, next, random_access_iterator_tag, reverse_iterator
-#include <limits> // numeric_limits
-#include <locale> // locale
-#include <map> // map
-#include <memory> // addressof, allocator, allocator_traits, unique_ptr
-#include <numeric> // accumulate
-#include <sstream> // stringstream
-#include <stdexcept> // domain_error, invalid_argument, out_of_range
-#include <string> // getline, stoi, string, to_string
-#include <type_traits> // add_pointer, conditional, decay, enable_if, false_type, integral_constant, is_arithmetic, is_base_of, is_const, is_constructible, is_convertible, is_default_constructible, is_enum, is_floating_point, is_integral, is_nothrow_move_assignable, is_nothrow_move_constructible, is_pointer, is_reference, is_same, is_scalar, is_signed, remove_const, remove_cv, remove_pointer, remove_reference, true_type, underlying_type
-#include <utility> // declval, forward, make_pair, move, pair, swap
-#include <vector> // vector
-
-// exclude unsupported compilers
-#if defined(__clang__)
- #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
- #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
- #endif
-#elif defined(__GNUC__)
- #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40900
- #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
- #endif
-#endif
-
-// disable float-equal warnings on GCC/clang
-#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-
-// disable documentation warnings on clang
-#if defined(__clang__)
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wdocumentation"
-#endif
-
-// allow for portable deprecation warnings
-#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
- #define JSON_DEPRECATED __attribute__((deprecated))
-#elif defined(_MSC_VER)
- #define JSON_DEPRECATED __declspec(deprecated)
-#else
- #define JSON_DEPRECATED
-#endif
-
-// allow to disable exceptions
-#if not defined(JSON_NOEXCEPTION) || defined(__EXCEPTIONS)
- #define JSON_THROW(exception) throw exception
- #define JSON_TRY try
- #define JSON_CATCH(exception) catch(exception)
-#else
- #define JSON_THROW(exception) std::abort()
- #define JSON_TRY if(true)
- #define JSON_CATCH(exception) if(false)
-#endif
-
-/*!
-@brief namespace for Niels Lohmann
-@see https://github.com/nlohmann
-@since version 1.0.0
-*/
-namespace nlohmann
-{
-
-/*!
-@brief unnamed namespace with internal helper functions
-
-This namespace collects some functions that could not be defined inside the
-@ref basic_json class.
-
-@since version 2.1.0
-*/
-namespace detail
-{
-///////////////////////////
-// JSON type enumeration //
-///////////////////////////
-
-/*!
-@brief the JSON type enumeration
-
-This enumeration collects the different JSON types. It is internally used to
-distinguish the stored values, and the functions @ref basic_json::is_null(),
-@ref basic_json::is_object(), @ref basic_json::is_array(),
-@ref basic_json::is_string(), @ref basic_json::is_boolean(),
-@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
-@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
-@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
-@ref basic_json::is_structured() rely on it.
-
-@note There are three enumeration entries (number_integer, number_unsigned, and
-number_float), because the library distinguishes these three types for numbers:
-@ref basic_json::number_unsigned_t is used for unsigned integers,
-@ref basic_json::number_integer_t is used for signed integers, and
-@ref basic_json::number_float_t is used for floating-point numbers or to
-approximate integers which do not fit in the limits of their respective type.
-
-@sa @ref basic_json::basic_json(const value_t value_type) -- create a JSON
-value with the default value for a given type
-
-@since version 1.0.0
-*/
-enum class value_t : uint8_t
-{
- null, ///< null value
- object, ///< object (unordered set of name/value pairs)
- array, ///< array (ordered collection of values)
- string, ///< string value
- boolean, ///< boolean value
- number_integer, ///< number value (signed integer)
- number_unsigned, ///< number value (unsigned integer)
- number_float, ///< number value (floating-point)
- discarded ///< discarded by the the parser callback function
-};
-
-/*!
-@brief comparison operator for JSON types
-
-Returns an ordering that is similar to Python:
-- order: null < boolean < number < object < array < string
-- furthermore, each type is not smaller than itself
-
-@since version 1.0.0
-*/
-inline bool operator<(const value_t lhs, const value_t rhs) noexcept
-{
- static constexpr std::array<uint8_t, 8> order = {{
- 0, // null
- 3, // object
- 4, // array
- 5, // string
- 1, // boolean
- 2, // integer
- 2, // unsigned
- 2, // float
- }
- };
-
- // discarded values are not comparable
- if (lhs == value_t::discarded or rhs == value_t::discarded)
- {
- return false;
- }
-
- return order[static_cast<std::size_t>(lhs)] <
- order[static_cast<std::size_t>(rhs)];
-}
-
-
-/////////////
-// helpers //
-/////////////
-
-// alias templates to reduce boilerplate
-template<bool B, typename T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-
-template<typename T>
-using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-
-// taken from http://stackoverflow.com/a/26936864/266378
-template<typename T>
-using is_unscoped_enum =
- std::integral_constant<bool, std::is_convertible<T, int>::value and
- std::is_enum<T>::value>;
-
-/*
-Implementation of two C++17 constructs: conjunction, negation. This is needed
-to avoid evaluating all the traits in a condition
-
-For example: not std::is_same<void, T>::value and has_value_type<T>::value
-will not compile when T = void (on MSVC at least). Whereas
-conjunction<negation<std::is_same<void, T>>, has_value_type<T>>::value will
-stop evaluating if negation<...>::value == false
-
-Please note that those constructs must be used with caution, since symbols can
-become very long quickly (which can slow down compilation and cause MSVC
-internal compiler errors). Only use it when you have to (see example ahead).
-*/
-template<class...> struct conjunction : std::true_type {};
-template<class B1> struct conjunction<B1> : B1 {};
-template<class B1, class... Bn>
-struct conjunction<B1, Bn...> : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
-
-template<class B> struct negation : std::integral_constant < bool, !B::value > {};
-
-// dispatch utility (taken from ranges-v3)
-template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
-template<> struct priority_tag<0> {};
-
-
-//////////////////
-// constructors //
-//////////////////
-
-template<value_t> struct external_constructor;
-
-template<>
-struct external_constructor<value_t::boolean>
-{
- template<typename BasicJsonType>
- static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
- {
- j.m_type = value_t::boolean;
- j.m_value = b;
- j.assert_invariant();
- }
-};
-
-template<>
-struct external_constructor<value_t::string>
-{
- template<typename BasicJsonType>
- static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
- {
- j.m_type = value_t::string;
- j.m_value = s;
- j.assert_invariant();
- }
-};
-
-template<>
-struct external_constructor<value_t::number_float>
-{
- template<typename BasicJsonType>
- static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
- {
- // replace infinity and NAN by null
- if (not std::isfinite(val))
- {
- j = BasicJsonType{};
- }
- else
- {
- j.m_type = value_t::number_float;
- j.m_value = val;
- }
- j.assert_invariant();
- }
-};
-
-template<>
-struct external_constructor<value_t::number_unsigned>
-{
- template<typename BasicJsonType>
- static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
- {
- j.m_type = value_t::number_unsigned;
- j.m_value = val;
- j.assert_invariant();
- }
-};
-
-template<>
-struct external_constructor<value_t::number_integer>
-{
- template<typename BasicJsonType>
- static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
- {
- j.m_type = value_t::number_integer;
- j.m_value = val;
- j.assert_invariant();
- }
-};
-
-template<>
-struct external_constructor<value_t::array>
-{
- template<typename BasicJsonType>
- static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
- {
- j.m_type = value_t::array;
- j.m_value = arr;
- j.assert_invariant();
- }
-
- template<typename BasicJsonType, typename CompatibleArrayType,
- enable_if_t<not std::is_same<CompatibleArrayType,
- typename BasicJsonType::array_t>::value,
- int> = 0>
- static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
- {
- using std::begin;
- using std::end;
- j.m_type = value_t::array;
- j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
- j.assert_invariant();
- }
-};
-
-template<>
-struct external_constructor<value_t::object>
-{
- template<typename BasicJsonType>
- static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
- {
- j.m_type = value_t::object;
- j.m_value = obj;
- j.assert_invariant();
- }
-
- template<typename BasicJsonType, typename CompatibleObjectType,
- enable_if_t<not std::is_same<CompatibleObjectType,
- typename BasicJsonType::object_t>::value,
- int> = 0>
- static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
- {
- using std::begin;
- using std::end;
-
- j.m_type = value_t::object;
- j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
- j.assert_invariant();
- }
-};
-
-
-////////////////////////
-// has_/is_ functions //
-////////////////////////
-
-/*!
-@brief Helper to determine whether there's a key_type for T.
-
-This helper is used to tell associative containers apart from other containers
-such as sequence containers. For instance, `std::map` passes the test as it
-contains a `mapped_type`, whereas `std::vector` fails the test.
-
-@sa http://stackoverflow.com/a/7728728/266378
-@since version 1.0.0, overworked in version 2.0.6
-*/
-#define NLOHMANN_JSON_HAS_HELPER(type) \
- template<typename T> struct has_##type { \
- private: \
- template<typename U, typename = typename U::type> \
- static int detect(U &&); \
- static void detect(...); \
- public: \
- static constexpr bool value = \
- std::is_integral<decltype(detect(std::declval<T>()))>::value; \
- }
-
-NLOHMANN_JSON_HAS_HELPER(mapped_type);
-NLOHMANN_JSON_HAS_HELPER(key_type);
-NLOHMANN_JSON_HAS_HELPER(value_type);
-NLOHMANN_JSON_HAS_HELPER(iterator);
-
-#undef NLOHMANN_JSON_HAS_HELPER
-
-
-template<bool B, class RealType, class CompatibleObjectType>
-struct is_compatible_object_type_impl : std::false_type {};
-
-template<class RealType, class CompatibleObjectType>
-struct is_compatible_object_type_impl<true, RealType, CompatibleObjectType>
-{
- static constexpr auto value =
- std::is_constructible<typename RealType::key_type,
- typename CompatibleObjectType::key_type>::value and
- std::is_constructible<typename RealType::mapped_type,
- typename CompatibleObjectType::mapped_type>::value;
-};
-
-template<class BasicJsonType, class CompatibleObjectType>
-struct is_compatible_object_type
-{
- static auto constexpr value = is_compatible_object_type_impl <
- conjunction<negation<std::is_same<void, CompatibleObjectType>>,
- has_mapped_type<CompatibleObjectType>,
- has_key_type<CompatibleObjectType>>::value,
- typename BasicJsonType::object_t, CompatibleObjectType >::value;
-};
-
-template<typename BasicJsonType, typename T>
-struct is_basic_json_nested_type
-{
- static auto constexpr value = std::is_same<T, typename BasicJsonType::iterator>::value or
- std::is_same<T, typename BasicJsonType::const_iterator>::value or
- std::is_same<T, typename BasicJsonType::reverse_iterator>::value or
- std::is_same<T, typename BasicJsonType::const_reverse_iterator>::value or
- std::is_same<T, typename BasicJsonType::json_pointer>::value;
-};
-
-template<class BasicJsonType, class CompatibleArrayType>
-struct is_compatible_array_type
-{
- static auto constexpr value =
- conjunction<negation<std::is_same<void, CompatibleArrayType>>,
- negation<is_compatible_object_type<
- BasicJsonType, CompatibleArrayType>>,
- negation<std::is_constructible<typename BasicJsonType::string_t,
- CompatibleArrayType>>,
- negation<is_basic_json_nested_type<BasicJsonType, CompatibleArrayType>>,
- has_value_type<CompatibleArrayType>,
- has_iterator<CompatibleArrayType>>::value;
-};
-
-template<bool, typename, typename>
-struct is_compatible_integer_type_impl : std::false_type {};
-
-template<typename RealIntegerType, typename CompatibleNumberIntegerType>
-struct is_compatible_integer_type_impl<true, RealIntegerType, CompatibleNumberIntegerType>
-{
- // is there an assert somewhere on overflows?
- using RealLimits = std::numeric_limits<RealIntegerType>;
- using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
-
- static constexpr auto value =
- std::is_constructible<RealIntegerType,
- CompatibleNumberIntegerType>::value and
- CompatibleLimits::is_integer and
- RealLimits::is_signed == CompatibleLimits::is_signed;
-};
-
-template<typename RealIntegerType, typename CompatibleNumberIntegerType>
-struct is_compatible_integer_type
-{
- static constexpr auto value =
- is_compatible_integer_type_impl <
- std::is_integral<CompatibleNumberIntegerType>::value and
- not std::is_same<bool, CompatibleNumberIntegerType>::value,
- RealIntegerType, CompatibleNumberIntegerType > ::value;
-};
-
-
-// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
-template<typename BasicJsonType, typename T>
-struct has_from_json
-{
- private:
- // also check the return type of from_json
- template<typename U, typename = enable_if_t<std::is_same<void, decltype(uncvref_t<U>::from_json(
- std::declval<BasicJsonType>(), std::declval<T&>()))>::value>>
- static int detect(U&&);
- static void detect(...);
-
- public:
- static constexpr bool value = std::is_integral<decltype(
- detect(std::declval<typename BasicJsonType::template json_serializer<T, void>>()))>::value;
-};
-
-// This trait checks if JSONSerializer<T>::from_json(json const&) exists
-// this overload is used for non-default-constructible user-defined-types
-template<typename BasicJsonType, typename T>
-struct has_non_default_from_json
-{
- private:
- template <
- typename U,
- typename = enable_if_t<std::is_same<
- T, decltype(uncvref_t<U>::from_json(std::declval<BasicJsonType>()))>::value >>
- static int detect(U&&);
- static void detect(...);
-
- public:
- static constexpr bool value = std::is_integral<decltype(detect(
- std::declval<typename BasicJsonType::template json_serializer<T, void>>()))>::value;
-};
-
-// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
-template<typename BasicJsonType, typename T>
-struct has_to_json
-{
- private:
- template<typename U, typename = decltype(uncvref_t<U>::to_json(
- std::declval<BasicJsonType&>(), std::declval<T>()))>
- static int detect(U&&);
- static void detect(...);
-
- public:
- static constexpr bool value = std::is_integral<decltype(detect(
- std::declval<typename BasicJsonType::template json_serializer<T, void>>()))>::value;
-};
-
-
-/////////////
-// to_json //
-/////////////
-
-template<typename BasicJsonType, typename T, enable_if_t<
- std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
-void to_json(BasicJsonType& j, T b) noexcept
-{
- external_constructor<value_t::boolean>::construct(j, b);
-}
-
-template<typename BasicJsonType, typename CompatibleString,
- enable_if_t<std::is_constructible<typename BasicJsonType::string_t,
- CompatibleString>::value, int> = 0>
-void to_json(BasicJsonType& j, const CompatibleString& s)
-{
- external_constructor<value_t::string>::construct(j, s);
-}
-
-template<typename BasicJsonType, typename FloatType,
- enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
-void to_json(BasicJsonType& j, FloatType val) noexcept
-{
- external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
-}
-
-template <
- typename BasicJsonType, typename CompatibleNumberUnsignedType,
- enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t,
- CompatibleNumberUnsignedType>::value, int> = 0 >
-void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
-{
- external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
-}
-
-template <
- typename BasicJsonType, typename CompatibleNumberIntegerType,
- enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t,
- CompatibleNumberIntegerType>::value, int> = 0 >
-void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
-{
- external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
-}
-
-template<typename BasicJsonType, typename UnscopedEnumType,
- enable_if_t<is_unscoped_enum<UnscopedEnumType>::value, int> = 0>
-void to_json(BasicJsonType& j, UnscopedEnumType e) noexcept
-{
- external_constructor<value_t::number_integer>::construct(j, e);
-}
-
-template <
- typename BasicJsonType, typename CompatibleArrayType,
- enable_if_t <
- is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value or
- std::is_same<typename BasicJsonType::array_t, CompatibleArrayType>::value,
- int > = 0 >
-void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
-{
- external_constructor<value_t::array>::construct(j, arr);
-}
-
-template <
- typename BasicJsonType, typename CompatibleObjectType,
- enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value,
- int> = 0 >
-void to_json(BasicJsonType& j, const CompatibleObjectType& arr)
-{
- external_constructor<value_t::object>::construct(j, arr);
-}
-
-
-///////////////
-// from_json //
-///////////////
-
-// 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(
- std::domain_error("type must be number, but is " + j.type_name()));
- }
- }
-}
-
-template<typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
-{
- if (not j.is_boolean())
- {
- JSON_THROW(std::domain_error("type must be boolean, but is " + 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 (not j.is_string())
- {
- JSON_THROW(std::domain_error("type must be string, but is " + 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 UnscopedEnumType,
- enable_if_t<is_unscoped_enum<UnscopedEnumType>::value, int> = 0>
-void from_json(const BasicJsonType& j, UnscopedEnumType& e)
-{
- typename std::underlying_type<UnscopedEnumType>::type val;
- get_arithmetic_value(j, val);
- e = static_cast<UnscopedEnumType>(val);
-}
-
-template<typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::array_t& arr)
-{
- if (not j.is_array())
- {
- JSON_THROW(std::domain_error("type must be array, but is " + 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>
-void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
-{
- // do not perform the check when user wants to retrieve jsons
- // (except when it's null.. ?)
- if (j.is_null())
- {
- JSON_THROW(std::domain_error("type must be array, but is " + j.type_name()));
- }
- if (not std::is_same<T, BasicJsonType>::value)
- {
- if (not j.is_array())
- {
- JSON_THROW(std::domain_error("type must be array, but is " + j.type_name()));
- }
- }
- for (auto it = j.rbegin(), end = j.rend(); it != end; ++it)
- {
- l.push_front(it->template get<T>());
- }
-}
-
-template<typename BasicJsonType, typename CompatibleArrayType>
-void from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<0>)
-{
- using std::begin;
- 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>)
--> decltype(
- arr.reserve(std::declval<typename CompatibleArrayType::size_type>()),
- void())
-{
- using std::begin;
- 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 CompatibleArrayType,
- enable_if_t<is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value and
- not std::is_same<typename BasicJsonType::array_t, CompatibleArrayType>::value, int> = 0>
-void from_json(const BasicJsonType& j, CompatibleArrayType& arr)
-{
- if (j.is_null())
- {
- JSON_THROW(std::domain_error("type must be array, but is " + j.type_name()));
- }
-
- // when T == BasicJsonType, do not check if value_t is correct
- if (not std::is_same<typename CompatibleArrayType::value_type, BasicJsonType>::value)
- {
- if (not j.is_array())
- {
- JSON_THROW(std::domain_error("type must be array, but is " + j.type_name()));
- }
- }
- from_json_array_impl(j, arr, priority_tag<1> {});
-}
-
-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 (not j.is_object())
- {
- JSON_THROW(std::domain_error("type must be object, but is " + j.type_name()));
- }
-
- auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
- using std::begin;
- using std::end;
- // we could avoid the assignment, but this might require a for loop, which
- // might be less efficient than the container constructor for some
- // containers (would it?)
- obj = CompatibleObjectType(begin(*inner_object), end(*inner_object));
-}
-
-// 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(std::domain_error("type must be number, but is " + j.type_name()));
- }
- }
-}
-
-struct to_json_fn
-{
- private:
- template<typename BasicJsonType, typename T>
- auto call(BasicJsonType& j, T&& val, priority_tag<1>) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
- -> decltype(to_json(j, std::forward<T>(val)), void())
- {
- return to_json(j, std::forward<T>(val));
- }
-
- template<typename BasicJsonType, typename T>
- void call(BasicJsonType&, T&&, priority_tag<0>) const noexcept
- {
- static_assert(sizeof(BasicJsonType) == 0,
- "could not find to_json() method in T's namespace");
- }
-
- public:
- template<typename BasicJsonType, typename T>
- void operator()(BasicJsonType& j, T&& val) const
- noexcept(noexcept(std::declval<to_json_fn>().call(j, std::forward<T>(val), priority_tag<1> {})))
- {
- return call(j, std::forward<T>(val), priority_tag<1> {});
- }
-};
-
-struct from_json_fn
-{
- private:
- template<typename BasicJsonType, typename T>
- auto call(const BasicJsonType& j, T& val, priority_tag<1>) 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&, T&, priority_tag<0>) const noexcept
- {
- static_assert(sizeof(BasicJsonType) == 0,
- "could not find from_json() method in T's namespace");
- }
-
- 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> {});
- }
-};
-
-// taken from ranges-v3
-template<typename T>
-struct static_const
-{
- static constexpr T value{};
-};
-
-template<typename T>
-constexpr T static_const<T>::value;
-} // namespace detail
-
-
-/// namespace to hold default `to_json` / `from_json` functions
-namespace
-{
-constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;
-constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;
-}
-
-
-/*!
-@brief default JSONSerializer template argument
-
-This serializer ignores the template arguments and uses ADL
-([argument-dependent lookup](http://en.cppreference.com/w/cpp/language/adl))
-for serialization.
-*/
-template<typename = void, typename = void>
-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));
- }
-};
-
-
-/*!
-@brief a class to store JSON values
-
-@tparam ObjectType type for JSON objects (`std::map` by default; will be used
-in @ref object_t)
-@tparam ArrayType type for JSON arrays (`std::vector` by default; will be used
-in @ref array_t)
-@tparam StringType type for JSON strings and object keys (`std::string` by
-default; will be used in @ref string_t)
-@tparam BooleanType type for JSON booleans (`bool` by default; will be used
-in @ref boolean_t)
-@tparam NumberIntegerType type for JSON integer numbers (`int64_t` by
-default; will be used in @ref number_integer_t)
-@tparam NumberUnsignedType type for JSON unsigned integer numbers (@c
-`uint64_t` by default; will be used in @ref number_unsigned_t)
-@tparam NumberFloatType type for JSON floating-point numbers (`double` by
-default; will be used in @ref number_float_t)
-@tparam AllocatorType type of the allocator to use (`std::allocator` by
-default)
-@tparam JSONSerializer the serializer to resolve internal calls to `to_json()`
-and `from_json()` (@ref adl_serializer by default)
-
-@requirement The class satisfies the following concept requirements:
-- Basic
- - [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible):
- JSON values can be default constructed. The result will be a JSON null
- value.
- - [MoveConstructible](http://en.cppreference.com/w/cpp/concept/MoveConstructible):
- A JSON value can be constructed from an rvalue argument.
- - [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible):
- A JSON value can be copy-constructed from an lvalue expression.
- - [MoveAssignable](http://en.cppreference.com/w/cpp/concept/MoveAssignable):
- A JSON value van be assigned from an rvalue argument.
- - [CopyAssignable](http://en.cppreference.com/w/cpp/concept/CopyAssignable):
- A JSON value can be copy-assigned from an lvalue expression.
- - [Destructible](http://en.cppreference.com/w/cpp/concept/Destructible):
- JSON values can be destructed.
-- Layout
- - [StandardLayoutType](http://en.cppreference.com/w/cpp/concept/StandardLayoutType):
- JSON values have
- [standard layout](http://en.cppreference.com/w/cpp/language/data_members#Standard_layout):
- All non-static data members are private and standard layout types, the
- class has no virtual functions or (virtual) base classes.
-- Library-wide
- - [EqualityComparable](http://en.cppreference.com/w/cpp/concept/EqualityComparable):
- JSON values can be compared with `==`, see @ref
- operator==(const_reference,const_reference).
- - [LessThanComparable](http://en.cppreference.com/w/cpp/concept/LessThanComparable):
- JSON values can be compared with `<`, see @ref
- operator<(const_reference,const_reference).
- - [Swappable](http://en.cppreference.com/w/cpp/concept/Swappable):
- Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of
- other compatible types, using unqualified function call @ref swap().
- - [NullablePointer](http://en.cppreference.com/w/cpp/concept/NullablePointer):
- JSON values can be compared against `std::nullptr_t` objects which are used
- to model the `null` value.
-- Container
- - [Container](http://en.cppreference.com/w/cpp/concept/Container):
- JSON values can be used like STL containers and provide iterator access.
- - [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer);
- JSON values can be used like STL containers and provide reverse iterator
- access.
-
-@invariant The member variables @a m_value and @a m_type have the following
-relationship:
-- If `m_type == value_t::object`, then `m_value.object != nullptr`.
-- If `m_type == value_t::array`, then `m_value.array != nullptr`.
-- If `m_type == value_t::string`, then `m_value.string != nullptr`.
-The invariants are checked by member function assert_invariant().
-
-@internal
-@note ObjectType trick from http://stackoverflow.com/a/9860911
-@endinternal
-
-@see [RFC 7159: The JavaScript Object Notation (JSON) Data Interchange
-Format](http://rfc7159.net/rfc7159)
-
-@since version 1.0.0
-
-@nosubgrouping
-*/
-template <
- template<typename U, typename V, typename... Args> class ObjectType = std::map,
- template<typename U, typename... Args> class ArrayType = std::vector,
- class StringType = std::string,
- class BooleanType = bool,
- class NumberIntegerType = std::int64_t,
- class NumberUnsignedType = std::uint64_t,
- class NumberFloatType = double,
- template<typename U> class AllocatorType = std::allocator,
- template<typename T, typename SFINAE = void> class JSONSerializer = adl_serializer
- >
-class basic_json
-{
- private:
- template<detail::value_t> friend struct detail::external_constructor;
- /// workaround type for MSVC
- using basic_json_t = basic_json<ObjectType, ArrayType, StringType,
- BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType,
- AllocatorType, JSONSerializer>;
-
- public:
- using value_t = detail::value_t;
- // forward declarations
- template<typename U> class iter_impl;
- template<typename Base> class json_reverse_iterator;
- class json_pointer;
- template<typename T, typename SFINAE>
- using json_serializer = JSONSerializer<T, SFINAE>;
-
- /////////////////////
- // container types //
- /////////////////////
-
- /// @name container types
- /// The canonic container types to use @ref basic_json like any other STL
- /// container.
- /// @{
-
- /// the type of elements in a basic_json container
- using value_type = basic_json;
-
- /// the type of an element reference
- using reference = value_type&;
- /// the type of an element const reference
- using const_reference = const value_type&;
-
- /// a type to represent differences between iterators
- using difference_type = std::ptrdiff_t;
- /// a type to represent container sizes
- using size_type = std::size_t;
-
- /// the allocator type
- using allocator_type = AllocatorType<basic_json>;
-
- /// the type of an element pointer
- using pointer = typename std::allocator_traits<allocator_type>::pointer;
- /// the type of an element const pointer
- using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
-
- /// an iterator for a basic_json container
- using iterator = iter_impl<basic_json>;
- /// a const iterator for a basic_json container
- using const_iterator = iter_impl<const basic_json>;
- /// a reverse iterator for a basic_json container
- using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
- /// a const reverse iterator for a basic_json container
- using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
-
- /// @}
-
-
- /*!
- @brief returns the allocator associated with the container
- */
- static allocator_type get_allocator()
- {
- return allocator_type();
- }
-
- /*!
- @brief returns version information on the library
-
- This function returns a JSON object with information about the library,
- including the version number and information on the platform and compiler.
-
- @return JSON object holding version information
- key | description
- ----------- | ---------------
- `compiler` | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version).
- `copyright` | The copyright line for the library as string.
- `name` | The name of the library as string.
- `platform` | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.
- `url` | The URL of the project as string.
- `version` | The version of the library. It is an object with the following keys: `major`, `minor`, and `patch` as defined by [Semantic Versioning](http://semver.org), and `string` (the version string).
-
- @liveexample{The following code shows an example output of the `meta()`
- function.,meta}
-
- @complexity Constant.
-
- @since 2.1.0
- */
- static basic_json meta()
- {
- basic_json result;
-
- result["copyright"] = "(C) 2013-2017 Niels Lohmann";
- result["name"] = "JSON for Modern C++";
- result["url"] = "https://github.com/nlohmann/json";
- result["version"] =
- {
- {"string", "2.1.1"},
- {"major", 2},
- {"minor", 1},
- {"patch", 1}
- };
-
-#ifdef _WIN32
- result["platform"] = "win32";
-#elif defined __linux__
- result["platform"] = "linux";
-#elif defined __APPLE__
- result["platform"] = "apple";
-#elif defined __unix__
- result["platform"] = "unix";
-#else
- result["platform"] = "unknown";
-#endif
-
-#if defined(__clang__)
- result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
-#elif defined(__ICC) || defined(__INTEL_COMPILER)
- result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
-#elif defined(__GNUC__) || defined(__GNUG__)
- result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
-#elif defined(__HP_cc) || defined(__HP_aCC)
- result["compiler"] = "hp"
-#elif defined(__IBMCPP__)
- result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
-#elif defined(_MSC_VER)
- result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
-#elif defined(__PGI)
- result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
-#elif defined(__SUNPRO_CC)
- result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
-#else
- result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
-#endif
-
-#ifdef __cplusplus
- result["compiler"]["c++"] = std::to_string(__cplusplus);
-#else
- result["compiler"]["c++"] = "unknown";
-#endif
- return result;
- }
-
-
- ///////////////////////////
- // JSON value data types //
- ///////////////////////////
-
- /// @name JSON value data types
- /// The data types to store a JSON value. These types are derived from
- /// the template arguments passed to class @ref basic_json.
- /// @{
-
- /*!
- @brief a type for an object
-
- [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:
- > An object is an unordered collection of zero or more name/value pairs,
- > where a name is a string and a value is a string, number, boolean, null,
- > object, or array.
-
- To store objects in C++, a type is defined by the template parameters
- described below.
-
- @tparam ObjectType the container to store objects (e.g., `std::map` or
- `std::unordered_map`)
- @tparam StringType the type of the keys or names (e.g., `std::string`).
- The comparison function `std::less<StringType>` is used to order elements
- inside the container.
- @tparam AllocatorType the allocator to use for objects (e.g.,
- `std::allocator`)
-
- #### Default type
-
- With the default values for @a ObjectType (`std::map`), @a StringType
- (`std::string`), and @a AllocatorType (`std::allocator`), the default
- value for @a object_t is:
-
- @code {.cpp}
- std::map<
- std::string, // key_type
- basic_json, // value_type
- std::less<std::string>, // key_compare
- std::allocator<std::pair<const std::string, basic_json>> // allocator_type
- >
- @endcode
-
- #### Behavior
-
- The choice of @a object_t influences the behavior of the JSON class. With
- the default type, objects have the following behavior:
-
- - When all names are unique, objects will be interoperable in the sense
- that all software implementations receiving that object will agree on
- the name-value mappings.
- - When the names within an object are not unique, later stored name/value
- pairs overwrite previously stored name/value pairs, leaving the used
- names unique. For instance, `{"key": 1}` and `{"key": 2, "key": 1}` will
- be treated as equal and both stored as `{"key": 1}`.
- - Internally, name/value pairs are stored in lexicographical order of the
- names. Objects will also be serialized (see @ref dump) in this order.
- For instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored
- and serialized as `{"a": 2, "b": 1}`.
- - When comparing objects, the order of the name/value pairs is irrelevant.
- This makes objects interoperable in the sense that they will not be
- affected by these differences. For instance, `{"b": 1, "a": 2}` and
- `{"a": 2, "b": 1}` will be treated as equal.
-
- #### Limits
-
- [RFC 7159](http://rfc7159.net/rfc7159) specifies:
- > An implementation may set limits on the maximum depth of nesting.
-
- In this class, the object's limit of nesting is not constraint explicitly.
- However, a maximum depth of nesting may be introduced by the compiler or
- runtime environment. A theoretical limit can be queried by calling the
- @ref max_size function of a JSON object.
-
- #### Storage
-
- Objects are stored as pointers in a @ref basic_json type. That is, for any
- access to object values, a pointer of type `object_t*` must be
- dereferenced.
-
- @sa @ref array_t -- type for an array value
-
- @since version 1.0.0
-
- @note The order name/value pairs are added to the object is *not*
- preserved by the library. Therefore, iterating an object may return
- name/value pairs in a different order than they were originally stored. In
- fact, keys will be traversed in alphabetical order as `std::map` with
- `std::less` is used by default. Please note this behavior conforms to [RFC
- 7159](http://rfc7159.net/rfc7159), because any order implements the
- specified "unordered" nature of JSON objects.
- */
- using object_t = ObjectType<StringType,
- basic_json,
- std::less<StringType>,
- AllocatorType<std::pair<const StringType,
- basic_json>>>;
-
- /*!
- @brief a type for an array
-
- [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:
- > An array is an ordered sequence of zero or more values.
-
- To store objects in C++, a type is defined by the template parameters
- explained below.
-
- @tparam ArrayType container type to store arrays (e.g., `std::vector` or
- `std::list`)
- @tparam AllocatorType allocator to use for arrays (e.g., `std::allocator`)
-
- #### Default type
-
- With the default values for @a ArrayType (`std::vector`) and @a
- AllocatorType (`std::allocator`), the default value for @a array_t is:
-
- @code {.cpp}
- std::vector<
- basic_json, // value_type
- std::allocator<basic_json> // allocator_type
- >
- @endcode
-
- #### Limits
-
- [RFC 7159](http://rfc7159.net/rfc7159) specifies:
- > An implementation may set limits on the maximum depth of nesting.
-
- In this class, the array's limit of nesting is not constraint explicitly.
- However, a maximum depth of nesting may be introduced by the compiler or
- runtime environment. A theoretical limit can be queried by calling the
- @ref max_size function of a JSON array.
-
- #### Storage
-
- Arrays are stored as pointers in a @ref basic_json type. That is, for any
- access to array values, a pointer of type `array_t*` must be dereferenced.
-
- @sa @ref object_t -- type for an object value
-
- @since version 1.0.0
- */
- using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
-
- /*!
- @brief a type for a string
-
- [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:
- > A string is a sequence of zero or more Unicode characters.
-
- To store objects in C++, a type is defined by the template parameter
- described below. Unicode values are split by the JSON class into
- byte-sized characters during deserialization.
-
- @tparam StringType the container to store strings (e.g., `std::string`).
- Note this container is used for keys/names in objects, see @ref object_t.
-
- #### Default type
-
- With the default values for @a StringType (`std::string`), the default
- value for @a string_t is:
-
- @code {.cpp}
- std::string
- @endcode
-
- #### Encoding
-
- Strings are stored in UTF-8 encoding. Therefore, functions like
- `std::string::size()` or `std::string::length()` return the number of
- bytes in the string rather than the number of characters or glyphs.
-
- #### String comparison
-
- [RFC 7159](http://rfc7159.net/rfc7159) states:
- > Software implementations are typically required to test names of object
- > members for equality. Implementations that transform the textual
- > representation into sequences of Unicode code units and then perform the
- > comparison numerically, code unit by code unit, are interoperable in the
- > sense that implementations will agree in all cases on equality or
- > inequality of two strings. For example, implementations that compare
- > strings with escaped characters unconverted may incorrectly find that
- > `"a\\b"` and `"a\u005Cb"` are not equal.
-
- This implementation is interoperable as it does compare strings code unit
- by code unit.
-
- #### Storage
-
- String values are stored as pointers in a @ref basic_json type. That is,
- for any access to string values, a pointer of type `string_t*` must be
- dereferenced.
-
- @since version 1.0.0
- */
- using string_t = StringType;
-
- /*!
- @brief a type for a boolean
-
- [RFC 7159](http://rfc7159.net/rfc7159) implicitly describes a boolean as a
- type which differentiates the two literals `true` and `false`.
-
- To store objects in C++, a type is defined by the template parameter @a
- BooleanType which chooses the type to use.
-
- #### Default type
-
- With the default values for @a BooleanType (`bool`), the default value for
- @a boolean_t is:
-
- @code {.cpp}
- bool
- @endcode
-
- #### Storage
-
- Boolean values are stored directly inside a @ref basic_json type.
-
- @since version 1.0.0
- */
- using boolean_t = BooleanType;
-
- /*!
- @brief a type for a number (integer)
-
- [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
- > The representation of numbers is similar to that used in most
- > programming languages. A number is represented in base 10 using decimal
- > digits. It contains an integer component that may be prefixed with an
- > optional minus sign, which may be followed by a fraction part and/or an
- > exponent part. Leading zeros are not allowed. (...) Numeric values that
- > cannot be represented in the grammar below (such as Infinity and NaN)
- > are not permitted.
-
- This description includes both integer and floating-point numbers.
- However, C++ allows more precise storage if it is known whether the number
- is a signed integer, an unsigned integer or a floating-point number.
- Therefore, three different types, @ref number_integer_t, @ref
- number_unsigned_t and @ref number_float_t are used.
-
- To store integer numbers in C++, a type is defined by the template
- parameter @a NumberIntegerType which chooses the type to use.
-
- #### Default type
-
- With the default values for @a NumberIntegerType (`int64_t`), the default
- value for @a number_integer_t is:
-
- @code {.cpp}
- int64_t
- @endcode
-
- #### Default behavior
-
- - The restrictions about leading zeros is not enforced in C++. Instead,
- leading zeros in integer literals lead to an interpretation as octal
- number. Internally, the value will be stored as decimal number. For
- instance, the C++ integer literal `010` will be serialized to `8`.
- During deserialization, leading zeros yield an error.
- - Not-a-number (NaN) values will be serialized to `null`.
-
- #### Limits
-
- [RFC 7159](http://rfc7159.net/rfc7159) specifies:
- > An implementation may set limits on the range and precision of numbers.
-
- When the default type is used, the maximal integer number that can be
- stored is `9223372036854775807` (INT64_MAX) and the minimal integer number
- that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers
- that are out of range will yield over/underflow when used in a
- constructor. During deserialization, too large or small integer numbers
- will be automatically be stored as @ref number_unsigned_t or @ref
- number_float_t.
-
- [RFC 7159](http://rfc7159.net/rfc7159) further states:
- > Note that when such software is used, numbers that are integers and are
- > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
- > that implementations will agree exactly on their numeric values.
-
- As this range is a subrange of the exactly supported range [INT64_MIN,
- INT64_MAX], this class's integer type is interoperable.
-
- #### Storage
-
- Integer number values are stored directly inside a @ref basic_json type.
-
- @sa @ref number_float_t -- type for number values (floating-point)
-
- @sa @ref number_unsigned_t -- type for number values (unsigned integer)
-
- @since version 1.0.0
- */
- using number_integer_t = NumberIntegerType;
-
- /*!
- @brief a type for a number (unsigned)
-
- [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
- > The representation of numbers is similar to that used in most
- > programming languages. A number is represented in base 10 using decimal
- > digits. It contains an integer component that may be prefixed with an
- > optional minus sign, which may be followed by a fraction part and/or an
- > exponent part. Leading zeros are not allowed. (...) Numeric values that
- > cannot be represented in the grammar below (such as Infinity and NaN)
- > are not permitted.
-
- This description includes both integer and floating-point numbers.
- However, C++ allows more precise storage if it is known whether the number
- is a signed integer, an unsigned integer or a floating-point number.
- Therefore, three different types, @ref number_integer_t, @ref
- number_unsigned_t and @ref number_float_t are used.
-
- To store unsigned integer numbers in C++, a type is defined by the
- template parameter @a NumberUnsignedType which chooses the type to use.
-
- #### Default type
-
- With the default values for @a NumberUnsignedType (`uint64_t`), the
- default value for @a number_unsigned_t is:
-
- @code {.cpp}
- uint64_t
- @endcode
-
- #### Default behavior
-
- - The restrictions about leading zeros is not enforced in C++. Instead,
- leading zeros in integer literals lead to an interpretation as octal
- number. Internally, the value will be stored as decimal number. For
- instance, the C++ integer literal `010` will be serialized to `8`.
- During deserialization, leading zeros yield an error.
- - Not-a-number (NaN) values will be serialized to `null`.
-
- #### Limits
-
- [RFC 7159](http://rfc7159.net/rfc7159) specifies:
- > An implementation may set limits on the range and precision of numbers.
-
- When the default type is used, the maximal integer number that can be
- stored is `18446744073709551615` (UINT64_MAX) and the minimal integer
- number that can be stored is `0`. Integer numbers that are out of range
- will yield over/underflow when used in a constructor. During
- deserialization, too large or small integer numbers will be automatically
- be stored as @ref number_integer_t or @ref number_float_t.
-
- [RFC 7159](http://rfc7159.net/rfc7159) further states:
- > Note that when such software is used, numbers that are integers and are
- > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
- > that implementations will agree exactly on their numeric values.
-
- As this range is a subrange (when considered in conjunction with the
- number_integer_t type) of the exactly supported range [0, UINT64_MAX],
- this class's integer type is interoperable.
-
- #### Storage
-
- Integer number values are stored directly inside a @ref basic_json type.
-
- @sa @ref number_float_t -- type for number values (floating-point)
- @sa @ref number_integer_t -- type for number values (integer)
-
- @since version 2.0.0
- */
- using number_unsigned_t = NumberUnsignedType;
-
- /*!
- @brief a type for a number (floating-point)
-
- [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
- > The representation of numbers is similar to that used in most
- > programming languages. A number is represented in base 10 using decimal
- > digits. It contains an integer component that may be prefixed with an
- > optional minus sign, which may be followed by a fraction part and/or an
- > exponent part. Leading zeros are not allowed. (...) Numeric values that
- > cannot be represented in the grammar below (such as Infinity and NaN)
- > are not permitted.
-
- This description includes both integer and floating-point numbers.
- However, C++ allows more precise storage if it is known whether the number
- is a signed integer, an unsigned integer or a floating-point number.
- Therefore, three different types, @ref number_integer_t, @ref
- number_unsigned_t and @ref number_float_t are used.
-
- To store floating-point numbers in C++, a type is defined by the template
- parameter @a NumberFloatType which chooses the type to use.
-
- #### Default type
-
- With the default values for @a NumberFloatType (`double`), the default
- value for @a number_float_t is:
-
- @code {.cpp}
- double
- @endcode
-
- #### Default behavior
-
- - The restrictions about leading zeros is not enforced in C++. Instead,
- leading zeros in floating-point literals will be ignored. Internally,
- the value will be stored as decimal number. For instance, the C++
- floating-point literal `01.2` will be serialized to `1.2`. During
- deserialization, leading zeros yield an error.
- - Not-a-number (NaN) values will be serialized to `null`.
-
- #### Limits
-
- [RFC 7159](http://rfc7159.net/rfc7159) states:
- > This specification allows implementations to set limits on the range and
- > precision of numbers accepted. Since software that implements IEEE
- > 754-2008 binary64 (double precision) numbers is generally available and
- > widely used, good interoperability can be achieved by implementations
- > that expect no more precision or range than these provide, in the sense
- > that implementations will approximate JSON numbers within the expected
- > precision.
-
- This implementation does exactly follow this approach, as it uses double
- precision floating-point numbers. Note values smaller than
- `-1.79769313486232e+308` and values greater than `1.79769313486232e+308`
- will be stored as NaN internally and be serialized to `null`.
-
- #### Storage
-
- Floating-point number values are stored directly inside a @ref basic_json
- type.
-
- @sa @ref number_integer_t -- type for number values (integer)
-
- @sa @ref number_unsigned_t -- type for number values (unsigned integer)
-
- @since version 1.0.0
- */
- using number_float_t = NumberFloatType;
-
- /// @}
-
- private:
-
- /// helper for exception-safe object creation
- template<typename T, typename... Args>
- static T* create(Args&& ... args)
- {
- AllocatorType<T> alloc;
- auto deleter = [&](T * object)
- {
- alloc.deallocate(object, 1);
- };
- std::unique_ptr<T, decltype(deleter)> object(alloc.allocate(1), deleter);
- alloc.construct(object.get(), std::forward<Args>(args)...);
- assert(object != nullptr);
- return object.release();
- }
-
- ////////////////////////
- // JSON value storage //
- ////////////////////////
-
- /*!
- @brief a JSON value
-
- The actual storage for a JSON value of the @ref basic_json class. This
- union combines the different storage types for the JSON value types
- defined in @ref value_t.
-
- JSON type | value_t type | used type
- --------- | --------------- | ------------------------
- object | object | pointer to @ref object_t
- array | array | pointer to @ref array_t
- string | string | pointer to @ref string_t
- boolean | boolean | @ref boolean_t
- number | number_integer | @ref number_integer_t
- number | number_unsigned | @ref number_unsigned_t
- number | number_float | @ref number_float_t
- null | null | *no value is stored*
-
- @note Variable-length types (objects, arrays, and strings) are stored as
- pointers. The size of the union should not exceed 64 bits if the default
- value types are used.
-
- @since version 1.0.0
- */
- union json_value
- {
- /// object (stored with pointer to save storage)
- object_t* object;
- /// array (stored with pointer to save storage)
- array_t* array;
- /// string (stored with pointer to save storage)
- string_t* string;
- /// boolean
- boolean_t boolean;
- /// number (integer)
- number_integer_t number_integer;
- /// number (unsigned integer)
- number_unsigned_t number_unsigned;
- /// number (floating-point)
- number_float_t number_float;
-
- /// default constructor (for null values)
- json_value() = default;
- /// constructor for booleans
- json_value(boolean_t v) noexcept : boolean(v) {}
- /// constructor for numbers (integer)
- json_value(number_integer_t v) noexcept : number_integer(v) {}
- /// constructor for numbers (unsigned)
- json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
- /// constructor for numbers (floating-point)
- json_value(number_float_t v) noexcept : number_float(v) {}
- /// constructor for empty values of a given type
- json_value(value_t t)
- {
- switch (t)
- {
- case value_t::object:
- {
- object = create<object_t>();
- break;
- }
-
- case value_t::array:
- {
- array = create<array_t>();
- break;
- }
-
- case value_t::string:
- {
- string = create<string_t>("");
- break;
- }
-
- case value_t::boolean:
- {
- boolean = boolean_t(false);
- break;
- }
-
- case value_t::number_integer:
- {
- number_integer = number_integer_t(0);
- break;
- }
-
- case value_t::number_unsigned:
- {
- number_unsigned = number_unsigned_t(0);
- break;
- }
-
- case value_t::number_float:
- {
- number_float = number_float_t(0.0);
- break;
- }
-
- case value_t::null:
- {
- break;
- }
-
- default:
- {
- if (t == value_t::null)
- {
- JSON_THROW(std::domain_error("961c151d2e87f2686a955a9be24d316f1362bf21 2.1.1")); // LCOV_EXCL_LINE
- }
- break;
- }
- }
- }
-
- /// constructor for strings
- json_value(const string_t& value)
- {
- string = create<string_t>(value);
- }
-
- /// constructor for objects
- json_value(const object_t& value)
- {
- object = create<object_t>(value);
- }
-
- /// constructor for arrays
- json_value(const array_t& value)
- {
- array = create<array_t>(value);
- }
- };
-
- /*!
- @brief checks the class invariants
-
- This function asserts the class invariants. It needs to be called at the
- end of every constructor to make sure that created objects respect the
- invariant. Furthermore, it has to be called each time the type of a JSON
- value is changed, because the invariant expresses a relationship between
- @a m_type and @a m_value.
- */
- void assert_invariant() const
- {
- assert(m_type != value_t::object or m_value.object != nullptr);
- assert(m_type != value_t::array or m_value.array != nullptr);
- assert(m_type != value_t::string or m_value.string != nullptr);
- }
-
- public:
- //////////////////////////
- // JSON parser callback //
- //////////////////////////
-
- /*!
- @brief JSON callback events
-
- This enumeration lists the parser events that can trigger calling a
- callback function of type @ref parser_callback_t during parsing.
-
- @image html callback_events.png "Example when certain parse events are triggered"
-
- @since version 1.0.0
- */
- enum class parse_event_t : uint8_t
- {
- /// the parser read `{` and started to process a JSON object
- object_start,
- /// the parser read `}` and finished processing a JSON object
- object_end,
- /// the parser read `[` and started to process a JSON array
- array_start,
- /// the parser read `]` and finished processing a JSON array
- array_end,
- /// the parser read a key of a value in an object
- key,
- /// the parser finished reading a JSON value
- value
- };
-
- /*!
- @brief per-element parser callback type
-
- With a parser callback function, the result of parsing a JSON text can be
- influenced. When passed to @ref parse(std::istream&, const
- parser_callback_t) or @ref parse(const CharT, const parser_callback_t),
- it is called on certain events (passed as @ref parse_event_t via parameter
- @a event) with a set recursion depth @a depth and context JSON value
- @a parsed. The return value of the callback function is a boolean
- indicating whether the element that emitted the callback shall be kept or
- not.
-
- We distinguish six scenarios (determined by the event type) in which the
- callback function can be called. The following table describes the values
- of the parameters @a depth, @a event, and @a parsed.
-
- parameter @a event | description | parameter @a depth | parameter @a parsed
- ------------------ | ----------- | ------------------ | -------------------
- parse_event_t::object_start | the parser read `{` and started to process a JSON object | depth of the parent of the JSON object | a JSON value with type discarded
- parse_event_t::key | the parser read a key of a value in an object | depth of the currently parsed JSON object | a JSON string containing the key
- parse_event_t::object_end | the parser read `}` and finished processing a JSON object | depth of the parent of the JSON object | the parsed JSON object
- parse_event_t::array_start | the parser read `[` and started to process a JSON array | depth of the parent of the JSON array | a JSON value with type discarded
- parse_event_t::array_end | the parser read `]` and finished processing a JSON array | depth of the parent of the JSON array | the parsed JSON array
- parse_event_t::value | the parser finished reading a JSON value | depth of the value | the parsed JSON value
-
- @image html callback_events.png "Example when certain parse events are triggered"
-
- Discarding a value (i.e., returning `false`) has different effects
- depending on the context in which function was called:
-
- - Discarded values in structured types are skipped. That is, the parser
- will behave as if the discarded value was never read.
- - In case a value outside a structured type is skipped, it is replaced
- with `null`. This case happens if the top-level element is skipped.
-
- @param[in] depth the depth of the recursion during parsing
-
- @param[in] event an event of type parse_event_t indicating the context in
- the callback function has been called
-
- @param[in,out] parsed the current intermediate parse result; note that
- writing to this value has no effect for parse_event_t::key events
-
- @return Whether the JSON value which called the function during parsing
- should be kept (`true`) or not (`false`). In the latter case, it is either
- skipped completely or replaced by an empty discarded object.
-
- @sa @ref parse(std::istream&, parser_callback_t) or
- @ref parse(const CharT, const parser_callback_t) for examples
-
- @since version 1.0.0
- */
- using parser_callback_t = std::function<bool(int depth,
- parse_event_t event,
- basic_json& parsed)>;
-
-
- //////////////////
- // constructors //
- //////////////////
-
- /// @name constructors and destructors
- /// Constructors of class @ref basic_json, copy/move constructor, copy
- /// assignment, static functions creating objects, and the destructor.
- /// @{
-
- /*!
- @brief create an empty value with a given type
-
- Create an empty JSON value with a given type. The value will be default
- initialized with an empty value which depends on the type:
-
- Value type | initial value
- ----------- | -------------
- null | `null`
- boolean | `false`
- string | `""`
- number | `0`
- object | `{}`
- array | `[]`
-
- @param[in] value_type the type of the value to create
-
- @complexity Constant.
-
- @throw std::bad_alloc if allocation for object, array, or string value
- fails
-
- @liveexample{The following code shows the constructor for different @ref
- value_t values,basic_json__value_t}
-
- @since version 1.0.0
- */
- basic_json(const value_t value_type)
- : m_type(value_type), m_value(value_type)
- {
- assert_invariant();
- }
-
- /*!
- @brief create a null object
-
- Create a `null` JSON value. It either takes a null pointer as parameter
- (explicitly creating `null`) or no parameter (implicitly creating `null`).
- The passed null pointer itself is not read -- it is only used to choose
- the right constructor.
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this constructor never throws
- exceptions.
-
- @liveexample{The following code shows the constructor with and without a
- null pointer parameter.,basic_json__nullptr_t}
-
- @since version 1.0.0
- */
- basic_json(std::nullptr_t = nullptr) noexcept
- : basic_json(value_t::null)
- {
- assert_invariant();
- }
-
- /*!
- @brief create a JSON value
-
- This is a "catch all" constructor for all compatible JSON types; that is,
- types for which a `to_json()` method exsits. The constructor forwards the
- parameter @a val to that method (to `json_serializer<U>::to_json` method
- with `U = uncvref_t<CompatibleType>`, to be exact).
-
- Template type @a CompatibleType includes, but is not limited to, the
- following types:
- - **arrays**: @ref array_t and all kinds of compatible containers such as
- `std::vector`, `std::deque`, `std::list`, `std::forward_list`,
- `std::array`, `std::set`, `std::unordered_set`, `std::multiset`, and
- `unordered_multiset` with a `value_type` from which a @ref basic_json
- value can be constructed.
- - **objects**: @ref object_t and all kinds of compatible associative
- containers such as `std::map`, `std::unordered_map`, `std::multimap`,
- and `std::unordered_multimap` with a `key_type` compatible to
- @ref string_t and a `value_type` from which a @ref basic_json value can
- be constructed.
- - **strings**: @ref string_t, string literals, and all compatible string
- containers can be used.
- - **numbers**: @ref number_integer_t, @ref number_unsigned_t,
- @ref number_float_t, and all convertible number types such as `int`,
- `size_t`, `int64_t`, `float` or `double` can be used.
- - **boolean**: @ref boolean_t / `bool` can be used.
-
- See the examples below.
-
- @tparam CompatibleType a type such that:
- - @a CompatibleType is not derived from `std::istream`,
- - @a CompatibleType is not @ref basic_json (to avoid hijacking copy/move
- constructors),
- - @a CompatibleType is not a @ref basic_json nested type (e.g.,
- @ref json_pointer, @ref iterator, etc ...)
- - @ref @ref json_serializer<U> has a
- `to_json(basic_json_t&, CompatibleType&&)` method
-
- @tparam U = `uncvref_t<CompatibleType>`
-
- @param[in] val the value to be forwarded
-
- @complexity Usually linear in the size of the passed @a val, also
- depending on the implementation of the called `to_json()`
- method.
-
- @throw what `json_serializer<U>::to_json()` throws
-
- @liveexample{The following code shows the constructor with several
- compatible types.,basic_json__CompatibleType}
-
- @since version 2.1.0
- */
- template<typename CompatibleType, typename U = detail::uncvref_t<CompatibleType>,
- detail::enable_if_t<not std::is_base_of<std::istream, U>::value and
- not std::is_same<U, basic_json_t>::value and
- not detail::is_basic_json_nested_type<
- basic_json_t, U>::value and
- detail::has_to_json<basic_json, U>::value,
- int> = 0>
- basic_json(CompatibleType && val) noexcept(noexcept(JSONSerializer<U>::to_json(
- std::declval<basic_json_t&>(), std::forward<CompatibleType>(val))))
- {
- JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
- assert_invariant();
- }
-
- /*!
- @brief create a container (array or object) from an initializer list
-
- Creates a JSON value of type array or object from the passed initializer
- list @a init. In case @a type_deduction is `true` (default), the type of
- the JSON value to be created is deducted from the initializer list @a init
- according to the following rules:
-
- 1. If the list is empty, an empty JSON object value `{}` is created.
- 2. If the list consists of pairs whose first element is a string, a JSON
- object value is created where the first elements of the pairs are
- treated as keys and the second elements are as values.
- 3. In all other cases, an array is created.
-
- The rules aim to create the best fit between a C++ initializer list and
- JSON values. The rationale is as follows:
-
- 1. The empty initializer list is written as `{}` which is exactly an empty
- JSON object.
- 2. C++ has now way of describing mapped types other than to list a list of
- pairs. As JSON requires that keys must be of type string, rule 2 is the
- weakest constraint one can pose on initializer lists to interpret them
- as an object.
- 3. In all other cases, the initializer list could not be interpreted as
- JSON object type, so interpreting it as JSON array type is safe.
-
- With the rules described above, the following JSON values cannot be
- expressed by an initializer list:
-
- - the empty array (`[]`): use @ref array(std::initializer_list<basic_json>)
- with an empty initializer list in this case
- - arrays whose elements satisfy rule 2: use @ref
- array(std::initializer_list<basic_json>) with the same initializer list
- in this case
-
- @note When used without parentheses around an empty initializer list, @ref
- basic_json() is called instead of this function, yielding the JSON null
- value.
-
- @param[in] init initializer list with JSON values
-
- @param[in] type_deduction internal parameter; when set to `true`, the type
- of the JSON value is deducted from the initializer list @a init; when set
- to `false`, the type provided via @a manual_type is forced. This mode is
- used by the functions @ref array(std::initializer_list<basic_json>) and
- @ref object(std::initializer_list<basic_json>).
-
- @param[in] manual_type internal parameter; when @a type_deduction is set
- to `false`, the created JSON value will use the provided type (only @ref
- value_t::array and @ref value_t::object are valid); when @a type_deduction
- is set to `true`, this parameter has no effect
-
- @throw std::domain_error if @a type_deduction is `false`, @a manual_type
- is `value_t::object`, but @a init contains an element which is not a pair
- whose first element is a string; example: `"cannot create object from
- initializer list"`
-
- @complexity Linear in the size of the initializer list @a init.
-
- @liveexample{The example below shows how JSON values are created from
- initializer lists.,basic_json__list_init_t}
-
- @sa @ref array(std::initializer_list<basic_json>) -- create a JSON array
- value from an initializer list
- @sa @ref object(std::initializer_list<basic_json>) -- create a JSON object
- value from an initializer list
-
- @since version 1.0.0
- */
- basic_json(std::initializer_list<basic_json> init,
- bool type_deduction = true,
- value_t manual_type = value_t::array)
- {
- // check if each element is an array with two elements whose first
- // element is a string
- bool is_an_object = std::all_of(init.begin(), init.end(),
- [](const basic_json & element)
- {
- return element.is_array() and element.size() == 2 and element[0].is_string();
- });
-
- // adjust type if type deduction is not wanted
- if (not type_deduction)
- {
- // if array is wanted, do not create an object though possible
- if (manual_type == value_t::array)
- {
- is_an_object = false;
- }
-
- // if object is wanted but impossible, throw an exception
- if (manual_type == value_t::object and not is_an_object)
- {
- JSON_THROW(std::domain_error("cannot create object from initializer list"));
- }
- }
-
- if (is_an_object)
- {
- // the initializer list is a list of pairs -> create object
- m_type = value_t::object;
- m_value = value_t::object;
-
- std::for_each(init.begin(), init.end(), [this](const basic_json & element)
- {
- m_value.object->emplace(*(element[0].m_value.string), element[1]);
- });
- }
- else
- {
- // the initializer list describes an array -> create array
- m_type = value_t::array;
- m_value.array = create<array_t>(init);
- }
-
- assert_invariant();
- }
-
- /*!
- @brief explicitly create an array from an initializer list
-
- Creates a JSON array value from a given initializer list. That is, given a
- list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the
- initializer list is empty, the empty array `[]` is created.
-
- @note This function is only needed to express two edge cases that cannot
- be realized with the initializer list constructor (@ref
- basic_json(std::initializer_list<basic_json>, bool, value_t)). These cases
- are:
- 1. creating an array whose elements are all pairs whose first element is a
- string -- in this case, the initializer list constructor would create an
- object, taking the first elements as keys
- 2. creating an empty array -- passing the empty initializer list to the
- initializer list constructor yields an empty object
-
- @param[in] init initializer list with JSON values to create an array from
- (optional)
-
- @return JSON array value
-
- @complexity Linear in the size of @a init.
-
- @liveexample{The following code shows an example for the `array`
- function.,array}
-
- @sa @ref basic_json(std::initializer_list<basic_json>, bool, value_t) --
- create a JSON value from an initializer list
- @sa @ref object(std::initializer_list<basic_json>) -- create a JSON object
- value from an initializer list
-
- @since version 1.0.0
- */
- static basic_json array(std::initializer_list<basic_json> init =
- std::initializer_list<basic_json>())
- {
- return basic_json(init, false, value_t::array);
- }
-
- /*!
- @brief explicitly create an object from an initializer list
-
- Creates a JSON object value from a given initializer list. The initializer
- lists elements must be pairs, and their first elements must be strings. If
- the initializer list is empty, the empty object `{}` is created.
-
- @note This function is only added for symmetry reasons. In contrast to the
- related function @ref array(std::initializer_list<basic_json>), there are
- no cases which can only be expressed by this function. That is, any
- initializer list @a init can also be passed to the initializer list
- constructor @ref basic_json(std::initializer_list<basic_json>, bool,
- value_t).
-
- @param[in] init initializer list to create an object from (optional)
-
- @return JSON object value
-
- @throw std::domain_error if @a init is not a pair whose first elements are
- strings; thrown by
- @ref basic_json(std::initializer_list<basic_json>, bool, value_t)
-
- @complexity Linear in the size of @a init.
-
- @liveexample{The following code shows an example for the `object`
- function.,object}
-
- @sa @ref basic_json(std::initializer_list<basic_json>, bool, value_t) --
- create a JSON value from an initializer list
- @sa @ref array(std::initializer_list<basic_json>) -- create a JSON array
- value from an initializer list
-
- @since version 1.0.0
- */
- static basic_json object(std::initializer_list<basic_json> init =
- std::initializer_list<basic_json>())
- {
- return basic_json(init, false, value_t::object);
- }
-
- /*!
- @brief construct an array with count copies of given value
-
- Constructs a JSON array value by creating @a cnt copies of a passed value.
- In case @a cnt is `0`, an empty array is created. As postcondition,
- `std::distance(begin(),end()) == cnt` holds.
-
- @param[in] cnt the number of JSON copies of @a val to create
- @param[in] val the JSON value to copy
-
- @complexity Linear in @a cnt.
-
- @liveexample{The following code shows examples for the @ref
- basic_json(size_type\, const basic_json&)
- constructor.,basic_json__size_type_basic_json}
-
- @since version 1.0.0
- */
- basic_json(size_type cnt, const basic_json& val)
- : m_type(value_t::array)
- {
- m_value.array = create<array_t>(cnt, val);
- assert_invariant();
- }
-
- /*!
- @brief construct a JSON container given an iterator range
-
- Constructs the JSON value with the contents of the range `[first, last)`.
- The semantics depends on the different types a JSON value can have:
- - In case of primitive types (number, boolean, or string), @a first must
- be `begin()` and @a last must be `end()`. In this case, the value is
- copied. Otherwise, std::out_of_range is thrown.
- - In case of structured types (array, object), the constructor behaves as
- similar versions for `std::vector`.
- - In case of a null type, std::domain_error is thrown.
-
- @tparam InputIT an input iterator type (@ref iterator or @ref
- const_iterator)
-
- @param[in] first begin of the range to copy from (included)
- @param[in] last end of the range to copy from (excluded)
-
- @pre Iterators @a first and @a last must be initialized. **This
- precondition is enforced with an assertion.**
-
- @throw std::domain_error if iterators are not compatible; that is, do not
- belong to the same JSON value; example: `"iterators are not compatible"`
- @throw std::out_of_range if iterators are for a primitive type (number,
- boolean, or string) where an out of range error can be detected easily;
- example: `"iterators out of range"`
- @throw std::bad_alloc if allocation for object, array, or string fails
- @throw std::domain_error if called with a null value; example: `"cannot
- use construct with iterators from null"`
-
- @complexity Linear in distance between @a first and @a last.
-
- @liveexample{The example below shows several ways to create JSON values by
- specifying a subrange with iterators.,basic_json__InputIt_InputIt}
-
- @since version 1.0.0
- */
- template<class InputIT, typename std::enable_if<
- std::is_same<InputIT, typename basic_json_t::iterator>::value or
- std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int>::type = 0>
- basic_json(InputIT first, InputIT last)
- {
- assert(first.m_object != nullptr);
- assert(last.m_object != nullptr);
-
- // make sure iterator fits the current value
- if (first.m_object != last.m_object)
- {
- JSON_THROW(std::domain_error("iterators are not compatible"));
- }
-
- // copy type from first iterator
- m_type = first.m_object->m_type;
-
- // check if iterator range is complete for primitive values
- switch (m_type)
- {
- case value_t::boolean:
- case value_t::number_float:
- case value_t::number_integer:
- case value_t::number_unsigned:
- case value_t::string:
- {
- if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())
- {
- JSON_THROW(std::out_of_range("iterators out of range"));
- }
- break;
- }
-
- default:
- {
- break;
- }
- }
-
- switch (m_type)
- {
- case value_t::number_integer:
- {
- m_value.number_integer = first.m_object->m_value.number_integer;
- break;
- }
-
- case value_t::number_unsigned:
- {
- m_value.number_unsigned = first.m_object->m_value.number_unsigned;
- break;
- }
-
- case value_t::number_float:
- {
- m_value.number_float = first.m_object->m_value.number_float;
- break;
- }
-
- case value_t::boolean:
- {
- m_value.boolean = first.m_object->m_value.boolean;
- break;
- }
-
- case value_t::string:
- {
- m_value = *first.m_object->m_value.string;
- break;
- }
-
- case value_t::object:
- {
- m_value.object = create<object_t>(first.m_it.object_iterator,
- last.m_it.object_iterator);
- break;
- }
-
- case value_t::array:
- {
- m_value.array = create<array_t>(first.m_it.array_iterator,
- last.m_it.array_iterator);
- break;
- }
-
- default:
- {
- JSON_THROW(std::domain_error("cannot use construct with iterators from " + first.m_object->type_name()));
- }
- }
-
- assert_invariant();
- }
-
- /*!
- @brief construct a JSON value given an input stream
-
- @param[in,out] i stream to read a serialized JSON value from
- @param[in] cb a parser callback function of type @ref parser_callback_t
- which is used to control the deserialization by filtering unwanted values
- (optional)
-
- @complexity Linear in the length of the input. The parser is a predictive
- LL(1) parser. The complexity can be higher if the parser callback function
- @a cb has a super-linear complexity.
-
- @note A UTF-8 byte order mark is silently ignored.
-
- @deprecated This constructor is deprecated and will be removed in version
- 3.0.0 to unify the interface of the library. Deserialization will be
- done by stream operators or by calling one of the `parse` functions,
- e.g. @ref parse(std::istream&, const parser_callback_t). That is, calls
- like `json j(i);` for an input stream @a i need to be replaced by
- `json j = json::parse(i);`. See the example below.
-
- @liveexample{The example below demonstrates constructing a JSON value from
- a `std::stringstream` with and without callback
- function.,basic_json__istream}
-
- @since version 2.0.0, deprecated in version 2.0.3, to be removed in
- version 3.0.0
- */
- JSON_DEPRECATED
- explicit basic_json(std::istream& i, const parser_callback_t cb = nullptr)
- {
- *this = parser(i, cb).parse();
- assert_invariant();
- }
-
- ///////////////////////////////////////
- // other constructors and destructor //
- ///////////////////////////////////////
-
- /*!
- @brief copy constructor
-
- Creates a copy of a given JSON value.
-
- @param[in] other the JSON value to copy
-
- @complexity Linear in the size of @a other.
-
- @requirement This function helps `basic_json` satisfying the
- [Container](http://en.cppreference.com/w/cpp/concept/Container)
- requirements:
- - The complexity is linear.
- - As postcondition, it holds: `other == basic_json(other)`.
-
- @throw std::bad_alloc if allocation for object, array, or string fails.
-
- @liveexample{The following code shows an example for the copy
- constructor.,basic_json__basic_json}
-
- @since version 1.0.0
- */
- basic_json(const basic_json& other)
- : m_type(other.m_type)
- {
- // check of passed value is valid
- other.assert_invariant();
-
- switch (m_type)
- {
- case value_t::object:
- {
- m_value = *other.m_value.object;
- break;
- }
-
- case value_t::array:
- {
- m_value = *other.m_value.array;
- break;
- }
-
- case value_t::string:
- {
- m_value = *other.m_value.string;
- break;
- }
-
- case value_t::boolean:
- {
- m_value = other.m_value.boolean;
- break;
- }
-
- case value_t::number_integer:
- {
- m_value = other.m_value.number_integer;
- break;
- }
-
- case value_t::number_unsigned:
- {
- m_value = other.m_value.number_unsigned;
- break;
- }
-
- case value_t::number_float:
- {
- m_value = other.m_value.number_float;
- break;
- }
-
- default:
- {
- break;
- }
- }
-
- assert_invariant();
- }
-
- /*!
- @brief move constructor
-
- Move constructor. Constructs a JSON value with the contents of the given
- value @a other using move semantics. It "steals" the resources from @a
- other and leaves it as JSON null value.
-
- @param[in,out] other value to move to this object
-
- @post @a other is a JSON null value
-
- @complexity Constant.
-
- @liveexample{The code below shows the move constructor explicitly called
- via std::move.,basic_json__moveconstructor}
-
- @since version 1.0.0
- */
- basic_json(basic_json&& other) noexcept
- : m_type(std::move(other.m_type)),
- m_value(std::move(other.m_value))
- {
- // check that passed value is valid
- other.assert_invariant();
-
- // invalidate payload
- other.m_type = value_t::null;
- other.m_value = {};
-
- assert_invariant();
- }
-
- /*!
- @brief copy assignment
-
- Copy assignment operator. Copies a JSON value via the "copy and swap"
- strategy: It is expressed in terms of the copy constructor, destructor,
- and the swap() member function.
-
- @param[in] other value to copy from
-
- @complexity Linear.
-
- @requirement This function helps `basic_json` satisfying the
- [Container](http://en.cppreference.com/w/cpp/concept/Container)
- requirements:
- - The complexity is linear.
-
- @liveexample{The code below shows and example for the copy assignment. It
- creates a copy of value `a` which is then swapped with `b`. Finally\, the
- copy of `a` (which is the null value after the swap) is
- destroyed.,basic_json__copyassignment}
-
- @since version 1.0.0
- */
- reference& operator=(basic_json other) noexcept (
- std::is_nothrow_move_constructible<value_t>::value and
- std::is_nothrow_move_assignable<value_t>::value and
- std::is_nothrow_move_constructible<json_value>::value and
- std::is_nothrow_move_assignable<json_value>::value
- )
- {
- // check that passed value is valid
- other.assert_invariant();
-
- using std::swap;
- swap(m_type, other.m_type);
- swap(m_value, other.m_value);
-
- assert_invariant();
- return *this;
- }
-
- /*!
- @brief destructor
-
- Destroys the JSON value and frees all allocated memory.
-
- @complexity Linear.
-
- @requirement This function helps `basic_json` satisfying the
- [Container](http://en.cppreference.com/w/cpp/concept/Container)
- requirements:
- - The complexity is linear.
- - All stored elements are destroyed and all memory is freed.
-
- @since version 1.0.0
- */
- ~basic_json()
- {
- assert_invariant();
-
- switch (m_type)
- {
- case value_t::object:
- {
- AllocatorType<object_t> alloc;
- alloc.destroy(m_value.object);
- alloc.deallocate(m_value.object, 1);
- break;
- }
-
- case value_t::array:
- {
- AllocatorType<array_t> alloc;
- alloc.destroy(m_value.array);
- alloc.deallocate(m_value.array, 1);
- break;
- }
-
- case value_t::string:
- {
- AllocatorType<string_t> alloc;
- alloc.destroy(m_value.string);
- alloc.deallocate(m_value.string, 1);
- break;
- }
-
- default:
- {
- // all other types need no specific destructor
- break;
- }
- }
- }
-
- /// @}
-
- public:
- ///////////////////////
- // object inspection //
- ///////////////////////
-
- /// @name object inspection
- /// Functions to inspect the type of a JSON value.
- /// @{
-
- /*!
- @brief serialization
-
- Serialization function for JSON values. The function tries to mimic
- Python's `json.dumps()` function, and currently supports its @a indent
- parameter.
-
- @param[in] indent If indent is nonnegative, then array elements and object
- members will be pretty-printed with that indent level. An indent level of
- `0` will only insert newlines. `-1` (the default) selects the most compact
- representation.
-
- @return string containing the serialization of the JSON value
-
- @complexity Linear.
-
- @liveexample{The following example shows the effect of different @a indent
- parameters to the result of the serialization.,dump}
-
- @see https://docs.python.org/2/library/json.html#json.dump
-
- @since version 1.0.0
- */
- string_t dump(const int indent = -1) const
- {
- std::stringstream ss;
-
- if (indent >= 0)
- {
- dump(ss, true, static_cast<unsigned int>(indent));
- }
- else
- {
- dump(ss, false, 0);
- }
-
- return ss.str();
- }
-
- /*!
- @brief return the type of the JSON value (explicit)
-
- Return the type of the JSON value as a value from the @ref value_t
- enumeration.
-
- @return the type of the JSON value
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies `type()` for all JSON
- types.,type}
-
- @since version 1.0.0
- */
- constexpr value_t type() const noexcept
- {
- return m_type;
- }
-
- /*!
- @brief return whether type is primitive
-
- This function returns true iff the JSON type is primitive (string, number,
- boolean, or null).
-
- @return `true` if type is primitive (string, number, boolean, or null),
- `false` otherwise.
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies `is_primitive()` for all JSON
- types.,is_primitive}
-
- @sa @ref is_structured() -- returns whether JSON value is structured
- @sa @ref is_null() -- returns whether JSON value is `null`
- @sa @ref is_string() -- returns whether JSON value is a string
- @sa @ref is_boolean() -- returns whether JSON value is a boolean
- @sa @ref is_number() -- returns whether JSON value is a number
-
- @since version 1.0.0
- */
- constexpr bool is_primitive() const noexcept
- {
- return is_null() or is_string() or is_boolean() or is_number();
- }
-
- /*!
- @brief return whether type is structured
-
- This function returns true iff the JSON type is structured (array or
- object).
-
- @return `true` if type is structured (array or object), `false` otherwise.
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies `is_structured()` for all JSON
- types.,is_structured}
-
- @sa @ref is_primitive() -- returns whether value is primitive
- @sa @ref is_array() -- returns whether value is an array
- @sa @ref is_object() -- returns whether value is an object
-
- @since version 1.0.0
- */
- constexpr bool is_structured() const noexcept
- {
- return is_array() or is_object();
- }
-
- /*!
- @brief return whether value is null
-
- This function returns true iff the JSON value is null.
-
- @return `true` if type is null, `false` otherwise.
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies `is_null()` for all JSON
- types.,is_null}
-
- @since version 1.0.0
- */
- constexpr bool is_null() const noexcept
- {
- return m_type == value_t::null;
- }
-
- /*!
- @brief return whether value is a boolean
-
- This function returns true iff the JSON value is a boolean.
-
- @return `true` if type is boolean, `false` otherwise.
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies `is_boolean()` for all JSON
- types.,is_boolean}
-
- @since version 1.0.0
- */
- constexpr bool is_boolean() const noexcept
- {
- return m_type == value_t::boolean;
- }
-
- /*!
- @brief return whether value is a number
-
- This function returns true iff the JSON value is a number. This includes
- both integer and floating-point values.
-
- @return `true` if type is number (regardless whether integer, unsigned
- integer or floating-type), `false` otherwise.
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies `is_number()` for all JSON
- types.,is_number}
-
- @sa @ref is_number_integer() -- check if value is an integer or unsigned
- integer number
- @sa @ref is_number_unsigned() -- check if value is an unsigned integer
- number
- @sa @ref is_number_float() -- check if value is a floating-point number
-
- @since version 1.0.0
- */
- constexpr bool is_number() const noexcept
- {
- return is_number_integer() or is_number_float();
- }
-
- /*!
- @brief return whether value is an integer number
-
- This function returns true iff the JSON value is an integer or unsigned
- integer number. This excludes floating-point values.
-
- @return `true` if type is an integer or unsigned integer number, `false`
- otherwise.
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies `is_number_integer()` for all
- JSON types.,is_number_integer}
-
- @sa @ref is_number() -- check if value is a number
- @sa @ref is_number_unsigned() -- check if value is an unsigned integer
- number
- @sa @ref is_number_float() -- check if value is a floating-point number
-
- @since version 1.0.0
- */
- constexpr bool is_number_integer() const noexcept
- {
- return m_type == value_t::number_integer or m_type == value_t::number_unsigned;
- }
-
- /*!
- @brief return whether value is an unsigned integer number
-
- This function returns true iff the JSON value is an unsigned integer
- number. This excludes floating-point and (signed) integer values.
-
- @return `true` if type is an unsigned integer number, `false` otherwise.
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies `is_number_unsigned()` for all
- JSON types.,is_number_unsigned}
-
- @sa @ref is_number() -- check if value is a number
- @sa @ref is_number_integer() -- check if value is an integer or unsigned
- integer number
- @sa @ref is_number_float() -- check if value is a floating-point number
-
- @since version 2.0.0
- */
- constexpr bool is_number_unsigned() const noexcept
- {
- return m_type == value_t::number_unsigned;
- }
-
- /*!
- @brief return whether value is a floating-point number
-
- This function returns true iff the JSON value is a floating-point number.
- This excludes integer and unsigned integer values.
-
- @return `true` if type is a floating-point number, `false` otherwise.
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies `is_number_float()` for all
- JSON types.,is_number_float}
-
- @sa @ref is_number() -- check if value is number
- @sa @ref is_number_integer() -- check if value is an integer number
- @sa @ref is_number_unsigned() -- check if value is an unsigned integer
- number
-
- @since version 1.0.0
- */
- constexpr bool is_number_float() const noexcept
- {
- return m_type == value_t::number_float;
- }
-
- /*!
- @brief return whether value is an object
-
- This function returns true iff the JSON value is an object.
-
- @return `true` if type is object, `false` otherwise.
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies `is_object()` for all JSON
- types.,is_object}
-
- @since version 1.0.0
- */
- constexpr bool is_object() const noexcept
- {
- return m_type == value_t::object;
- }
-
- /*!
- @brief return whether value is an array
-
- This function returns true iff the JSON value is an array.
-
- @return `true` if type is array, `false` otherwise.
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies `is_array()` for all JSON
- types.,is_array}
-
- @since version 1.0.0
- */
- constexpr bool is_array() const noexcept
- {
- return m_type == value_t::array;
- }
-
- /*!
- @brief return whether value is a string
-
- This function returns true iff the JSON value is a string.
-
- @return `true` if type is string, `false` otherwise.
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies `is_string()` for all JSON
- types.,is_string}
-
- @since version 1.0.0
- */
- constexpr bool is_string() const noexcept
- {
- return m_type == value_t::string;
- }
-
- /*!
- @brief return whether value is discarded
-
- This function returns true iff the JSON value was discarded during parsing
- with a callback function (see @ref parser_callback_t).
-
- @note This function will always be `false` for JSON values after parsing.
- That is, discarded values can only occur during parsing, but will be
- removed when inside a structured value or replaced by null in other cases.
-
- @return `true` if type is discarded, `false` otherwise.
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies `is_discarded()` for all JSON
- types.,is_discarded}
-
- @since version 1.0.0
- */
- constexpr bool is_discarded() const noexcept
- {
- return m_type == value_t::discarded;
- }
-
- /*!
- @brief return the type of the JSON value (implicit)
-
- Implicitly return the type of the JSON value as a value from the @ref
- value_t enumeration.
-
- @return the type of the JSON value
-
- @complexity Constant.
-
- @exceptionsafety No-throw guarantee: this member function never throws
- exceptions.
-
- @liveexample{The following code exemplifies the @ref value_t operator for
- all JSON types.,operator__value_t}
-
- @since version 1.0.0
- */
- constexpr operator value_t() const noexcept
- {
- return m_type;
- }
-
- /// @}
-
- private:
- //////////////////
- // value access //
- //////////////////
-
- /// get a boolean (explicit)
- boolean_t get_impl(boolean_t* /*unused*/) const
- {
- if (is_boolean())
- {
- return m_value.boolean;
- }
-
- JSON_THROW(std::domain_error("type must be boolean, but is " + type_name()));
- }
-
- /// get a pointer to the value (object)
- object_t* get_impl_ptr(object_t* /*unused*/) noexcept
- {
- return is_object() ? m_value.object : nullptr;
- }
-
- /// get a pointer to the value (object)
- constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
- {
- return is_object() ? m_value.object : nullptr;
- }
-
- /// get a pointer to the value (array)
- array_t* get_impl_ptr(array_t* /*unused*/) noexcept
- {
- return is_array() ? m_value.array : nullptr;
- }
-
- /// get a pointer to the value (array)
- constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
- {
- return is_array() ? m_value.array : nullptr;
- }
-
- /// get a pointer to the value (string)
- string_t* get_impl_ptr(string_t* /*unused*/) noexcept
- {
- return is_string() ? m_value.string : nullptr;
- }
-
- /// get a pointer to the value (string)
- constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
- {
- return is_string() ? m_value.string : nullptr;
- }
-
- /// get a pointer to the value (boolean)
- boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
- {
- return is_boolean() ? &m_value.boolean : nullptr;
- }
-
- /// get a pointer to the value (boolean)
- constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
- {
- return is_boolean() ? &m_value.boolean : nullptr;
- }
-
- /// get a pointer to the value (integer number)
- number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
- {
- return is_number_integer() ? &m_value.number_integer : nullptr;
- }
-
- /// get a pointer to the value (integer number)
- constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
- {
- return is_number_integer() ? &m_value.number_integer : nullptr;
- }
-
- /// get a pointer to the value (unsigned number)
- number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
- {
- return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
- }
-
- /// get a pointer to the value (unsigned number)
- constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
- {
- return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
- }
-
- /// get a pointer to the value (floating-point number)
- number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
- {
- return is_number_float() ? &m_value.number_float : nullptr;
- }
-
- /// get a pointer to the value (floating-point number)
- constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
- {
- return is_number_float() ? &m_value.number_float : nullptr;
- }
-
- /*!
- @brief helper function to implement get_ref()
-
- This funcion helps to implement get_ref() without code duplication for
- const and non-const overloads
-
- @tparam ThisType will be deduced as `basic_json` or `const basic_json`
-
- @throw std::domain_error if ReferenceType does not match underlying value
- type of the current JSON
- */
- template<typename ReferenceType, typename ThisType>
- static ReferenceType get_ref_impl(ThisType& obj)
- {
- // helper type
- using PointerType = typename std::add_pointer<ReferenceType>::type;
-
- // delegate the call to get_ptr<>()
- auto ptr = obj.template get_ptr<PointerType>();
-
- if (ptr != nullptr)
- {
- return *ptr;
- }
-
- JSON_THROW(std::domain_error("incompatible ReferenceType for get_ref, actual type is " +
- obj.type_name()));
- }
-
- public:
- /// @name value access
- /// Direct access to the stored value of a JSON value.
- /// @{
-
- /*!
- @brief get special-case overload
-
- This overloads avoids a lot of template boilerplate, it can be seen as the
- identity method
-
- @tparam BasicJsonType == @ref basic_json
-
- @return a copy of *this
-
- @complexity Constant.
-
- @since version 2.1.0
- */
- template <
- typename BasicJsonType,
- detail::enable_if_t<std::is_same<typename std::remove_const<BasicJsonType>::type,
- basic_json_t>::value,
- int> = 0 >
- basic_json get() const
- {
- return *this;
- }
-
- /*!
- @brief get a value (explicit)
-
- Explicit type conversion between the JSON value and a compatible value
- which is [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible)
- and [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible).
- The value is converted by calling the @ref json_serializer<ValueType>
- `from_json()` method.
-
- The function is equivalent to executing
- @code {.cpp}
- ValueType ret;
- JSONSerializer<ValueType>::from_json(*this, ret);
- return ret;
- @endcode
-
- This overloads is chosen if:
- - @a ValueType is not @ref basic_json,
- - @ref json_serializer<ValueType> has a `from_json()` method of the form
- `void from_json(const @ref basic_json&, ValueType&)`, and
- - @ref json_serializer<ValueType> does not have a `from_json()` method of
- the form `ValueType from_json(const @ref basic_json&)`
-
- @tparam ValueTypeCV the provided value type
- @tparam ValueType the returned value type
-
- @return copy of the JSON value, converted to @a ValueType
-
- @throw what @ref json_serializer<ValueType> `from_json()` method throws
-
- @liveexample{The example below shows several conversions from JSON values
- to other types. There a few things to note: (1) Floating-point numbers can
- be converted to integers\, (2) A JSON array can be converted to a standard
- `std::vector<short>`\, (3) A JSON object can be converted to C++
- associative containers such as `std::unordered_map<std::string\,
- json>`.,get__ValueType_const}
-
- @since version 2.1.0
- */
- template <
- typename ValueTypeCV,
- typename ValueType = detail::uncvref_t<ValueTypeCV>,
- detail::enable_if_t <
- not std::is_same<basic_json_t, ValueType>::value and
- detail::has_from_json<basic_json_t, ValueType>::value and
- not detail::has_non_default_from_json<basic_json_t, ValueType>::value,
- int > = 0 >
- ValueType get() const noexcept(noexcept(
- JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
- {
- // we cannot static_assert on ValueTypeCV being non-const, because
- // there is support for get<const basic_json_t>(), which is why we
- // still need the uncvref
- static_assert(not std::is_reference<ValueTypeCV>::value,
- "get() cannot be used with reference types, you might want to use get_ref()");
- static_assert(std::is_default_constructible<ValueType>::value,
- "types must be DefaultConstructible when used with get()");
-
- ValueType ret;
- JSONSerializer<ValueType>::from_json(*this, ret);
- return ret;
- }
-
- /*!
- @brief get a value (explicit); special case
-
- Explicit type conversion between the JSON value and a compatible value
- which is **not** [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible)
- and **not** [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible).
- The value is converted by calling the @ref json_serializer<ValueType>
- `from_json()` method.
-
- The function is equivalent to executing
- @code {.cpp}
- return JSONSerializer<ValueTypeCV>::from_json(*this);
- @endcode
-
- This overloads is chosen if:
- - @a ValueType is not @ref basic_json and
- - @ref json_serializer<ValueType> has a `from_json()` method of the form
- `ValueType from_json(const @ref basic_json&)`
-
- @note If @ref json_serializer<ValueType> has both overloads of
- `from_json()`, this one is chosen.
-
- @tparam ValueTypeCV the provided value type
- @tparam ValueType the returned value type
-
- @return copy of the JSON value, converted to @a ValueType
-
- @throw what @ref json_serializer<ValueType> `from_json()` method throws
-
- @since version 2.1.0
- */
- template <
- typename ValueTypeCV,
- typename ValueType = detail::uncvref_t<ValueTypeCV>,
- detail::enable_if_t<not std::is_same<basic_json_t, ValueType>::value and
- detail::has_non_default_from_json<basic_json_t,
- ValueType>::value, int> = 0 >
- ValueType get() const noexcept(noexcept(
- JSONSerializer<ValueTypeCV>::from_json(std::declval<const basic_json_t&>())))
- {
- static_assert(not std::is_reference<ValueTypeCV>::value,
- "get() cannot be used with reference types, you might want to use get_ref()");
- return JSONSerializer<ValueTypeCV>::from_json(*this);
- }
-
- /*!
- @brief get a pointer value (explicit)
-
- Explicit pointer access to the internally stored JSON value. No copies are
- made.
-
- @warning The pointer becomes invalid if the underlying JSON object
- changes.
-
- @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
- object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
- @ref number_unsigned_t, or @ref number_float_t.
-
- @return pointer to the internally stored JSON value if the requested
- pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
-
- @complexity Constant.
-
- @liveexample{The example below shows how pointers to internal values of a
- JSON value can be requested. Note that no type conversions are made and a
- `nullptr` is returned if the value and the requested pointer type does not
- match.,get__PointerType}
-
- @sa @ref get_ptr() for explicit pointer-member access
-
- @since version 1.0.0
- */
- template<typename PointerType, typename std::enable_if<
- std::is_pointer<PointerType>::value, int>::type = 0>
- PointerType get() noexcept
- {
- // delegate the call to get_ptr
- return get_ptr<PointerType>();
- }
-
- /*!
- @brief get a pointer value (explicit)
- @copydoc get()
- */
- template<typename PointerType, typename std::enable_if<
- std::is_pointer<PointerType>::value, int>::type = 0>
- constexpr const PointerType get() const noexcept
- {
- // delegate the call to get_ptr
- return get_ptr<PointerType>();
- }
-
- /*!
- @brief get a pointer value (implicit)
-
- Implicit pointer access to the internally stored JSON value. No copies are
- made.
-
- @warning Writing data to the pointee of the result yields an undefined
- state.
-
- @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
- object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
- @ref number_unsigned_t, or @ref number_float_t. Enforced by a static
- assertion.
-
- @return pointer to the internally stored JSON value if the requested
- pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
-
- @complexity Constant.
-
- @liveexample{The example below shows how pointers to internal values of a
- JSON value can be requested. Note that no type conversions are made and a
- `nullptr` is returned if the value and the requested pointer type does not
- match.,get_ptr}
-
- @since version 1.0.0
- */
- template<typename PointerType, typename std::enable_if<
- std::is_pointer<PointerType>::value, int>::type = 0>
- PointerType get_ptr() noexcept
- {
- // get the type of the PointerType (remove pointer and const)
- using pointee_t = typename std::remove_const<typename
- std::remove_pointer<typename
- std::remove_const<PointerType>::type>::type>::type;
- // make sure the type matches the allowed types
- static_assert(
- std::is_same<object_t, pointee_t>::value
- or std::is_same<array_t, pointee_t>::value
- or std::is_same<string_t, pointee_t>::value
- or std::is_same<boolean_t, pointee_t>::value
- or std::is_same<number_integer_t, pointee_t>::value
- or std::is_same<number_unsigned_t, pointee_t>::value
- or std::is_same<number_float_t, pointee_t>::value
- , "incompatible pointer type");
-
- // delegate the call to get_impl_ptr<>()
- return get_impl_ptr(static_cast<PointerType>(nullptr));
- }
-
- /*!
- @brief get a pointer value (implicit)
- @copydoc get_ptr()
- */
- template<typename PointerType, typename std::enable_if<
- std::is_pointer<PointerType>::value and
- std::is_const<typename std::remove_pointer<PointerType>::type>::value, int>::type = 0>
- constexpr const PointerType get_ptr() const noexcept
- {
- // get the type of the PointerType (remove pointer and const)
- using pointee_t = typename std::remove_const<typename
- std::remove_pointer<typename
- std::remove_const<PointerType>::type>::type>::type;
- // make sure the type matches the allowed types
- static_assert(
- std::is_same<object_t, pointee_t>::value
- or std::is_same<array_t, pointee_t>::value
- or std::is_same<string_t, pointee_t>::value
- or std::is_same<boolean_t, pointee_t>::value
- or std::is_same<number_integer_t, pointee_t>::value
- or std::is_same<number_unsigned_t, pointee_t>::value
- or std::is_same<number_float_t, pointee_t>::value
- , "incompatible pointer type");
-
- // delegate the call to get_impl_ptr<>() const
- return get_impl_ptr(static_cast<const PointerType>(nullptr));
- }
-
- /*!
- @brief get a reference value (implicit)
-
- Implicit reference access to the internally stored JSON value. No copies
- are made.
-
- @warning Writing data to the referee of the result yields an undefined
- state.
-
- @tparam ReferenceType reference type; must be a reference to @ref array_t,
- @ref object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or
- @ref number_float_t. Enforced by static assertion.
-
- @return reference to the internally stored JSON value if the requested
- reference type @a ReferenceType fits to the JSON value; throws
- std::domain_error otherwise
-
- @throw std::domain_error in case passed type @a ReferenceType is
- incompatible with the stored JSON value
-
- @complexity Constant.
-
- @liveexample{The example shows several calls to `get_ref()`.,get_ref}
-
- @since version 1.1.0
- */
- template<typename ReferenceType, typename std::enable_if<
- std::is_reference<ReferenceType>::value, int>::type = 0>
- ReferenceType get_ref()
- {
- // delegate call to get_ref_impl
- return get_ref_impl<ReferenceType>(*this);
- }
-
- /*!
- @brief get a reference value (implicit)
- @copydoc get_ref()
- */
- template<typename ReferenceType, typename std::enable_if<
- std::is_reference<ReferenceType>::value and
- std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int>::type = 0>
- ReferenceType get_ref() const
- {
- // delegate call to get_ref_impl
- return get_ref_impl<ReferenceType>(*this);
- }
-
- /*!
- @brief get a value (implicit)
-
- Implicit type conversion between the JSON value and a compatible value.
- The call is realized by calling @ref get() const.
-
- @tparam ValueType non-pointer type compatible to the JSON value, for
- instance `int` for JSON integer numbers, `bool` for JSON booleans, or
- `std::vector` types for JSON arrays. The character type of @ref string_t
- as well as an initializer list of this type is excluded to avoid
- ambiguities as these types implicitly convert to `std::string`.
-
- @return copy of the JSON value, converted to type @a ValueType
-
- @throw std::domain_error in case passed type @a ValueType is incompatible
- to JSON, thrown by @ref get() const
-
- @complexity Linear in the size of the JSON value.
-
- @liveexample{The example below shows several conversions from JSON values
- to other types. There a few things to note: (1) Floating-point numbers can
- be converted to integers\, (2) A JSON array can be converted to a standard
- `std::vector<short>`\, (3) A JSON object can be converted to C++
- associative containers such as `std::unordered_map<std::string\,
- json>`.,operator__ValueType}
-
- @since version 1.0.0
- */
- template < typename ValueType, typename std::enable_if <
- not std::is_pointer<ValueType>::value and
- not std::is_same<ValueType, typename string_t::value_type>::value
-#ifndef _MSC_VER // fix for issue #167 operator<< ambiguity under VS2015
- and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
-#endif
- , int >::type = 0 >
- operator ValueType() const
- {
- // delegate the call to get<>() const
- return get<ValueType>();
- }
-
- /// @}
-
-
- ////////////////////
- // element access //
- ////////////////////
-
- /// @name element access
- /// Access to the JSON value.
- /// @{
-
- /*!
- @brief access specified array element with bounds checking
-
- Returns a reference to the element at specified location @a idx, with
- bounds checking.
-
- @param[in] idx index of the element to access
-
- @return reference to the element at index @a idx
-
- @throw std::domain_error if the JSON value is not an array; example:
- `"cannot use at() with string"`
- @throw std::out_of_range if the index @a idx is out of range of the array;
- that is, `idx >= size()`; example: `"array index 7 is out of range"`
-
- @complexity Constant.
-
- @liveexample{The example below shows how array elements can be read and
- written using `at()`.,at__size_type}
-
- @since version 1.0.0
- */
- reference at(size_type idx)
- {
- // at only works for arrays
- if (is_array())
- {
- JSON_TRY
- {
- return m_value.array->at(idx);
- }
- JSON_CATCH (std::out_of_range&)
- {
- // create better exception explanation
- JSON_THROW(std::out_of_range("array index " + std::to_string(idx) + " is out of range"));
- }
- }
- else
- {
- JSON_THROW(std::domain_error("cannot use at() with " + type_name()));
- }
- }
-
- /*!
- @brief access specified array element with bounds checking
-
- Returns a const reference to the element at specified location @a idx,
- with bounds checking.
-
- @param[in] idx index of the element to access
-
- @return const reference to the element at index @a idx
-
- @throw std::domain_error if the JSON value is not an array; example:
- `"cannot use at() with string"`
- @throw std::out_of_range if the index @a idx is out of range of the array;
- that is, `idx >= size()`; example: `"array index 7 is out of range"`
-
- @complexity Constant.
-
- @liveexample{The example below shows how array elements can be read using
- `at()`.,at__size_type_const}
-
- @since version 1.0.0
- */
- const_reference at(size_type idx) const
- {
- // at only works for arrays
- if (is_array())
- {
- JSON_TRY
- {
- return m_value.array->at(idx);
- }
- JSON_CATCH (std::out_of_range&)
- {
- // create better exception explanation
- JSON_THROW(std::out_of_range("array index " + std::to_string(idx) + " is out of range"));
- }
- }
- else
- {
- JSON_THROW(std::domain_error("cannot use at() with " + type_name()));
- }
- }
-
- /*!
- @brief access specified object element with bounds checking
-
- Returns a reference to the element at with specified key @a key, with
- bounds checking.
-
- @param[in] key key of the element to access
-
- @return reference to the element at key @a key
-
- @throw std::domain_error if the JSON value is not an object; example:
- `"cannot use at() with boolean"`
- @throw std::out_of_range if the key @a key is is not stored in the object;
- that is, `find(key) == end()`; example: `"key "the fast" not found"`
-
- @complexity Logarithmic in the size of the container.
-
- @liveexample{The example below shows how object elements can be read and
- written using `at()`.,at__object_t_key_type}
-
- @sa @ref operator[](const typename object_t::key_type&) for unchecked
- access by reference
- @sa @ref value() for access by value with a default value
-
- @since version 1.0.0
- */
- reference at(const typename object_t::key_type& key)
- {
- // at only works for objects
- if (is_object())
- {
- JSON_TRY
- {
- return m_value.object->at(key);
- }
- JSON_CATCH (std::out_of_range&)
- {
- // create better exception explanation
- JSON_THROW(std::out_of_range("key '" + key + "' not found"));
- }
- }
- else
- {
- JSON_THROW(std::domain_error("cannot use at() with " + type_name()));
- }
- }
-
- /*!
- @brief access specified object element with bounds checking
-
- Returns a const reference to the element at with specified key @a key,
- with bounds checking.
-
- @param[in] key key of the element to access
-
- @return const reference to the element at key @a key
-
- @throw std::domain_error if the JSON value is not an object; example:
- `"cannot use at() with boolean"`
- @throw std::out_of_range if the key @a key is is not stored in the object;
- that is, `find(key) == end()`; example: `"key "the fast" not found"`
-
- @complexity Logarithmic in the size of the container.
-
- @liveexample{The example below shows how object elements can be read using
- `at()`.,at__object_t_key_type_const}
-
- @sa @ref operator[](const typename object_t::key_type&) for unchecked
- access by reference
- @sa @ref value() for access by value with a default value
-
- @since version 1.0.0
- */
- const_reference at(const typename object_t::key_type& key) const
- {
- // at only works for objects
- if (is_object())
- {
- JSON_TRY
- {
- return m_value.object->at(key);
- }
- JSON_CATCH (std::out_of_range&)
- {
- // create better exception explanation
- JSON_THROW(std::out_of_range("key '" + key + "' not found"));
- }
- }
- else
- {
- JSON_THROW(std::domain_error("cannot use at() with " + type_name()));
- }
- }
-
- /*!
- @brief access specified array element
-
- Returns a reference to the element at specified location @a idx.
-
- @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),
- then the array is silently filled up with `null` values to make `idx` a
- valid reference to the last stored element.
-
- @param[in] idx index of the element to access
-
- @return reference to the element at index @a idx
-
- @throw std::domain_error if JSON is not an array or null; example:
- `"cannot use operator[] with string"`
-
- @complexity Constant if @a idx is in the range of the array. Otherwise
- linear in `idx - size()`.
-
- @liveexample{The example below shows how array elements can be read and
- written using `[]` operator. Note the addition of `null`
- values.,operatorarray__size_type}
-
- @since version 1.0.0
- */
- reference operator[](size_type idx)
- {
- // implicitly convert null value to an empty array
- if (is_null())
- {
- m_type = value_t::array;
- m_value.array = create<array_t>();
- assert_invariant();
- }
-
- // operator[] only works for arrays
- if (is_array())
- {
- // fill up array with null values if given idx is outside range
- if (idx >= m_value.array->size())
- {
- m_value.array->insert(m_value.array->end(),
- idx - m_value.array->size() + 1,
- basic_json());
- }
-
- return m_value.array->operator[](idx);
- }
-
- JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));
- }
-
- /*!
- @brief access specified array element
-
- Returns a const reference to the element at specified location @a idx.
-
- @param[in] idx index of the element to access
-
- @return const reference to the element at index @a idx
-
- @throw std::domain_error if JSON is not an array; example: `"cannot use
- operator[] with null"`
-
- @complexity Constant.
-
- @liveexample{The example below shows how array elements can be read using
- the `[]` operator.,operatorarray__size_type_const}
-
- @since version 1.0.0
- */
- const_reference operator[](size_type idx) const
- {
- // const operator[] only works for arrays
- if (is_array())
- {
- return m_value.array->operator[](idx);
- }
-
- JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));
- }
-
- /*!
- @brief access specified object element
-
- Returns a reference to the element at with specified key @a key.
-
- @note If @a key is not found in the object, then it is silently added to
- the object and filled with a `null` value to make `key` a valid reference.
- In case the value was `null` before, it is converted to an object.
-
- @param[in] key key of the element to access
-
- @return reference to the element at key @a key
-
- @throw std::domain_error if JSON is not an object or null; example:
- `"cannot use operator[] with string"`
-
- @complexity Logarithmic in the size of the container.
-
- @liveexample{The example below shows how object elements can be read and
- written using the `[]` operator.,operatorarray__key_type}
-
- @sa @ref at(const typename object_t::key_type&) for access by reference
- with range checking
- @sa @ref value() for access by value with a default value
-
- @since version 1.0.0
- */
- reference operator[](const typename object_t::key_type& key)
- {
- // implicitly convert null value to an empty object
- if (is_null())
- {
- m_type = value_t::object;
- m_value.object = create<object_t>();
- assert_invariant();
- }
-
- // operator[] only works for objects
- if (is_object())
- {
- return m_value.object->operator[](key);
- }
-
- JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));
- }
-
- /*!
- @brief read-only access specified object element
-
- Returns a const reference to the element at with specified key @a key. No
- bounds checking is performed.
-
- @warning If the element with key @a key does not exist, the behavior is
- undefined.
-
- @param[in] key key of the element to access
-
- @return const reference to the element at key @a key
-
- @pre The element with key @a key must exist. **This precondition is
- enforced with an assertion.**
-
- @throw std::domain_error if JSON is not an object; example: `"cannot use
- operator[] with null"`
-
- @complexity Logarithmic in the size of the container.
-
- @liveexample{The example below shows how object elements can be read using
- the `[]` operator.,operatorarray__key_type_const}
-
- @sa @ref at(const typename object_t::key_type&) for access by reference
- with range checking
- @sa @ref value() for access by value with a default value
-
- @since version 1.0.0
- */
- const_reference operator[](const typename object_t::key_type& key) const
- {
- // const operator[] only works for objects
- if (is_object())
- {
- assert(m_value.object->find(key) != m_value.object->end());
- return m_value.object->find(key)->second;
- }
-
- JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));
- }
-
- /*!
- @brief access specified object element
-
- Returns a reference to the element at with specified key @a key.
-
- @note If @a key is not found in the object, then it is silently added to
- the object and filled with a `null` value to make `key` a valid reference.
- In case the value was `null` before, it is converted to an object.
-
- @param[in] key key of the element to access
-
- @return reference to the element at key @a key
-
- @throw std::domain_error if JSON is not an object or null; example:
- `"cannot use operator[] with string"`
-
- @complexity Logarithmic in the size of the container.
-
- @liveexample{The example below shows how object elements can be read and
- written using the `[]` operator.,operatorarray__key_type}
-
- @sa @ref at(const typename object_t::key_type&) for access by reference
- with range checking
- @sa @ref value() for access by value with a default value
-
- @since version 1.0.0
- */
- template<typename T, std::size_t n>
- reference operator[](T * (&key)[n])
- {
- return operator[](static_cast<const T>(key));
- }
-
- /*!
- @brief read-only access specified object element
-
- Returns a const reference to the element at with specified key @a key. No
- bounds checking is performed.
-
- @warning If the element with key @a key does not exist, the behavior is
- undefined.
-
- @note This function is required for compatibility reasons with Clang.
-
- @param[in] key key of the element to access
-
- @return const reference to the element at key @a key
-
- @throw std::domain_error if JSON is not an object; example: `"cannot use
- operator[] with null"`
-
- @complexity Logarithmic in the size of the container.
-
- @liveexample{The example below shows how object elements can be read using
- the `[]` operator.,operatorarray__key_type_const}
-
- @sa @ref at(const typename object_t::key_type&) for access by reference
- with range checking
- @sa @ref value() for access by value with a default value
-
- @since version 1.0.0
- */
- template<typename T, std::size_t n>
- const_reference operator[](T * (&key)[n]) const
- {
- return operator[](static_cast<const T>(key));
- }
-
- /*!
- @brief access specified object element
-
- Returns a reference to the element at with specified key @a key.
-
- @note If @a key is not found in the object, then it is silently added to
- the object and filled with a `null` value to make `key` a valid reference.
- In case the value was `null` before, it is converted to an object.
-
- @param[in] key key of the element to access
-
- @return reference to the element at key @a key
-
- @throw std::domain_error if JSON is not an object or null; example:
- `"cannot use operator[] with string"`
-
- @complexity Logarithmic in the size of the container.
-
- @liveexample{The example below shows how object elements can be read and
- written using the `[]` operator.,operatorarray__key_type}
-
- @sa @ref at(const typename object_t::key_type&) for access by reference
- with range checking
- @sa @ref value() for access by value with a default value
-
- @since version 1.1.0
- */
- template<typename T>
- reference operator[](T* key)
- {
- // implicitly convert null to object
- if (is_null())
- {
- m_type = value_t::object;
- m_value = value_t::object;
- assert_invariant();
- }
-
- // at only works for objects
- if (is_object())
- {
- return m_value.object->operator[](key);
- }
-
- JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));
- }
-
- /*!
- @brief read-only access specified object element
-
- Returns a const reference to the element at with specified key @a key. No
- bounds checking is performed.
-
- @warning If the element with key @a key does not exist, the behavior is
- undefined.
-
- @param[in] key key of the element to access
-
- @return const reference to the element at key @a key
-
- @pre The element with key @a key must exist. **This precondition is
- enforced with an assertion.**
-
- @throw std::domain_error if JSON is not an object; example: `"cannot use
- operator[] with null"`
-
- @complexity Logarithmic in the size of the container.
-
- @liveexample{The example below shows how object elements can be read using
- the `[]` operator.,operatorarray__key_type_const}
-
- @sa @ref at(const typename object_t::key_type&) for access by reference
- with range checking
- @sa @ref value() for access by value with a default value
-
- @since version 1.1.0
- */
- template<typename T>
- const_reference operator[](T* key) const
- {
- // at only works for objects
- if (is_object())
- {
- assert(m_value.object->find(key) != m_value.object->end());
- return m_value.object->find(key)->second;
- }
-
- JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));
- }
-
- /*!
- @brief access specified object element with default value
-
- Returns either a copy of an object's element at the specified key @a key
- or a given default value if no element with key @a key exists.
-
- The function is basically equivalent to executing
- @code {.cpp}
- try {
- return at(key);
- } catch(std::out_of_range) {
- return default_value;
- }
- @endcode
-
- @note Unlike @ref at(const typename object_t::key_type&), this function
- does not throw if the given key @a key was not found.
-
- @note Unlike @ref operator[](const typename object_t::key_type& key), this
- function does not implicitly add an element to the position defined by @a
- key. This function is furthermore also applicable to const objects.
-
- @param[in] key key of the element to access
- @param[in] default_value the value to return if @a key is not found
-
- @tparam ValueType type compatible to JSON values, for instance `int` for
- JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
- JSON arrays. Note the type of the expected value at @a key and the default
- value @a default_value must be compatible.
-
- @return copy of the element at key @a key or @a default_value if @a key
- is not found
-
- @throw std::domain_error if JSON is not an object; example: `"cannot use
- value() with null"`
-
- @complexity Logarithmic in the size of the container.
-
- @liveexample{The example below shows how object elements can be queried
- with a default value.,basic_json__value}
-
- @sa @ref at(const typename object_t::key_type&) for access by reference
- with range checking
- @sa @ref operator[](const typename object_t::key_type&) for unchecked
- access by reference
-
- @since version 1.0.0
- */
- template<class ValueType, typename std::enable_if<
- std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
- ValueType value(const typename object_t::key_type& key, ValueType default_value) const
- {
- // at only works for objects
- if (is_object())
- {
- // if key is found, return value and given default value otherwise
- const auto it = find(key);
- if (it != end())
- {
- return *it;
- }
-
- return default_value;
- }
- else
- {
- JSON_THROW(std::domain_error("cannot use value() with " + type_name()));
- }
- }
-
- /*!
- @brief overload for a default value of type const char*
- @copydoc basic_json::value(const typename object_t::key_type&, ValueType) const
- */
- string_t value(const typename object_t::key_type& key, const char* default_value) const
- {
- return value(key, string_t(default_value));
- }
-
- /*!
- @brief access specified object element via JSON Pointer with default value
-
- Returns either a copy of an object's element at the specified key @a key
- or a given default value if no element with key @a key exists.
-
- The function is basically equivalent to executing
- @code {.cpp}
- try {
- return at(ptr);
- } catch(std::out_of_range) {
- return default_value;
- }
- @endcode
-
- @note Unlike @ref at(const json_pointer&), this function does not throw
- if the given key @a key was not found.
-
- @param[in] ptr a JSON pointer to the element to access
- @param[in] default_value the value to return if @a ptr found no value
-
- @tparam ValueType type compatible to JSON values, for instance `int` for
- JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
- JSON arrays. Note the type of the expected value at @a key and the default
- value @a default_value must be compatible.
-
- @return copy of the element at key @a key or @a default_value if @a key
- is not found
-
- @throw std::domain_error if JSON is not an object; example: `"cannot use
- value() with null"`
-
- @complexity Logarithmic in the size of the container.
-
- @liveexample{The example below shows how object elements can be queried
- with a default value.,basic_json__value_ptr}
-
- @sa @ref operator[](const json_pointer&) for unchecked access by reference
-
- @since version 2.0.2
- */
- template<class ValueType, typename std::enable_if<
- std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
- ValueType value(const json_pointer& ptr, ValueType default_value) const
- {
- // at only works for objects
- if (is_object())
- {
- // if pointer resolves a value, return it or use default value
- JSON_TRY
- {
- return ptr.get_checked(this);
- }
- JSON_CATCH (std::out_of_range&)
- {
- return default_value;
- }
- }
-
- JSON_THROW(std::domain_error("cannot use value() with " + type_name()));
- }
-
- /*!
- @brief overload for a default value of type const char*
- @copydoc basic_json::value(const json_pointer&, ValueType) const
- */
- string_t value(const json_pointer& ptr, const char* default_value) const
- {
- return value(ptr, string_t(default_value));
- }
-
- /*!
- @brief access the first element
-
- Returns a reference to the first element in the container. For a JSON
- container `c`, the expression `c.front()` is equivalent to `*c.begin()`.
-
- @return In case of a structured type (array or object), a reference to the
- first element is returned. In case of number, string, or boolean values, a
- reference to the value is returned.
-
- @complexity Constant.
-
- @pre The JSON value must not be `null` (would throw `std::out_of_range`)
- or an empty array or object (undefined behavior, **guarded by
- assertions**).
- @post The JSON value remains unchanged.
-
- @throw std::out_of_range when called on `null` value
-
- @liveexample{The following code shows an example for `front()`.,front}
-
- @sa @ref back() -- access the last element
-
- @since version 1.0.0
- */
- reference front()
- {
- return *begin();
- }
-
- /*!
- @copydoc basic_json::front()
- */
- const_reference front() const
- {
- return *cbegin();
- }
-
- /*!
- @brief access the last element
-
- Returns a reference to the last element in the container. For a JSON
- container `c`, the expression `c.back()` is equivalent to
- @code {.cpp}
- auto tmp = c.end();
- --tmp;
- return *tmp;
- @endcode
-
- @return In case of a structured type (array or object), a reference to the
- last element is returned. In case of number, string, or boolean values, a
- reference to the value is returned.
-
- @complexity Constant.
-
- @pre The JSON value must not be `null` (would throw `std::out_of_range`)
- or an empty array or object (undefined behavior, **guarded by
- assertions**).
- @post The JSON value remains unchanged.
-
- @throw std::out_of_range when called on `null` value.
-
- @liveexample{The following code shows an example for `back()`.,back}
-
- @sa @ref front() -- access the first element
-
- @since version 1.0.0
- */
- reference back()
- {
- auto tmp = end();
- --tmp;
- return *tmp;
- }
-
- /*!
- @copydoc basic_json::back()
- */
- const_reference back() const
- {
- auto tmp = cend();
- --tmp;
- return *tmp;
- }
-
- /*!
- @brief remove element given an iterator
-
- Removes the element specified by iterator @a pos. The iterator @a pos must
- be valid and dereferenceable. Thus the `end()` iterator (which is valid,
- but is not dereferenceable) cannot be used as a value for @a pos.
-
- If called on a primitive type other than `null`, the resulting JSON value
- will be `null`.
-
- @param[in] pos iterator to the element to remove
- @return Iterator following the last removed element. If the iterator @a
- pos refers to the last element, the `end()` iterator is returned.
-
- @tparam IteratorType an @ref iterator or @ref const_iterator
-
- @post Invalidates iterators and references at or after the point of the
- erase, including the `end()` iterator.
-
- @throw std::domain_error if called on a `null` value; example: `"cannot
- use erase() with null"`
- @throw std::domain_error if called on an iterator which does not belong to
- the current JSON value; example: `"iterator does not fit current value"`
- @throw std::out_of_range if called on a primitive type with invalid
- iterator (i.e., any iterator which is not `begin()`); example: `"iterator
- out of range"`
-
- @complexity The complexity depends on the type:
- - objects: amortized constant
- - arrays: linear in distance between @a pos and the end of the container
- - strings: linear in the length of the string
- - other types: constant
-
- @liveexample{The example shows the result of `erase()` for different JSON
- types.,erase__IteratorType}
-
- @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
- the given range
- @sa @ref erase(const typename object_t::key_type&) -- removes the element
- from an object at the given key
- @sa @ref erase(const size_type) -- removes the element from an array at
- the given index
-
- @since version 1.0.0
- */
- template<class IteratorType, typename std::enable_if<
- std::is_same<IteratorType, typename basic_json_t::iterator>::value or
- std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
- = 0>
- IteratorType erase(IteratorType pos)
- {
- // make sure iterator fits the current value
- if (this != pos.m_object)
- {
- JSON_THROW(std::domain_error("iterator does not fit current value"));
- }
-
- IteratorType result = end();
-
- switch (m_type)
- {
- case value_t::boolean:
- case value_t::number_float:
- case value_t::number_integer:
- case value_t::number_unsigned:
- case value_t::string:
- {
- if (not pos.m_it.primitive_iterator.is_begin())
- {
- JSON_THROW(std::out_of_range("iterator out of range"));
- }
-
- if (is_string())
- {
- AllocatorType<string_t> alloc;
- alloc.destroy(m_value.string);
- alloc.deallocate(m_value.string, 1);
- m_value.string = nullptr;
- }
-
- m_type = value_t::null;
- assert_invariant();
- break;
- }
-
- case value_t::object:
- {
- result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
- break;
- }
-
- case value_t::array:
- {
- result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
- break;
- }
-
- default:
- {
- JSON_THROW(std::domain_error("cannot use erase() with " + type_name()));
- }
- }
-
- return result;
- }
-
- /*!
- @brief remove elements given an iterator range
-
- Removes the element specified by the range `[first; last)`. The iterator
- @a first does not need to be dereferenceable if `first == last`: erasing
- an empty range is a no-op.
-
- If called on a primitive type other than `null`, the resulting JSON value
- will be `null`.
-
- @param[in] first iterator to the beginning of the range to remove
- @param[in] last iterator past the end of the range to remove
- @return Iterator following the last removed element. If the iterator @a
- second refers to the last element, the `end()` iterator is returned.
-
- @tparam IteratorType an @ref iterator or @ref const_iterator
-
- @post Invalidates iterators and references at or after the point of the
- erase, including the `end()` iterator.
-
- @throw std::domain_error if called on a `null` value; example: `"cannot
- use erase() with null"`
- @throw std::domain_error if called on iterators which does not belong to
- the current JSON value; example: `"iterators do not fit current value"`
- @throw std::out_of_range if called on a primitive type with invalid
- iterators (i.e., if `first != begin()` and `last != end()`); example:
- `"iterators out of range"`
-
- @complexity The complexity depends on the type:
- - objects: `log(size()) + std::distance(first, last)`
- - arrays: linear in the distance between @a first and @a last, plus linear
- in the distance between @a last and end of the container
- - strings: linear in the length of the string
- - other types: constant
-
- @liveexample{The example shows the result of `erase()` for different JSON
- types.,erase__IteratorType_IteratorType}
-
- @sa @ref erase(IteratorType) -- removes the element at a given position
- @sa @ref erase(const typename object_t::key_type&) -- removes the element
- from an object at the given key
- @sa @ref erase(const size_type) -- removes the element from an array at
- the given index
-
- @since version 1.0.0
- */
- template<class IteratorType, typename std::enable_if<
- std::is_same<IteratorType, typename basic_json_t::iterator>::value or
- std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
- = 0>
- IteratorType erase(IteratorType first, IteratorType last)
- {
- // make sure iterator fits the current value
- if (this != first.m_object or this != last.m_object)
- {
- JSON_THROW(std::domain_error("iterators do not fit current value"));
- }
-
- IteratorType result = end();
-
- switch (m_type)
- {
- case value_t::boolean:
- case value_t::number_float:
- case value_t::number_integer:
- case value_t::number_unsigned:
- case value_t::string:
- {
- if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())
- {
- JSON_THROW(std::out_of_range("iterators out of range"));
- }
-
- if (is_string())
- {
- AllocatorType<string_t> alloc;
- alloc.destroy(m_value.string);
- alloc.deallocate(m_value.string, 1);
- m_value.string = nullptr;
- }
-
- m_type = value_t::null;
- assert_invariant();
- break;
- }
-
- case value_t::object:
- {
- result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
- last.m_it.object_iterator);
- break;
- }
-
- case value_t::array:
- {
- result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
- last.m_it.array_iterator);
- break;
- }
-
- default:
- {
- JSON_THROW(std::domain_error("cannot use erase() with " + type_name()));
- }
- }
-
- return result;
- }
-
- /*!
- @brief remove element from a JSON object given a key
-
- Removes elements from a JSON object with the key value @a key.
-
- @param[in] key value of the elements to remove
-
- @return Number of elements removed. If @a ObjectType is the default
- `std::map` type, the return value will always be `0` (@a key was not
- found) or `1` (@a key was found).
-
- @post References and iterators to the erased elements are invalidated.
- Other references and iterators are not affected.
-
- @throw std::domain_error when called on a type other than JSON object;
- example: `"cannot use erase() with null"`
-
- @complexity `log(size()) + count(key)`
-
- @liveexample{The example shows the effect of `erase()`.,erase__key_type}
-
- @sa @ref erase(IteratorType) -- removes the element at a given position
- @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
- the given range
- @sa @ref erase(const size_type) -- removes the element from an array at
- the given index
-
- @since version 1.0.0
- */
- size_type erase(const typename object_t::key_type& key)
- {
- // this erase only works for objects
- if (is_object())
- {
- return m_value.object->erase(key);
- }
-
- JSON_THROW(std::domain_error("cannot use erase() with " + type_name()));
- }
-
- /*!
- @brief remove element from a JSON array given an index
-
- Removes element from a JSON array at the index @a idx.
-
- @param[in] idx index of the element to remove
-
- @throw std::domain_error when called on a type other than JSON array;
- example: `"cannot use erase() with null"`
- @throw std::out_of_range when `idx >= size()`; example: `"array index 17
- is out of range"`
-
- @complexity Linear in distance between @a idx and the end of the container.
-
- @liveexample{The example shows the effect of `erase()`.,erase__size_type}
-
- @sa @ref erase(IteratorType) -- removes the element at a given position
- @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
- the given range
- @sa @ref erase(const typename object_t::key_type&) -- removes the element
- from an object at the given key
-
- @since version 1.0.0
- */
- void erase(const size_type idx)
- {
- // this erase only works for arrays
- if (is_array())
- {
- if (idx >= size())
- {
- JSON_THROW(std::out_of_range("array index " + std::to_string(idx) + " is out of range"));
- }
-
- m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
- }
- else
- {
- JSON_THROW(std::domain_error("cannot use erase() with " + type_name()));
- }
- }
-
- /// @}
-
-
- ////////////
- // lookup //
- ////////////
-
- /// @name lookup
- /// @{
-
- /*!
- @brief find an element in a JSON object
-
- Finds an element in a JSON object with key equivalent to @a key. If the
- element is not found or the JSON value is not an object, end() is
- returned.
-
- @note This method always returns @ref end() when executed on a JSON type
- that is not an object.
-
- @param[in] key key value of the element to search for
-
- @return Iterator to an element with key equivalent to @a key. If no such
- element is found or the JSON value is not an object, past-the-end (see
- @ref end()) iterator is returned.
-
- @complexity Logarithmic in the size of the JSON object.
-
- @liveexample{The example shows how `find()` is used.,find__key_type}
-
- @since version 1.0.0
- */
- iterator find(typename object_t::key_type key)
- {
- auto result = end();
-
- if (is_object())
- {
- result.m_it.object_iterator = m_value.object->find(key);
- }
-
- return result;
- }
-
- /*!
- @brief find an element in a JSON object
- @copydoc find(typename object_t::key_type)
- */
- const_iterator find(typename object_t::key_type key) const
- {
- auto result = cend();
-
- if (is_object())
- {
- result.m_it.object_iterator = m_value.object->find(key);
- }
-
- return result;
- }
-
- /*!
- @brief returns the number of occurrences of a key in a JSON object
-
- Returns the number of elements with key @a key. If ObjectType is the
- default `std::map` type, the return value will always be `0` (@a key was
- not found) or `1` (@a key was found).
-
- @note This method always returns `0` when executed on a JSON type that is
- not an object.
-
- @param[in] key key value of the element to count
-
- @return Number of elements with key @a key. If the JSON value is not an
- object, the return value will be `0`.
-
- @complexity Logarithmic in the size of the JSON object.
-
- @liveexample{The example shows how `count()` is used.,count}
-
- @since version 1.0.0
- */
- size_type count(typename object_t::key_type key) const
- {
- // return 0 for all nonobject types
- return is_object() ? m_value.object->count(key) : 0;
- }
-
- /// @}
-
-
- ///////////////
- // iterators //
- ///////////////
-
- /// @name iterators
- /// @{
-
- /*!
- @brief returns an iterator to the first element
-
- Returns an iterator to the first element.
-
- @image html range-begin-end.svg "Illustration from cppreference.com"
-
- @return iterator to the first element
-
- @complexity Constant.
-
- @requirement This function helps `basic_json` satisfying the
- [Container](http://en.cppreference.com/w/cpp/concept/Container)
- requirements:
- - The complexity is constant.
-
- @liveexample{The following code shows an example for `begin()`.,begin}
-
- @sa @ref cbegin() -- returns a const iterator to the beginning
- @sa @ref end() -- returns an iterator to the end
- @sa @ref cend() -- returns a const iterator to the end
-
- @since version 1.0.0
- */
- iterator begin() noexcept
- {
- iterator result(this);
- result.set_begin();
- return result;
- }
-
- /*!
- @copydoc basic_json::cbegin()
- */
- const_iterator begin() const noexcept
- {
- return cbegin();
- }
-
- /*!
- @brief returns a const iterator to the first element
-
- Returns a const iterator to the first element.
-
- @image html range-begin-end.svg "Illustration from cppreference.com"
-
- @return const iterator to the first element
-
- @complexity Constant.
-
- @requirement This function helps `basic_json` satisfying the
- [Container](http://en.cppreference.com/w/cpp/concept/Container)
- requirements:
- - The complexity is constant.
- - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.
-
- @liveexample{The following code shows an example for `cbegin()`.,cbegin}
-
- @sa @ref begin() -- returns an iterator to the beginning
- @sa @ref end() -- returns an iterator to the end
- @sa @ref cend() -- returns a const iterator to the end
-
- @since version 1.0.0
- */
- const_iterator cbegin() const noexcept
- {
- const_iterator result(this);
- result.set_begin();
- return result;
- }
-
- /*!
- @brief returns an iterator to one past the last element
-
- Returns an iterator to one past the last element.
-
- @image html range-begin-end.svg "Illustration from cppreference.com"
-
- @return iterator one past the last element
-
- @complexity Constant.
-
- @requirement This function helps `basic_json` satisfying the
- [Container](http://en.cppreference.com/w/cpp/concept/Container)
- requirements:
- - The complexity is constant.
-
- @liveexample{The following code shows an example for `end()`.,end}
-
- @sa @ref cend() -- returns a const iterator to the end
- @sa @ref begin() -- returns an iterator to the beginning
- @sa @ref cbegin() -- returns a const iterator to the beginning
-
- @since version 1.0.0
- */
- iterator end() noexcept
- {
- iterator result(this);
- result.set_end();
- return result;
- }
-
- /*!
- @copydoc basic_json::cend()
- */
- const_iterator end() const noexcept
- {
- return cend();
- }
-
- /*!
- @brief returns a const iterator to one past the last element
-
- Returns a const iterator to one past the last element.
-
- @image html range-begin-end.svg "Illustration from cppreference.com"
-
- @return const iterator one past the last element
-
- @complexity Constant.
-
- @requirement This function helps `basic_json` satisfying the
- [Container](http://en.cppreference.com/w/cpp/concept/Container)
- requirements:
- - The complexity is constant.
- - Has the semantics of `const_cast<const basic_json&>(*this).end()`.
-
- @liveexample{The following code shows an example for `cend()`.,cend}
-
- @sa @ref end() -- returns an iterator to the end
- @sa @ref begin() -- returns an iterator to the beginning
- @sa @ref cbegin() -- returns a const iterator to the beginning
-
- @since version 1.0.0
- */
- const_iterator cend() const noexcept
- {
- const_iterator result(this);
- result.set_end();
- return result;
- }
-
- /*!
- @brief returns an iterator to the reverse-beginning
-
- Returns an iterator to the reverse-beginning; that is, the last element.
-
- @image html range-rbegin-rend.svg "Illustration from cppreference.com"
-
- @complexity Constant.
-
- @requirement This function helps `basic_json` satisfying the
- [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
- requirements:
- - The complexity is constant.
- - Has the semantics of `reverse_iterator(end())`.
-
- @liveexample{The following code shows an example for `rbegin()`.,rbegin}
-
- @sa @ref crbegin() -- returns a const reverse iterator to the beginning
- @sa @ref rend() -- returns a reverse iterator to the end
- @sa @ref crend() -- returns a const reverse iterator to the end
-
- @since version 1.0.0
- */
- reverse_iterator rbegin() noexcept
- {
- return reverse_iterator(end());
- }
-
- /*!
- @copydoc basic_json::crbegin()
- */
- const_reverse_iterator rbegin() const noexcept
- {
- return crbegin();
- }
-
- /*!
- @brief returns an iterator to the reverse-end
-
- Returns an iterator to the reverse-end; that is, one before the first
- element.
-
- @image html range-rbegin-rend.svg "Illustration from cppreference.com"
-
- @complexity Constant.
-
- @requirement This function helps `basic_json` satisfying the
- [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
- requirements:
- - The complexity is constant.
- - Has the semantics of `reverse_iterator(begin())`.
-
- @liveexample{The following code shows an example for `rend()`.,rend}
-
- @sa @ref crend() -- returns a const reverse iterator to the end
- @sa @ref rbegin() -- returns a reverse iterator to the beginning
- @sa @ref crbegin() -- returns a const reverse iterator to the beginning
-
- @since version 1.0.0
- */
- reverse_iterator rend() noexcept
- {
- return reverse_iterator(begin());
- }
-
- /*!
- @copydoc basic_json::crend()
- */
- const_reverse_iterator rend() const noexcept
- {
- return crend();
- }
-
- /*!
- @brief returns a const reverse iterator to the last element
-
- Returns a const iterator to the reverse-beginning; that is, the last
- element.
-
- @image html range-rbegin-rend.svg "Illustration from cppreference.com"
-
- @complexity Constant.
-
- @requirement This function helps `basic_json` satisfying the
- [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
- requirements:
- - The complexity is constant.
- - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.
-
- @liveexample{The following code shows an example for `crbegin()`.,crbegin}
-
- @sa @ref rbegin() -- returns a reverse iterator to the beginning
- @sa @ref rend() -- returns a reverse iterator to the end
- @sa @ref crend() -- returns a const reverse iterator to the end
-
- @since version 1.0.0
- */
- const_reverse_iterator crbegin() const noexcept
- {
- return const_reverse_iterator(cend());
- }
-
- /*!
- @brief returns a const reverse iterator to one before the first
-
- Returns a const reverse iterator to the reverse-end; that is, one before
- the first element.
-
- @image html range-rbegin-rend.svg "Illustration from cppreference.com"
-
- @complexity Constant.
-
- @requirement This function helps `basic_json` satisfying the
- [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
- requirements:
- - The complexity is constant.
- - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.
-
- @liveexample{The following code shows an example for `crend()`.,crend}
-
- @sa @ref rend() -- returns a reverse iterator to the end
- @sa @ref rbegin() -- returns a reverse iterator to the beginning
- @sa @ref crbegin() -- returns a const reverse iterator to the beginning
-
- @since version 1.0.0
- */
- const_reverse_iterator crend() const noexcept
- {
- return const_reverse_iterator(cbegin());
- }
-
- private:
- // forward declaration
- template<typename IteratorType> class iteration_proxy;
-
- public:
- /*!
- @brief wrapper to access iterator member functions in range-based for
-
- This function allows to access @ref iterator::key() and @ref
- iterator::value() during range-based for loops. In these loops, a
- reference to the JSON values is returned, so there is no access to the
- underlying iterator.
-
- @note The name of this function is not yet final and may change in the
- future.
- */
- static iteration_proxy<iterator> iterator_wrapper(reference cont)
- {
- return iteration_proxy<iterator>(cont);
- }
-
- /*!
- @copydoc iterator_wrapper(reference)
- */
- static iteration_proxy<const_iterator> iterator_wrapper(const_reference cont)
- {
- return iteration_proxy<const_iterator>(cont);
- }
-
- /// @}
-
-
- //////////////
- // capacity //
- //////////////
-
- /// @name capacity
- /// @{
-
- /*!
- @brief checks whether the container is empty
-
- Checks if a JSON value has no elements.
-
- @return The return value depends on the different types and is
- defined as follows:
- Value type | return value
- ----------- | -------------
- null | `true`
- boolean | `false`
- string | `false`
- number | `false`
- object | result of function `object_t::empty()`
- array | result of function `array_t::empty()`
-
- @note This function does not return whether a string stored as JSON value
- is empty - it returns whether the JSON container itself is empty which is
- false in the case of a string.
-
- @complexity Constant, as long as @ref array_t and @ref object_t satisfy
- the Container concept; that is, their `empty()` functions have constant
- complexity.
-
- @requirement This function helps `basic_json` satisfying the
- [Container](http://en.cppreference.com/w/cpp/concept/Container)
- requirements:
- - The complexity is constant.
- - Has the semantics of `begin() == end()`.
-
- @liveexample{The following code uses `empty()` to check if a JSON
- object contains any elements.,empty}
-
- @sa @ref size() -- returns the number of elements
-
- @since version 1.0.0
- */
- bool empty() const noexcept
- {
- switch (m_type)
- {
- case value_t::null:
- {
- // null values are empty
- return true;
- }
-
- case value_t::array:
- {
- // delegate call to array_t::empty()
- return m_value.array->empty();
- }
-
- case value_t::object:
- {
- // delegate call to object_t::empty()
- return m_value.object->empty();
- }
-
- default:
- {
- // all other types are nonempty
- return false;
- }
- }
- }
-
- /*!
- @brief returns the number of elements
-
- Returns the number of elements in a JSON value.
-
- @return The return value depends on the different types and is
- defined as follows:
- Value type | return value
- ----------- | -------------
- null | `0`
- boolean | `1`
- string | `1`
- number | `1`
- object | result of function object_t::size()
- array | result of function array_t::size()
-
- @note This function does not return the length of a string stored as JSON
- value - it returns the number of elements in the JSON value which is 1 in
- the case of a string.
-
- @complexity Constant, as long as @ref array_t and @ref object_t satisfy
- the Container concept; that is, their size() functions have constant
- complexity.
-
- @requirement This function helps `basic_json` satisfying the
- [Container](http://en.cppreference.com/w/cpp/concept/Container)
- requirements:
- - The complexity is constant.
- - Has the semantics of `std::distance(begin(), end())`.
-
- @liveexample{The following code calls `size()` on the different value
- types.,size}
-
- @sa @ref empty() -- checks whether the container is empty
- @sa @ref max_size() -- returns the maximal number of elements
-
- @since version 1.0.0
- */
- size_type size() const noexcept
- {
- switch (m_type)
- {
- case value_t::null:
- {
- // null values are empty
- return 0;
- }
-
- case value_t::array:
- {
- // delegate call to array_t::size()
- return m_value.array->size();
- }
-
- case value_t::object:
- {
- // delegate call to object_t::size()
- return m_value.object->size();
- }
-
- default:
- {
- // all other types have size 1
- return 1;
- }
- }
- }
-
- /*!
- @brief returns the maximum possible number of elements
-
- Returns the maximum number of elements a JSON value is able to hold due to
- system or library implementation limitations, i.e. `std::distance(begin(),
- end())` for the JSON value.
-
- @return The return value depends on the different types and is
- defined as follows:
- Value type | return value
- ----------- | -------------
- null | `0` (same as `size()`)
- boolean | `1` (same as `size()`)
- string | `1` (same as `size()`)
- number | `1` (same as `size()`)
- object | result of function `object_t::max_size()`
- array | result of function `array_t::max_size()`
-
- @complexity Constant, as long as @ref array_t and @ref object_t satisfy
- the Container concept; that is, their `max_size()` functions have constant
- complexity.
-
- @requirement This function helps `basic_json` satisfying the
- [Container](http://en.cppreference.com/w/cpp/concept/Container)
- requirements:
- - The complexity is constant.
- - Has the semantics of returning `b.size()` where `b` is the largest
- possible JSON value.
-
- @liveexample{The following code calls `max_size()` on the different value
- types. Note the output is implementation specific.,max_size}
-
- @sa @ref size() -- returns the number of elements
-
- @since version 1.0.0
- */
- size_type max_size() const noexcept
- {
- switch (m_type)
- {
- case value_t::array:
- {
- // delegate call to array_t::max_size()
- return m_value.array->max_size();
- }
-
- case value_t::object:
- {
- // delegate call to object_t::max_size()
- return m_value.object->max_size();
- }
-
- default:
- {
- // all other types have max_size() == size()
- return size();
- }
- }
- }
-
- /// @}
-
-
- ///////////////
- // modifiers //
- ///////////////
-
- /// @name modifiers
- /// @{
-
- /*!
- @brief clears the contents
-
- Clears the content of a JSON value and resets it to the default value as
- if @ref basic_json(value_t) would have been called:
-
- Value type | initial value
- ----------- | -------------
- null | `null`
- boolean | `false`
- string | `""`
- number | `0`
- object | `{}`
- array | `[]`
-
- @complexity Linear in the size of the JSON value.
-
- @liveexample{The example below shows the effect of `clear()` to different
- JSON types.,clear}
-
- @since version 1.0.0
- */
- void clear() noexcept
- {
- switch (m_type)
- {
- case value_t::number_integer:
- {
- m_value.number_integer = 0;
- break;
- }
-
- case value_t::number_unsigned:
- {
- m_value.number_unsigned = 0;
- break;
- }
-
- case value_t::number_float:
- {
- m_value.number_float = 0.0;
- break;
- }
-
- case value_t::boolean:
- {
- m_value.boolean = false;
- break;
- }
-
- case value_t::string:
- {
- m_value.string->clear();
- break;
- }
-
- case value_t::array:
- {
- m_value.array->clear();
- break;
- }
-
- case value_t::object:
- {
- m_value.object->clear();
- break;
- }
-
- default:
- {
- break;
- }
- }
- }
-
- /*!
- @brief add an object to an array
-
- Appends the given element @a val to the end of the JSON value. If the
- function is called on a JSON null value, an empty array is created before
- appending @a val.
-
- @param[in] val the value to add to the JSON array
-
- @throw std::domain_error when called on a type other than JSON array or
- null; example: `"cannot use push_back() with number"`
-
- @complexity Amortized constant.
-
- @liveexample{The example shows how `push_back()` and `+=` can be used to
- add elements to a JSON array. Note how the `null` value was silently
- converted to a JSON array.,push_back}
-
- @since version 1.0.0
- */
- void push_back(basic_json&& val)
- {
- // push_back only works for null objects or arrays
- if (not(is_null() or is_array()))
- {
- JSON_THROW(std::domain_error("cannot use push_back() with " + type_name()));
- }
-
- // transform null object into an array
- if (is_null())
- {
- m_type = value_t::array;
- m_value = value_t::array;
- assert_invariant();
- }
-
- // add element to array (move semantics)
- m_value.array->push_back(std::move(val));
- // invalidate object
- val.m_type = value_t::null;
- }
-
- /*!
- @brief add an object to an array
- @copydoc push_back(basic_json&&)
- */
- reference operator+=(basic_json&& val)
- {
- push_back(std::move(val));
- return *this;
- }
-
- /*!
- @brief add an object to an array
- @copydoc push_back(basic_json&&)
- */
- void push_back(const basic_json& val)
- {
- // push_back only works for null objects or arrays
- if (not(is_null() or is_array()))
- {
- JSON_THROW(std::domain_error("cannot use push_back() with " + type_name()));
- }
-
- // transform null object into an array
- if (is_null())
- {
- m_type = value_t::array;
- m_value = value_t::array;
- assert_invariant();
- }
-
- // add element to array
- m_value.array->push_back(val);
- }
-
- /*!
- @brief add an object to an array
- @copydoc push_back(basic_json&&)
- */
- reference operator+=(const basic_json& val)
- {
- push_back(val);
- return *this;
- }
-
- /*!
- @brief add an object to an object
-
- Inserts the given element @a val to the JSON object. If the function is
- called on a JSON null value, an empty object is created before inserting
- @a val.
-
- @param[in] val the value to add to the JSON object
-
- @throw std::domain_error when called on a type other than JSON object or
- null; example: `"cannot use push_back() with number"`
-
- @complexity Logarithmic in the size of the container, O(log(`size()`)).
-
- @liveexample{The example shows how `push_back()` and `+=` can be used to
- add elements to a JSON object. Note how the `null` value was silently
- converted to a JSON object.,push_back__object_t__value}
-
- @since version 1.0.0
- */
- void push_back(const typename object_t::value_type& val)
- {
- // push_back only works for null objects or objects
- if (not(is_null() or is_object()))
- {
- JSON_THROW(std::domain_error("cannot use push_back() with " + type_name()));
- }
-
- // transform null object into an object
- if (is_null())
- {
- m_type = value_t::object;
- m_value = value_t::object;
- assert_invariant();
- }
-
- // add element to array
- m_value.object->insert(val);
- }
-
- /*!
- @brief add an object to an object
- @copydoc push_back(const typename object_t::value_type&)
- */
- reference operator+=(const typename object_t::value_type& val)
- {
- push_back(val);
- return *this;
- }
-
- /*!
- @brief add an object to an object
-
- This function allows to use `push_back` with an initializer list. In case
-
- 1. the current value is an object,
- 2. the initializer list @a init contains only two elements, and
- 3. the first element of @a init is a string,
-
- @a init is converted into an object element and added using
- @ref push_back(const typename object_t::value_type&). Otherwise, @a init
- is converted to a JSON value and added using @ref push_back(basic_json&&).
-
- @param init an initializer list
-
- @complexity Linear in the size of the initializer list @a init.
-
- @note This function is required to resolve an ambiguous overload error,
- because pairs like `{"key", "value"}` can be both interpreted as
- `object_t::value_type` or `std::initializer_list<basic_json>`, see
- https://github.com/nlohmann/json/issues/235 for more information.
-
- @liveexample{The example shows how initializer lists are treated as
- objects when possible.,push_back__initializer_list}
- */
- void push_back(std::initializer_list<basic_json> init)
- {
- if (is_object() and init.size() == 2 and init.begin()->is_string())
- {
- const string_t key = *init.begin();
- push_back(typename object_t::value_type(key, *(init.begin() + 1)));
- }
- else
- {
- push_back(basic_json(init));
- }
- }
-
- /*!
- @brief add an object to an object
- @copydoc push_back(std::initializer_list<basic_json>)
- */
- reference operator+=(std::initializer_list<basic_json> init)
- {
- push_back(init);
- return *this;
- }
-
- /*!
- @brief add an object to an array
-
- Creates a JSON value from the passed parameters @a args to the end of the
- JSON value. If the function is called on a JSON null value, an empty array
- is created before appending the value created from @a args.
-
- @param[in] args arguments to forward to a constructor of @ref basic_json
- @tparam Args compatible types to create a @ref basic_json object
-
- @throw std::domain_error when called on a type other than JSON array or
- null; example: `"cannot use emplace_back() with number"`
-
- @complexity Amortized constant.
-
- @liveexample{The example shows how `push_back()` can be used to add
- elements to a JSON array. Note how the `null` value was silently converted
- to a JSON array.,emplace_back}
-
- @since version 2.0.8
- */
- template<class... Args>
- void emplace_back(Args&& ... args)
- {
- // emplace_back only works for null objects or arrays
- if (not(is_null() or is_array()))
- {
- JSON_THROW(std::domain_error("cannot use emplace_back() with " + type_name()));
- }
-
- // transform null object into an array
- if (is_null())
- {
- m_type = value_t::array;
- m_value = value_t::array;
- assert_invariant();
- }
-
- // add element to array (perfect forwarding)
- m_value.array->emplace_back(std::forward<Args>(args)...);
- }
-
- /*!
- @brief add an object to an object if key does not exist
-
- Inserts a new element into a JSON object constructed in-place with the
- given @a args if there is no element with the key in the container. If the
- function is called on a JSON null value, an empty object is created before
- appending the value created from @a args.
-
- @param[in] args arguments to forward to a constructor of @ref basic_json
- @tparam Args compatible types to create a @ref basic_json object
-
- @return a pair consisting of an iterator to the inserted element, or the
- already-existing element if no insertion happened, and a bool
- denoting whether the insertion took place.
-
- @throw std::domain_error when called on a type other than JSON object or
- null; example: `"cannot use emplace() with number"`
-
- @complexity Logarithmic in the size of the container, O(log(`size()`)).
-
- @liveexample{The example shows how `emplace()` can be used to add elements
- to a JSON object. Note how the `null` value was silently converted to a
- JSON object. Further note how no value is added if there was already one
- value stored with the same key.,emplace}
-
- @since version 2.0.8
- */
- template<class... Args>
- std::pair<iterator, bool> emplace(Args&& ... args)
- {
- // emplace only works for null objects or arrays
- if (not(is_null() or is_object()))
- {
- JSON_THROW(std::domain_error("cannot use emplace() with " + type_name()));
- }
-
- // transform null object into an object
- if (is_null())
- {
- m_type = value_t::object;
- m_value = value_t::object;
- assert_invariant();
- }
-
- // add element to array (perfect forwarding)
- auto res = m_value.object->emplace(std::forward<Args>(args)...);
- // create result iterator and set iterator to the result of emplace
- auto it = begin();
- it.m_it.object_iterator = res.first;
-
- // return pair of iterator and boolean
- return {it, res.second};
- }
-
- /*!
- @brief inserts element
-
- Inserts element @a val before iterator @a pos.
-
- @param[in] pos iterator before which the content will be inserted; may be
- the end() iterator
- @param[in] val element to insert
- @return iterator pointing to the inserted @a val.
-
- @throw std::domain_error if called on JSON values other than arrays;
- example: `"cannot use insert() with string"`
- @throw std::domain_error if @a pos is not an iterator of *this; example:
- `"iterator does not fit current value"`
-
- @complexity Constant plus linear in the distance between @a pos and end of
- the container.
-
- @liveexample{The example shows how `insert()` is used.,insert}
-
- @since version 1.0.0
- */
- iterator insert(const_iterator pos, const basic_json& val)
- {
- // insert only works for arrays
- if (is_array())
- {
- // check if iterator pos fits to this JSON value
- if (pos.m_object != this)
- {
- JSON_THROW(std::domain_error("iterator does not fit current value"));
- }
-
- // insert to array and return iterator
- iterator result(this);
- result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, val);
- return result;
- }
-
- JSON_THROW(std::domain_error("cannot use insert() with " + type_name()));
- }
-
- /*!
- @brief inserts element
- @copydoc insert(const_iterator, const basic_json&)
- */
- iterator insert(const_iterator pos, basic_json&& val)
- {
- return insert(pos, val);
- }
-
- /*!
- @brief inserts elements
-
- Inserts @a cnt copies of @a val before iterator @a pos.
-
- @param[in] pos iterator before which the content will be inserted; may be
- the end() iterator
- @param[in] cnt number of copies of @a val to insert
- @param[in] val element to insert
- @return iterator pointing to the first element inserted, or @a pos if
- `cnt==0`
-
- @throw std::domain_error if called on JSON values other than arrays;
- example: `"cannot use insert() with string"`
- @throw std::domain_error if @a pos is not an iterator of *this; example:
- `"iterator does not fit current value"`
-
- @complexity Linear in @a cnt plus linear in the distance between @a pos
- and end of the container.
-
- @liveexample{The example shows how `insert()` is used.,insert__count}
-
- @since version 1.0.0
- */
- iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
- {
- // insert only works for arrays
- if (is_array())
- {
- // check if iterator pos fits to this JSON value
- if (pos.m_object != this)
- {
- JSON_THROW(std::domain_error("iterator does not fit current value"));
- }
-
- // insert to array and return iterator
- iterator result(this);
- result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
- return result;
- }
-
- JSON_THROW(std::domain_error("cannot use insert() with " + type_name()));
- }
-
- /*!
- @brief inserts elements
-
- Inserts elements from range `[first, last)` before iterator @a pos.
-
- @param[in] pos iterator before which the content will be inserted; may be
- the end() iterator
- @param[in] first begin of the range of elements to insert
- @param[in] last end of the range of elements to insert
-
- @throw std::domain_error if called on JSON values other than arrays;
- example: `"cannot use insert() with string"`
- @throw std::domain_error if @a pos is not an iterator of *this; example:
- `"iterator does not fit current value"`
- @throw std::domain_error if @a first and @a last do not belong to the same
- JSON value; example: `"iterators do not fit"`
- @throw std::domain_error if @a first or @a last are iterators into
- container for which insert is called; example: `"passed iterators may not
- belong to container"`
-
- @return iterator pointing to the first element inserted, or @a pos if
- `first==last`
-
- @complexity Linear in `std::distance(first, last)` plus linear in the
- distance between @a pos and end of the container.
-
- @liveexample{The example shows how `insert()` is used.,insert__range}
-
- @since version 1.0.0
- */
- iterator insert(const_iterator pos, const_iterator first, const_iterator last)
- {
- // insert only works for arrays
- if (not is_array())
- {
- JSON_THROW(std::domain_error("cannot use insert() with " + type_name()));
- }
-
- // check if iterator pos fits to this JSON value
- if (pos.m_object != this)
- {
- JSON_THROW(std::domain_error("iterator does not fit current value"));
- }
-
- // check if range iterators belong to the same JSON object
- if (first.m_object != last.m_object)
- {
- JSON_THROW(std::domain_error("iterators do not fit"));
- }
-
- if (first.m_object == this or last.m_object == this)
- {
- JSON_THROW(std::domain_error("passed iterators may not belong to container"));
- }
-
- // insert to array and return iterator
- iterator result(this);
- result.m_it.array_iterator = m_value.array->insert(
- pos.m_it.array_iterator,
- first.m_it.array_iterator,
- last.m_it.array_iterator);
- return result;
- }
-
- /*!
- @brief inserts elements
-
- Inserts elements from initializer list @a ilist before iterator @a pos.
-
- @param[in] pos iterator before which the content will be inserted; may be
- the end() iterator
- @param[in] ilist initializer list to insert the values from
-
- @throw std::domain_error if called on JSON values other than arrays;
- example: `"cannot use insert() with string"`
- @throw std::domain_error if @a pos is not an iterator of *this; example:
- `"iterator does not fit current value"`
-
- @return iterator pointing to the first element inserted, or @a pos if
- `ilist` is empty
-
- @complexity Linear in `ilist.size()` plus linear in the distance between
- @a pos and end of the container.
-
- @liveexample{The example shows how `insert()` is used.,insert__ilist}
-
- @since version 1.0.0
- */
- iterator insert(const_iterator pos, std::initializer_list<basic_json> ilist)
- {
- // insert only works for arrays
- if (not is_array())
- {
- JSON_THROW(std::domain_error("cannot use insert() with " + type_name()));
- }
-
- // check if iterator pos fits to this JSON value
- if (pos.m_object != this)
- {
- JSON_THROW(std::domain_error("iterator does not fit current value"));
- }
-
- // insert to array and return iterator
- iterator result(this);
- result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, ilist);
- return result;
- }
-
- /*!
- @brief exchanges the values
-
- Exchanges the contents of the JSON value with those of @a other. Does not
- invoke any move, copy, or swap operations on individual elements. All
- iterators and references remain valid. The past-the-end iterator is
- invalidated.
-
- @param[in,out] other JSON value to exchange the contents with
-
- @complexity Constant.
-
- @liveexample{The example below shows how JSON values can be swapped with
- `swap()`.,swap__reference}
-
- @since version 1.0.0
- */
- void swap(reference other) noexcept (
- std::is_nothrow_move_constructible<value_t>::value and
- std::is_nothrow_move_assignable<value_t>::value and
- std::is_nothrow_move_constructible<json_value>::value and
- std::is_nothrow_move_assignable<json_value>::value
- )
- {
- std::swap(m_type, other.m_type);
- std::swap(m_value, other.m_value);
- assert_invariant();
- }
-
- /*!
- @brief exchanges the values
-
- Exchanges the contents of a JSON array with those of @a other. Does not
- invoke any move, copy, or swap operations on individual elements. All
- iterators and references remain valid. The past-the-end iterator is
- invalidated.
-
- @param[in,out] other array to exchange the contents with
-
- @throw std::domain_error when JSON value is not an array; example:
- `"cannot use swap() with string"`
-
- @complexity Constant.
-
- @liveexample{The example below shows how arrays can be swapped with
- `swap()`.,swap__array_t}
-
- @since version 1.0.0
- */
- void swap(array_t& other)
- {
- // swap only works for arrays
- if (is_array())
- {
- std::swap(*(m_value.array), other);
- }
- else
- {
- JSON_THROW(std::domain_error("cannot use swap() with " + type_name()));
- }
- }
-
- /*!
- @brief exchanges the values
-
- Exchanges the contents of a JSON object with those of @a other. Does not
- invoke any move, copy, or swap operations on individual elements. All
- iterators and references remain valid. The past-the-end iterator is
- invalidated.
-
- @param[in,out] other object to exchange the contents with
-
- @throw std::domain_error when JSON value is not an object; example:
- `"cannot use swap() with string"`
-
- @complexity Constant.
-
- @liveexample{The example below shows how objects can be swapped with
- `swap()`.,swap__object_t}
-
- @since version 1.0.0
- */
- void swap(object_t& other)
- {
- // swap only works for objects
- if (is_object())
- {
- std::swap(*(m_value.object), other);
- }
- else
- {
- JSON_THROW(std::domain_error("cannot use swap() with " + type_name()));
- }
- }
-
- /*!
- @brief exchanges the values
-
- Exchanges the contents of a JSON string with those of @a other. Does not
- invoke any move, copy, or swap operations on individual elements. All
- iterators and references remain valid. The past-the-end iterator is
- invalidated.
-
- @param[in,out] other string to exchange the contents with
-
- @throw std::domain_error when JSON value is not a string; example: `"cannot
- use swap() with boolean"`
-
- @complexity Constant.
-
- @liveexample{The example below shows how strings can be swapped with
- `swap()`.,swap__string_t}
-
- @since version 1.0.0
- */
- void swap(string_t& other)
- {
- // swap only works for strings
- if (is_string())
- {
- std::swap(*(m_value.string), other);
- }
- else
- {
- JSON_THROW(std::domain_error("cannot use swap() with " + type_name()));
- }
- }
-
- /// @}
-
- public:
- //////////////////////////////////////////
- // lexicographical comparison operators //
- //////////////////////////////////////////
-
- /// @name lexicographical comparison operators
- /// @{
-
- /*!
- @brief comparison: equal
-
- Compares two JSON values for equality according to the following rules:
- - Two JSON values are equal if (1) they are from the same type and (2)
- their stored values are the same.
- - Integer and floating-point numbers are automatically converted before
- comparison. Floating-point numbers are compared indirectly: two
- floating-point numbers `f1` and `f2` are considered equal if neither
- `f1 > f2` nor `f2 > f1` holds.
- - Two JSON null values are equal.
-
- @param[in] lhs first JSON value to consider
- @param[in] rhs second JSON value to consider
- @return whether the values @a lhs and @a rhs are equal
-
- @complexity Linear.
-
- @liveexample{The example demonstrates comparing several JSON
- types.,operator__equal}
-
- @since version 1.0.0
- */
- friend bool operator==(const_reference lhs, const_reference rhs) noexcept
- {
- const auto lhs_type = lhs.type();
- const auto rhs_type = rhs.type();
-
- if (lhs_type == rhs_type)
- {
- switch (lhs_type)
- {
- case value_t::array:
- {
- return *lhs.m_value.array == *rhs.m_value.array;
- }
- case value_t::object:
- {
- return *lhs.m_value.object == *rhs.m_value.object;
- }
- case value_t::null:
- {
- return true;
- }
- case value_t::string:
- {
- return *lhs.m_value.string == *rhs.m_value.string;
- }
- case value_t::boolean:
- {
- return lhs.m_value.boolean == rhs.m_value.boolean;
- }
- case value_t::number_integer:
- {
- return lhs.m_value.number_integer == rhs.m_value.number_integer;
- }
- case value_t::number_unsigned:
- {
- return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
- }
- case value_t::number_float:
- {
- return lhs.m_value.number_float == rhs.m_value.number_float;
- }
- default:
- {
- return false;
- }
- }
- }
- else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
- {
- return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
- }
- else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
- {
- return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
- }
- else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
- {
- return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
- }
- else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
- {
- return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
- }
- else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
- {
- return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
- }
- else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
- {
- return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
- }
-
- return false;
- }
-
- /*!
- @brief comparison: equal
- @copydoc operator==(const_reference, const_reference)
- */
- template<typename ScalarType, typename std::enable_if<
- std::is_scalar<ScalarType>::value, int>::type = 0>
- friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
- {
- return (lhs == basic_json(rhs));
- }
-
- /*!
- @brief comparison: equal
- @copydoc operator==(const_reference, const_reference)
- */
- template<typename ScalarType, typename std::enable_if<
- std::is_scalar<ScalarType>::value, int>::type = 0>
- friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
- {
- return (basic_json(lhs) == rhs);
- }
-
- /*!
- @brief comparison: not equal
-
- Compares two JSON values for inequality by calculating `not (lhs == rhs)`.
-
- @param[in] lhs first JSON value to consider
- @param[in] rhs second JSON value to consider
- @return whether the values @a lhs and @a rhs are not equal
-
- @complexity Linear.
-
- @liveexample{The example demonstrates comparing several JSON
- types.,operator__notequal}
-
- @since version 1.0.0
- */
- friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
- {
- return not (lhs == rhs);
- }
-
- /*!
- @brief comparison: not equal
- @copydoc operator!=(const_reference, const_reference)
- */
- template<typename ScalarType, typename std::enable_if<
- std::is_scalar<ScalarType>::value, int>::type = 0>
- friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
- {
- return (lhs != basic_json(rhs));
- }
-
- /*!
- @brief comparison: not equal
- @copydoc operator!=(const_reference, const_reference)
- */
- template<typename ScalarType, typename std::enable_if<
- std::is_scalar<ScalarType>::value, int>::type = 0>
- friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
- {
- return (basic_json(lhs) != rhs);
- }
-
- /*!
- @brief comparison: less than
-
- Compares whether one JSON value @a lhs is less than another JSON value @a
- rhs according to the following rules:
- - If @a lhs and @a rhs have the same type, the values are compared using
- the default `<` operator.
- - Integer and floating-point numbers are automatically converted before
- comparison
- - In case @a lhs and @a rhs have different types, the values are ignored
- and the order of the types is considered, see
- @ref operator<(const value_t, const value_t).
-
- @param[in] lhs first JSON value to consider
- @param[in] rhs second JSON value to consider
- @return whether @a lhs is less than @a rhs
-
- @complexity Linear.
-
- @liveexample{The example demonstrates comparing several JSON
- types.,operator__less}
-
- @since version 1.0.0
- */
- friend bool operator<(const_reference lhs, const_reference rhs) noexcept
- {
- const auto lhs_type = lhs.type();
- const auto rhs_type = rhs.type();
-
- if (lhs_type == rhs_type)
- {
- switch (lhs_type)
- {
- case value_t::array:
- {
- return *lhs.m_value.array < *rhs.m_value.array;
- }
- case value_t::object:
- {
- return *lhs.m_value.object < *rhs.m_value.object;
- }
- case value_t::null:
- {
- return false;
- }
- case value_t::string:
- {
- return *lhs.m_value.string < *rhs.m_value.string;
- }
- case value_t::boolean:
- {
- return lhs.m_value.boolean < rhs.m_value.boolean;
- }
- case value_t::number_integer:
- {
- return lhs.m_value.number_integer < rhs.m_value.number_integer;
- }
- case value_t::number_unsigned:
- {
- return lhs.m_value.number_unsigned < rhs.m_value.number_unsigned;
- }
- case value_t::number_float:
- {
- return lhs.m_value.number_float < rhs.m_value.number_float;
- }
- default:
- {
- return false;
- }
- }
- }
- else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
- {
- return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
- }
- else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
- {
- return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
- }
- else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
- {
- return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
- }
- else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
- {
- return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
- }
- else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
- {
- return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
- }
- else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
- {
- return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
- }
-
- // We only reach this line if we cannot compare values. In that case,
- // we compare types. Note we have to call the operator explicitly,
- // because MSVC has problems otherwise.
- return operator<(lhs_type, rhs_type);
- }
-
- /*!
- @brief comparison: less than or equal
-
- Compares whether one JSON value @a lhs is less than or equal to another
- JSON value by calculating `not (rhs < lhs)`.
-
- @param[in] lhs first JSON value to consider
- @param[in] rhs second JSON value to consider
- @return whether @a lhs is less than or equal to @a rhs
-
- @complexity Linear.
-
- @liveexample{The example demonstrates comparing several JSON
- types.,operator__greater}
-
- @since version 1.0.0
- */
- friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
- {
- return not (rhs < lhs);
- }
-
- /*!
- @brief comparison: greater than
-
- Compares whether one JSON value @a lhs is greater than another
- JSON value by calculating `not (lhs <= rhs)`.
-
- @param[in] lhs first JSON value to consider
- @param[in] rhs second JSON value to consider
- @return whether @a lhs is greater than to @a rhs
-
- @complexity Linear.
-
- @liveexample{The example demonstrates comparing several JSON
- types.,operator__lessequal}
-
- @since version 1.0.0
- */
- friend bool operator>(const_reference lhs, const_reference rhs) noexcept
- {
- return not (lhs <= rhs);
- }
-
- /*!
- @brief comparison: greater than or equal
-
- Compares whether one JSON value @a lhs is greater than or equal to another
- JSON value by calculating `not (lhs < rhs)`.
-
- @param[in] lhs first JSON value to consider
- @param[in] rhs second JSON value to consider
- @return whether @a lhs is greater than or equal to @a rhs
-
- @complexity Linear.
-
- @liveexample{The example demonstrates comparing several JSON
- types.,operator__greaterequal}
-
- @since version 1.0.0
- */
- friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
- {
- return not (lhs < rhs);
- }
-
- /// @}
-
-
- ///////////////////
- // serialization //
- ///////////////////
-
- /// @name serialization
- /// @{
-
- /*!
- @brief serialize to stream
-
- Serialize the given JSON value @a j to the output stream @a o. The JSON
- value will be serialized using the @ref dump member function. The
- indentation of the output can be controlled with the member variable
- `width` of the output stream @a o. For instance, using the manipulator
- `std::setw(4)` on @a o sets the indentation level to `4` and the
- serialization result is the same as calling `dump(4)`.
-
- @param[in,out] o stream to serialize to
- @param[in] j JSON value to serialize
-
- @return the stream @a o
-
- @complexity Linear.
-
- @liveexample{The example below shows the serialization with different
- parameters to `width` to adjust the indentation level.,operator_serialize}
-
- @since version 1.0.0
- */
- friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
- {
- // read width member and use it as indentation parameter if nonzero
- const bool pretty_print = (o.width() > 0);
- const auto indentation = (pretty_print ? o.width() : 0);
-
- // reset width to 0 for subsequent calls to this stream
- o.width(0);
-
- // do the actual serialization
- j.dump(o, pretty_print, static_cast<unsigned int>(indentation));
-
- return o;
- }
-
- /*!
- @brief serialize to stream
- @copydoc operator<<(std::ostream&, const basic_json&)
- */
- friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
- {
- return o << j;
- }
-
- /// @}
-
-
- /////////////////////
- // deserialization //
- /////////////////////
-
- /// @name deserialization
- /// @{
-
- /*!
- @brief deserialize from an array
-
- This function reads from an array of 1-byte values.
-
- @pre Each element of the container has a size of 1 byte. Violating this
- precondition yields undefined behavior. **This precondition is enforced
- with a static assertion.**
-
- @param[in] array array to read from
- @param[in] cb a parser callback function of type @ref parser_callback_t
- which is used to control the deserialization by filtering unwanted values
- (optional)
-
- @return result of the deserialization
-
- @complexity Linear in the length of the input. The parser is a predictive
- LL(1) parser. The complexity can be higher if the parser callback function
- @a cb has a super-linear complexity.
-
- @note A UTF-8 byte order mark is silently ignored.
-
- @liveexample{The example below demonstrates the `parse()` function reading
- from an array.,parse__array__parser_callback_t}
-
- @since version 2.0.3
- */
- template<class T, std::size_t N>
- static basic_json parse(T (&array)[N],
- const parser_callback_t cb = nullptr)
- {
- // delegate the call to the iterator-range parse overload
- return parse(std::begin(array), std::end(array), cb);
- }
-
- /*!
- @brief deserialize from string literal
-
- @tparam CharT character/literal type with size of 1 byte
- @param[in] s string literal to read a serialized JSON value from
- @param[in] cb a parser callback function of type @ref parser_callback_t
- which is used to control the deserialization by filtering unwanted values
- (optional)
-
- @return result of the deserialization
-
- @complexity Linear in the length of the input. The parser is a predictive
- LL(1) parser. The complexity can be higher if the parser callback function
- @a cb has a super-linear complexity.
-
- @note A UTF-8 byte order mark is silently ignored.
- @note String containers like `std::string` or @ref string_t can be parsed
- with @ref parse(const ContiguousContainer&, const parser_callback_t)
-
- @liveexample{The example below demonstrates the `parse()` function with
- and without callback function.,parse__string__parser_callback_t}
-
- @sa @ref parse(std::istream&, const parser_callback_t) for a version that
- reads from an input stream
-
- @since version 1.0.0 (originally for @ref string_t)
- */
- template<typename CharT, typename std::enable_if<
- std::is_pointer<CharT>::value and
- std::is_integral<typename std::remove_pointer<CharT>::type>::value and
- sizeof(typename std::remove_pointer<CharT>::type) == 1, int>::type = 0>
- static basic_json parse(const CharT s,
- const parser_callback_t cb = nullptr)
- {
- return parser(reinterpret_cast<const char*>(s), cb).parse();
- }
-
- /*!
- @brief deserialize from stream
-
- @param[in,out] i stream to read a serialized JSON value from
- @param[in] cb a parser callback function of type @ref parser_callback_t
- which is used to control the deserialization by filtering unwanted values
- (optional)
-
- @return result of the deserialization
-
- @complexity Linear in the length of the input. The parser is a predictive
- LL(1) parser. The complexity can be higher if the parser callback function
- @a cb has a super-linear complexity.
-
- @note A UTF-8 byte order mark is silently ignored.
-
- @liveexample{The example below demonstrates the `parse()` function with
- and without callback function.,parse__istream__parser_callback_t}
-
- @sa @ref parse(const CharT, const parser_callback_t) for a version
- that reads from a string
-
- @since version 1.0.0
- */
- static basic_json parse(std::istream& i,
- const parser_callback_t cb = nullptr)
- {
- return parser(i, cb).parse();
- }
-
- /*!
- @copydoc parse(std::istream&, const parser_callback_t)
- */
- static basic_json parse(std::istream&& i,
- const parser_callback_t cb = nullptr)
- {
- return parser(i, cb).parse();
- }
-
- /*!
- @brief deserialize from an iterator range with contiguous storage
-
- This function reads from an iterator range of a container with contiguous
- storage of 1-byte values. Compatible container types include
- `std::vector`, `std::string`, `std::array`, `std::valarray`, and
- `std::initializer_list`. Furthermore, C-style arrays can be used with
- `std::begin()`/`std::end()`. User-defined containers can be used as long
- as they implement random-access iterators and a contiguous storage.
-
- @pre The iterator range is contiguous. Violating this precondition yields
- undefined behavior. **This precondition is enforced with an assertion.**
- @pre Each element in the range has a size of 1 byte. Violating this
- precondition yields undefined behavior. **This precondition is enforced
- with a static assertion.**
-
- @warning There is no way to enforce all preconditions at compile-time. If
- the function is called with noncompliant iterators and with
- assertions switched off, the behavior is undefined and will most
- likely yield segmentation violation.
-
- @tparam IteratorType iterator of container with contiguous storage
- @param[in] first begin of the range to parse (included)
- @param[in] last end of the range to parse (excluded)
- @param[in] cb a parser callback function of type @ref parser_callback_t
- which is used to control the deserialization by filtering unwanted values
- (optional)
-
- @return result of the deserialization
-
- @complexity Linear in the length of the input. The parser is a predictive
- LL(1) parser. The complexity can be higher if the parser callback function
- @a cb has a super-linear complexity.
-
- @note A UTF-8 byte order mark is silently ignored.
-
- @liveexample{The example below demonstrates the `parse()` function reading
- from an iterator range.,parse__iteratortype__parser_callback_t}
-
- @since version 2.0.3
- */
- template<class IteratorType, typename std::enable_if<
- std::is_base_of<
- std::random_access_iterator_tag,
- typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
- static basic_json parse(IteratorType first, IteratorType last,
- const parser_callback_t cb = nullptr)
- {
- // assertion to check that the iterator range is indeed contiguous,
- // see http://stackoverflow.com/a/35008842/266378 for more discussion
- assert(std::accumulate(first, last, std::pair<bool, int>(true, 0),
- [&first](std::pair<bool, int> res, decltype(*first) val)
- {
- res.first &= (val == *(std::next(std::addressof(*first), res.second++)));
- return res;
- }).first);
-
- // assertion to check that each element is 1 byte long
- static_assert(sizeof(typename std::iterator_traits<IteratorType>::value_type) == 1,
- "each element in the iterator range must have the size of 1 byte");
-
- // if iterator range is empty, create a parser with an empty string
- // to generate "unexpected EOF" error message
- if (std::distance(first, last) <= 0)
- {
- return parser("").parse();
- }
-
- return parser(first, last, cb).parse();
- }
-
- /*!
- @brief deserialize from a container with contiguous storage
-
- This function reads from a container with contiguous storage of 1-byte
- values. Compatible container types include `std::vector`, `std::string`,
- `std::array`, and `std::initializer_list`. User-defined containers can be
- used as long as they implement random-access iterators and a contiguous
- storage.
-
- @pre The container storage is contiguous. Violating this precondition
- yields undefined behavior. **This precondition is enforced with an
- assertion.**
- @pre Each element of the container has a size of 1 byte. Violating this
- precondition yields undefined behavior. **This precondition is enforced
- with a static assertion.**
-
- @warning There is no way to enforce all preconditions at compile-time. If
- the function is called with a noncompliant container and with
- assertions switched off, the behavior is undefined and will most
- likely yield segmentation violation.
-
- @tparam ContiguousContainer container type with contiguous storage
- @param[in] c container to read from
- @param[in] cb a parser callback function of type @ref parser_callback_t
- which is used to control the deserialization by filtering unwanted values
- (optional)
-
- @return result of the deserialization
-
- @complexity Linear in the length of the input. The parser is a predictive
- LL(1) parser. The complexity can be higher if the parser callback function
- @a cb has a super-linear complexity.
-
- @note A UTF-8 byte order mark is silently ignored.
-
- @liveexample{The example below demonstrates the `parse()` function reading
- from a contiguous container.,parse__contiguouscontainer__parser_callback_t}
-
- @since version 2.0.3
- */
- template<class ContiguousContainer, typename std::enable_if<
- not std::is_pointer<ContiguousContainer>::value and
- std::is_base_of<
- std::random_access_iterator_tag,
- typename std::iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value
- , int>::type = 0>
- static basic_json parse(const ContiguousContainer& c,
- const parser_callback_t cb = nullptr)
- {
- // delegate the call to the iterator-range parse overload
- return parse(std::begin(c), std::end(c), cb);
- }
-
- /*!
- @brief deserialize from stream
-
- Deserializes an input stream to a JSON value.
-
- @param[in,out] i input stream to read a serialized JSON value from
- @param[in,out] j JSON value to write the deserialized input to
-
- @throw std::invalid_argument in case of parse errors
-
- @complexity Linear in the length of the input. The parser is a predictive
- LL(1) parser.
-
- @note A UTF-8 byte order mark is silently ignored.
-
- @liveexample{The example below shows how a JSON value is constructed by
- reading a serialization from a stream.,operator_deserialize}
-
- @sa parse(std::istream&, const parser_callback_t) for a variant with a
- parser callback function to filter values while parsing
-
- @since version 1.0.0
- */
- friend std::istream& operator<<(basic_json& j, std::istream& i)
- {
- j = parser(i).parse();
- return i;
- }
-
- /*!
- @brief deserialize from stream
- @copydoc operator<<(basic_json&, std::istream&)
- */
- friend std::istream& operator>>(std::istream& i, basic_json& j)
- {
- j = parser(i).parse();
- return i;
- }
-
- /// @}
-
- //////////////////////////////////////////
- // binary serialization/deserialization //
- //////////////////////////////////////////
-
- /// @name binary serialization/deserialization support
- /// @{
-
- private:
- /*!
- @note Some code in the switch cases has been copied, because otherwise
- copilers would complain about implicit fallthrough and there is no
- portable attribute to mute such warnings.
- */
- template<typename T>
- static void add_to_vector(std::vector<uint8_t>& vec, size_t bytes, const T number)
- {
- assert(bytes == 1 or bytes == 2 or bytes == 4 or bytes == 8);
-
- switch (bytes)
- {
- case 8:
- {
- vec.push_back(static_cast<uint8_t>((static_cast<uint64_t>(number) >> 070) & 0xff));
- vec.push_back(static_cast<uint8_t>((static_cast<uint64_t>(number) >> 060) & 0xff));
- vec.push_back(static_cast<uint8_t>((static_cast<uint64_t>(number) >> 050) & 0xff));
- vec.push_back(static_cast<uint8_t>((static_cast<uint64_t>(number) >> 040) & 0xff));
- vec.push_back(static_cast<uint8_t>((number >> 030) & 0xff));
- vec.push_back(static_cast<uint8_t>((number >> 020) & 0xff));
- vec.push_back(static_cast<uint8_t>((number >> 010) & 0xff));
- vec.push_back(static_cast<uint8_t>(number & 0xff));
- break;
- }
-
- case 4:
- {
- vec.push_back(static_cast<uint8_t>((number >> 030) & 0xff));
- vec.push_back(static_cast<uint8_t>((number >> 020) & 0xff));
- vec.push_back(static_cast<uint8_t>((number >> 010) & 0xff));
- vec.push_back(static_cast<uint8_t>(number & 0xff));
- break;
- }
-
- case 2:
- {
- vec.push_back(static_cast<uint8_t>((number >> 010) & 0xff));
- vec.push_back(static_cast<uint8_t>(number & 0xff));
- break;
- }
-
- case 1:
- {
- vec.push_back(static_cast<uint8_t>(number & 0xff));
- break;
- }
- }
- }
-
- /*!
- @brief take sufficient bytes from a vector to fill an integer variable
-
- In the context of binary serialization formats, we need to read several
- bytes from a byte vector and combine them to multi-byte integral data
- types.
-
- @param[in] vec byte vector to read from
- @param[in] current_index the position in the vector after which to read
-
- @return the next sizeof(T) bytes from @a vec, in reverse order as T
-
- @tparam T the integral return type
-
- @throw std::out_of_range if there are less than sizeof(T)+1 bytes in the
- vector @a vec to read
-
- In the for loop, the bytes from the vector are copied in reverse order into
- the return value. In the figures below, let sizeof(T)=4 and `i` be the loop
- variable.
-
- Precondition:
-
- vec: | | | a | b | c | d | T: | | | | |
- ^ ^ ^ ^
- current_index i ptr sizeof(T)
-
- Postcondition:
-
- vec: | | | a | b | c | d | T: | d | c | b | a |
- ^ ^ ^
- | i ptr
- current_index
-
- @sa Code adapted from <http://stackoverflow.com/a/41031865/266378>.
- */
- template<typename T>
- static T get_from_vector(const std::vector<uint8_t>& vec, const size_t current_index)
- {
- if (current_index + sizeof(T) + 1 > vec.size())
- {
- JSON_THROW(std::out_of_range("cannot read " + std::to_string(sizeof(T)) + " bytes from vector"));
- }
-
- T result;
- auto* ptr = reinterpret_cast<uint8_t*>(&result);
- for (size_t i = 0; i < sizeof(T); ++i)
- {
- *ptr++ = vec[current_index + sizeof(T) - i];
- }
- return result;
- }
-
- /*!
- @brief create a MessagePack serialization of a given JSON value
-
- This is a straightforward implementation of the MessagePack specification.
-
- @param[in] j JSON value to serialize
- @param[in,out] v byte vector to write the serialization to
-
- @sa https://github.com/msgpack/msgpack/blob/master/spec.md
- */
- static void to_msgpack_internal(const basic_json& j, std::vector<uint8_t>& v)
- {
- switch (j.type())
- {
- case value_t::null:
- {
- // nil
- v.push_back(0xc0);
- break;
- }
-
- case value_t::boolean:
- {
- // true and false
- v.push_back(j.m_value.boolean ? 0xc3 : 0xc2);
- break;
- }
-
- case value_t::number_integer:
- {
- if (j.m_value.number_integer >= 0)
- {
- // MessagePack does not differentiate between positive
- // signed integers and unsigned integers. Therefore, we
- // used the code from the value_t::number_unsigned case
- // here.
- if (j.m_value.number_unsigned < 128)
- {
- // positive fixnum
- add_to_vector(v, 1, j.m_value.number_unsigned);
- }
- else if (j.m_value.number_unsigned <= std::numeric_limits<uint8_t>::max())
- {
- // uint 8
- v.push_back(0xcc);
- add_to_vector(v, 1, j.m_value.number_unsigned);
- }
- else if (j.m_value.number_unsigned <= std::numeric_limits<uint16_t>::max())
- {
- // uint 16
- v.push_back(0xcd);
- add_to_vector(v, 2, j.m_value.number_unsigned);
- }
- else if (j.m_value.number_unsigned <= std::numeric_limits<uint32_t>::max())
- {
- // uint 32
- v.push_back(0xce);
- add_to_vector(v, 4, j.m_value.number_unsigned);
- }
- else if (j.m_value.number_unsigned <= std::numeric_limits<uint64_t>::max())
- {
- // uint 64
- v.push_back(0xcf);
- add_to_vector(v, 8, j.m_value.number_unsigned);
- }
- }
- else
- {
- if (j.m_value.number_integer >= -32)
- {
- // negative fixnum
- add_to_vector(v, 1, j.m_value.number_integer);
- }
- else if (j.m_value.number_integer >= std::numeric_limits<int8_t>::min() and j.m_value.number_integer <= std::numeric_limits<int8_t>::max())
- {
- // int 8
- v.push_back(0xd0);
- add_to_vector(v, 1, j.m_value.number_integer);
- }
- else if (j.m_value.number_integer >= std::numeric_limits<int16_t>::min() and j.m_value.number_integer <= std::numeric_limits<int16_t>::max())
- {
- // int 16
- v.push_back(0xd1);
- add_to_vector(v, 2, j.m_value.number_integer);
- }
- else if (j.m_value.number_integer >= std::numeric_limits<int32_t>::min() and j.m_value.number_integer <= std::numeric_limits<int32_t>::max())
- {
- // int 32
- v.push_back(0xd2);
- add_to_vector(v, 4, j.m_value.number_integer);
- }
- else if (j.m_value.number_integer >= std::numeric_limits<int64_t>::min() and j.m_value.number_integer <= std::numeric_limits<int64_t>::max())
- {
- // int 64
- v.push_back(0xd3);
- add_to_vector(v, 8, j.m_value.number_integer);
- }
- }
- break;
- }
-
- case value_t::number_unsigned:
- {
- if (j.m_value.number_unsigned < 128)
- {
- // positive fixnum
- add_to_vector(v, 1, j.m_value.number_unsigned);
- }
- else if (j.m_value.number_unsigned <= std::numeric_limits<uint8_t>::max())
- {
- // uint 8
- v.push_back(0xcc);
- add_to_vector(v, 1, j.m_value.number_unsigned);
- }
- else if (j.m_value.number_unsigned <= std::numeric_limits<uint16_t>::max())
- {
- // uint 16
- v.push_back(0xcd);
- add_to_vector(v, 2, j.m_value.number_unsigned);
- }
- else if (j.m_value.number_unsigned <= std::numeric_limits<uint32_t>::max())
- {
- // uint 32
- v.push_back(0xce);
- add_to_vector(v, 4, j.m_value.number_unsigned);
- }
- else if (j.m_value.number_unsigned <= std::numeric_limits<uint64_t>::max())
- {
- // uint 64
- v.push_back(0xcf);
- add_to_vector(v, 8, j.m_value.number_unsigned);
- }
- break;
- }
-
- case value_t::number_float:
- {
- // float 64
- v.push_back(0xcb);
- const auto* helper = reinterpret_cast<const uint8_t*>(&(j.m_value.number_float));
- for (size_t i = 0; i < 8; ++i)
- {
- v.push_back(helper[7 - i]);
- }
- break;
- }
-
- case value_t::string:
- {
- const auto N = j.m_value.string->size();
- if (N <= 31)
- {
- // fixstr
- v.push_back(static_cast<uint8_t>(0xa0 | N));
- }
- else if (N <= 255)
- {
- // str 8
- v.push_back(0xd9);
- add_to_vector(v, 1, N);
- }
- else if (N <= 65535)
- {
- // str 16
- v.push_back(0xda);
- add_to_vector(v, 2, N);
- }
- else if (N <= 4294967295)
- {
- // str 32
- v.push_back(0xdb);
- add_to_vector(v, 4, N);
- }
-
- // append string
- std::copy(j.m_value.string->begin(), j.m_value.string->end(),
- std::back_inserter(v));
- break;
- }
-
- case value_t::array:
- {
- const auto N = j.m_value.array->size();
- if (N <= 15)
- {
- // fixarray
- v.push_back(static_cast<uint8_t>(0x90 | N));
- }
- else if (N <= 0xffff)
- {
- // array 16
- v.push_back(0xdc);
- add_to_vector(v, 2, N);
- }
- else if (N <= 0xffffffff)
- {
- // array 32
- v.push_back(0xdd);
- add_to_vector(v, 4, N);
- }
-
- // append each element
- for (const auto& el : *j.m_value.array)
- {
- to_msgpack_internal(el, v);
- }
- break;
- }
-
- case value_t::object:
- {
- const auto N = j.m_value.object->size();
- if (N <= 15)
- {
- // fixmap
- v.push_back(static_cast<uint8_t>(0x80 | (N & 0xf)));
- }
- else if (N <= 65535)
- {
- // map 16
- v.push_back(0xde);
- add_to_vector(v, 2, N);
- }
- else if (N <= 4294967295)
- {
- // map 32
- v.push_back(0xdf);
- add_to_vector(v, 4, N);
- }
-
- // append each element
- for (const auto& el : *j.m_value.object)
- {
- to_msgpack_internal(el.first, v);
- to_msgpack_internal(el.second, v);
- }
- break;
- }
-
- default:
- {
- break;
- }
- }
- }
-
- /*!
- @brief create a CBOR serialization of a given JSON value
-
- This is a straightforward implementation of the CBOR specification.
-
- @param[in] j JSON value to serialize
- @param[in,out] v byte vector to write the serialization to
-
- @sa https://tools.ietf.org/html/rfc7049
- */
- static void to_cbor_internal(const basic_json& j, std::vector<uint8_t>& v)
- {
- switch (j.type())
- {
- case value_t::null:
- {
- v.push_back(0xf6);
- break;
- }
-
- case value_t::boolean:
- {
- v.push_back(j.m_value.boolean ? 0xf5 : 0xf4);
- break;
- }
-
- case value_t::number_integer:
- {
- if (j.m_value.number_integer >= 0)
- {
- // CBOR does not differentiate between positive signed
- // integers and unsigned integers. Therefore, we used the
- // code from the value_t::number_unsigned case here.
- if (j.m_value.number_integer <= 0x17)
- {
- add_to_vector(v, 1, j.m_value.number_integer);
- }
- else if (j.m_value.number_integer <= std::numeric_limits<uint8_t>::max())
- {
- v.push_back(0x18);
- // one-byte uint8_t
- add_to_vector(v, 1, j.m_value.number_integer);
- }
- else if (j.m_value.number_integer <= std::numeric_limits<uint16_t>::max())
- {
- v.push_back(0x19);
- // two-byte uint16_t
- add_to_vector(v, 2, j.m_value.number_integer);
- }
- else if (j.m_value.number_integer <= std::numeric_limits<uint32_t>::max())
- {
- v.push_back(0x1a);
- // four-byte uint32_t
- add_to_vector(v, 4, j.m_value.number_integer);
- }
- else
- {
- v.push_back(0x1b);
- // eight-byte uint64_t
- add_to_vector(v, 8, j.m_value.number_integer);
- }
- }
- else
- {
- // The conversions below encode the sign in the first
- // byte, and the value is converted to a positive number.
- const auto positive_number = -1 - j.m_value.number_integer;
- if (j.m_value.number_integer >= -24)
- {
- v.push_back(static_cast<uint8_t>(0x20 + positive_number));
- }
- else if (positive_number <= std::numeric_limits<uint8_t>::max())
- {
- // int 8
- v.push_back(0x38);
- add_to_vector(v, 1, positive_number);
- }
- else if (positive_number <= std::numeric_limits<uint16_t>::max())
- {
- // int 16
- v.push_back(0x39);
- add_to_vector(v, 2, positive_number);
- }
- else if (positive_number <= std::numeric_limits<uint32_t>::max())
- {
- // int 32
- v.push_back(0x3a);
- add_to_vector(v, 4, positive_number);
- }
- else
- {
- // int 64
- v.push_back(0x3b);
- add_to_vector(v, 8, positive_number);
- }
- }
- break;
- }
-
- case value_t::number_unsigned:
- {
- if (j.m_value.number_unsigned <= 0x17)
- {
- v.push_back(static_cast<uint8_t>(j.m_value.number_unsigned));
- }
- else if (j.m_value.number_unsigned <= 0xff)
- {
- v.push_back(0x18);
- // one-byte uint8_t
- add_to_vector(v, 1, j.m_value.number_unsigned);
- }
- else if (j.m_value.number_unsigned <= 0xffff)
- {
- v.push_back(0x19);
- // two-byte uint16_t
- add_to_vector(v, 2, j.m_value.number_unsigned);
- }
- else if (j.m_value.number_unsigned <= 0xffffffff)
- {
- v.push_back(0x1a);
- // four-byte uint32_t
- add_to_vector(v, 4, j.m_value.number_unsigned);
- }
- else if (j.m_value.number_unsigned <= 0xffffffffffffffff)
- {
- v.push_back(0x1b);
- // eight-byte uint64_t
- add_to_vector(v, 8, j.m_value.number_unsigned);
- }
- break;
- }
-
- case value_t::number_float:
- {
- // Double-Precision Float
- v.push_back(0xfb);
- const auto* helper = reinterpret_cast<const uint8_t*>(&(j.m_value.number_float));
- for (size_t i = 0; i < 8; ++i)
- {
- v.push_back(helper[7 - i]);
- }
- break;
- }
-
- case value_t::string:
- {
- const auto N = j.m_value.string->size();
- if (N <= 0x17)
- {
- v.push_back(0x60 + static_cast<uint8_t>(N)); // 1 byte for string + size
- }
- else if (N <= 0xff)
- {
- v.push_back(0x78); // one-byte uint8_t for N
- add_to_vector(v, 1, N);
- }
- else if (N <= 0xffff)
- {
- v.push_back(0x79); // two-byte uint16_t for N
- add_to_vector(v, 2, N);
- }
- else if (N <= 0xffffffff)
- {
- v.push_back(0x7a); // four-byte uint32_t for N
- add_to_vector(v, 4, N);
- }
- // LCOV_EXCL_START
- else if (N <= 0xffffffffffffffff)
- {
- v.push_back(0x7b); // eight-byte uint64_t for N
- add_to_vector(v, 8, N);
- }
- // LCOV_EXCL_STOP
-
- // append string
- std::copy(j.m_value.string->begin(), j.m_value.string->end(),
- std::back_inserter(v));
- break;
- }
-
- case value_t::array:
- {
- const auto N = j.m_value.array->size();
- if (N <= 0x17)
- {
- v.push_back(0x80 + static_cast<uint8_t>(N)); // 1 byte for array + size
- }
- else if (N <= 0xff)
- {
- v.push_back(0x98); // one-byte uint8_t for N
- add_to_vector(v, 1, N);
- }
- else if (N <= 0xffff)
- {
- v.push_back(0x99); // two-byte uint16_t for N
- add_to_vector(v, 2, N);
- }
- else if (N <= 0xffffffff)
- {
- v.push_back(0x9a); // four-byte uint32_t for N
- add_to_vector(v, 4, N);
- }
- // LCOV_EXCL_START
- else if (N <= 0xffffffffffffffff)
- {
- v.push_back(0x9b); // eight-byte uint64_t for N
- add_to_vector(v, 8, N);
- }
- // LCOV_EXCL_STOP
-
- // append each element
- for (const auto& el : *j.m_value.array)
- {
- to_cbor_internal(el, v);
- }
- break;
- }
-
- case value_t::object:
- {
- const auto N = j.m_value.object->size();
- if (N <= 0x17)
- {
- v.push_back(0xa0 + static_cast<uint8_t>(N)); // 1 byte for object + size
- }
- else if (N <= 0xff)
- {
- v.push_back(0xb8);
- add_to_vector(v, 1, N); // one-byte uint8_t for N
- }
- else if (N <= 0xffff)
- {
- v.push_back(0xb9);
- add_to_vector(v, 2, N); // two-byte uint16_t for N
- }
- else if (N <= 0xffffffff)
- {
- v.push_back(0xba);
- add_to_vector(v, 4, N); // four-byte uint32_t for N
- }
- // LCOV_EXCL_START
- else if (N <= 0xffffffffffffffff)
- {
- v.push_back(0xbb);
- add_to_vector(v, 8, N); // eight-byte uint64_t for N
- }
- // LCOV_EXCL_STOP
-
- // append each element
- for (const auto& el : *j.m_value.object)
- {
- to_cbor_internal(el.first, v);
- to_cbor_internal(el.second, v);
- }
- break;
- }
-
- default:
- {
- break;
- }
- }
- }
-
-
- /*
- @brief checks if given lengths do not exceed the size of a given vector
-
- To secure the access to the byte vector during CBOR/MessagePack
- deserialization, bytes are copied from the vector into buffers. This
- function checks if the number of bytes to copy (@a len) does not exceed
- the size @s size of the vector. Additionally, an @a offset is given from
- where to start reading the bytes.
-
- This function checks whether reading the bytes is safe; that is, offset is
- a valid index in the vector, offset+len
-
- @param[in] size size of the byte vector
- @param[in] len number of bytes to read
- @param[in] offset offset where to start reading
-
- vec: x x x x x X X X X X
- ^ ^ ^
- 0 offset len
-
- @throws out_of_range if `len > v.size()`
- */
- static void check_length(const size_t size, const size_t len, const size_t offset)
- {
- // simple case: requested length is greater than the vector's length
- if (len > size or offset > size)
- {
- JSON_THROW(std::out_of_range("len out of range"));
- }
-
- // second case: adding offset would result in overflow
- if ((size > (std::numeric_limits<size_t>::max() - offset)))
- {
- JSON_THROW(std::out_of_range("len+offset out of range"));
- }
-
- // last case: reading past the end of the vector
- if (len + offset > size)
- {
- JSON_THROW(std::out_of_range("len+offset out of range"));
- }
- }
-
- /*!
- @brief create a JSON value from a given MessagePack vector
-
- @param[in] v MessagePack serialization
- @param[in] idx byte index to start reading from @a v
-
- @return deserialized JSON value
-
- @throw std::invalid_argument if unsupported features from MessagePack were
- used in the given vector @a v or if the input is not valid MessagePack
- @throw std::out_of_range if the given vector ends prematurely
-
- @sa https://github.com/msgpack/msgpack/blob/master/spec.md
- */
- static basic_json from_msgpack_internal(const std::vector<uint8_t>& v, size_t& idx)
- {
- // make sure reading 1 byte is safe
- check_length(v.size(), 1, idx);
-
- // store and increment index
- const size_t current_idx = idx++;
-
- if (v[current_idx] <= 0xbf)
- {
- if (v[current_idx] <= 0x7f) // positive fixint
- {
- return v[current_idx];
- }
- if (v[current_idx] <= 0x8f) // fixmap
- {
- basic_json result = value_t::object;
- const size_t len = v[current_idx] & 0x0f;
- for (size_t i = 0; i < len; ++i)
- {
- std::string key = from_msgpack_internal(v, idx);
- result[key] = from_msgpack_internal(v, idx);
- }
- return result;
- }
- else if (v[current_idx] <= 0x9f) // fixarray
- {
- basic_json result = value_t::array;
- const size_t len = v[current_idx] & 0x0f;
- for (size_t i = 0; i < len; ++i)
- {
- result.push_back(from_msgpack_internal(v, idx));
- }
- return result;
- }
- else // fixstr
- {
- const size_t len = v[current_idx] & 0x1f;
- const size_t offset = current_idx + 1;
- idx += len; // skip content bytes
- check_length(v.size(), len, offset);
- return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
- }
- }
- else if (v[current_idx] >= 0xe0) // negative fixint
- {
- return static_cast<int8_t>(v[current_idx]);
- }
- else
- {
- switch (v[current_idx])
- {
- case 0xc0: // nil
- {
- return value_t::null;
- }
-
- case 0xc2: // false
- {
- return false;
- }
-
- case 0xc3: // true
- {
- return true;
- }
-
- case 0xca: // float 32
- {
- // copy bytes in reverse order into the double variable
- float res;
- for (size_t byte = 0; byte < sizeof(float); ++byte)
- {
- reinterpret_cast<uint8_t*>(&res)[sizeof(float) - byte - 1] = v.at(current_idx + 1 + byte);
- }
- idx += sizeof(float); // skip content bytes
- return res;
- }
-
- case 0xcb: // float 64
- {
- // copy bytes in reverse order into the double variable
- double res;
- for (size_t byte = 0; byte < sizeof(double); ++byte)
- {
- reinterpret_cast<uint8_t*>(&res)[sizeof(double) - byte - 1] = v.at(current_idx + 1 + byte);
- }
- idx += sizeof(double); // skip content bytes
- return res;
- }
-
- case 0xcc: // uint 8
- {
- idx += 1; // skip content byte
- return get_from_vector<uint8_t>(v, current_idx);
- }
-
- case 0xcd: // uint 16
- {
- idx += 2; // skip 2 content bytes
- return get_from_vector<uint16_t>(v, current_idx);
- }
-
- case 0xce: // uint 32
- {
- idx += 4; // skip 4 content bytes
- return get_from_vector<uint32_t>(v, current_idx);
- }
-
- case 0xcf: // uint 64
- {
- idx += 8; // skip 8 content bytes
- return get_from_vector<uint64_t>(v, current_idx);
- }
-
- case 0xd0: // int 8
- {
- idx += 1; // skip content byte
- return get_from_vector<int8_t>(v, current_idx);
- }
-
- case 0xd1: // int 16
- {
- idx += 2; // skip 2 content bytes
- return get_from_vector<int16_t>(v, current_idx);
- }
-
- case 0xd2: // int 32
- {
- idx += 4; // skip 4 content bytes
- return get_from_vector<int32_t>(v, current_idx);
- }
-
- case 0xd3: // int 64
- {
- idx += 8; // skip 8 content bytes
- return get_from_vector<int64_t>(v, current_idx);
- }
-
- case 0xd9: // str 8
- {
- const auto len = static_cast<size_t>(get_from_vector<uint8_t>(v, current_idx));
- const size_t offset = current_idx + 2;
- idx += len + 1; // skip size byte + content bytes
- check_length(v.size(), len, offset);
- return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
- }
-
- case 0xda: // str 16
- {
- const auto len = static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));
- const size_t offset = current_idx + 3;
- idx += len + 2; // skip 2 size bytes + content bytes
- check_length(v.size(), len, offset);
- return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
- }
-
- case 0xdb: // str 32
- {
- const auto len = static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));
- const size_t offset = current_idx + 5;
- idx += len + 4; // skip 4 size bytes + content bytes
- check_length(v.size(), len, offset);
- return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
- }
-
- case 0xdc: // array 16
- {
- basic_json result = value_t::array;
- const auto len = static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));
- idx += 2; // skip 2 size bytes
- for (size_t i = 0; i < len; ++i)
- {
- result.push_back(from_msgpack_internal(v, idx));
- }
- return result;
- }
-
- case 0xdd: // array 32
- {
- basic_json result = value_t::array;
- const auto len = static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));
- idx += 4; // skip 4 size bytes
- for (size_t i = 0; i < len; ++i)
- {
- result.push_back(from_msgpack_internal(v, idx));
- }
- return result;
- }
-
- case 0xde: // map 16
- {
- basic_json result = value_t::object;
- const auto len = static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));
- idx += 2; // skip 2 size bytes
- for (size_t i = 0; i < len; ++i)
- {
- std::string key = from_msgpack_internal(v, idx);
- result[key] = from_msgpack_internal(v, idx);
- }
- return result;
- }
-
- case 0xdf: // map 32
- {
- basic_json result = value_t::object;
- const auto len = static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));
- idx += 4; // skip 4 size bytes
- for (size_t i = 0; i < len; ++i)
- {
- std::string key = from_msgpack_internal(v, idx);
- result[key] = from_msgpack_internal(v, idx);
- }
- return result;
- }
-
- default:
- {
- JSON_THROW(std::invalid_argument("error parsing a msgpack @ " + std::to_string(current_idx) + ": " + std::to_string(static_cast<int>(v[current_idx]))));
- }
- }
- }
- }
-
- /*!
- @brief create a JSON value from a given CBOR vector
-
- @param[in] v CBOR serialization
- @param[in] idx byte index to start reading from @a v
-
- @return deserialized JSON value
-
- @throw std::invalid_argument if unsupported features from CBOR were used in
- the given vector @a v or if the input is not valid CBOR
- @throw std::out_of_range if the given vector ends prematurely
-
- @sa https://tools.ietf.org/html/rfc7049
- */
- static basic_json from_cbor_internal(const std::vector<uint8_t>& v, size_t& idx)
- {
- // store and increment index
- const size_t current_idx = idx++;
-
- switch (v.at(current_idx))
- {
- // Integer 0x00..0x17 (0..23)
- case 0x00:
- case 0x01:
- case 0x02:
- case 0x03:
- case 0x04:
- case 0x05:
- case 0x06:
- case 0x07:
- case 0x08:
- case 0x09:
- case 0x0a:
- case 0x0b:
- case 0x0c:
- case 0x0d:
- case 0x0e:
- case 0x0f:
- case 0x10:
- case 0x11:
- case 0x12:
- case 0x13:
- case 0x14:
- case 0x15:
- case 0x16:
- case 0x17:
- {
- return v[current_idx];
- }
-
- case 0x18: // Unsigned integer (one-byte uint8_t follows)
- {
- idx += 1; // skip content byte
- return get_from_vector<uint8_t>(v, current_idx);
- }
-
- case 0x19: // Unsigned integer (two-byte uint16_t follows)
- {
- idx += 2; // skip 2 content bytes
- return get_from_vector<uint16_t>(v, current_idx);
- }
-
- case 0x1a: // Unsigned integer (four-byte uint32_t follows)
- {
- idx += 4; // skip 4 content bytes
- return get_from_vector<uint32_t>(v, current_idx);
- }
-
- case 0x1b: // Unsigned integer (eight-byte uint64_t follows)
- {
- idx += 8; // skip 8 content bytes
- return get_from_vector<uint64_t>(v, current_idx);
- }
-
- // Negative integer -1-0x00..-1-0x17 (-1..-24)
- case 0x20:
- case 0x21:
- case 0x22:
- case 0x23:
- case 0x24:
- case 0x25:
- case 0x26:
- case 0x27:
- case 0x28:
- case 0x29:
- case 0x2a:
- case 0x2b:
- case 0x2c:
- case 0x2d:
- case 0x2e:
- case 0x2f:
- case 0x30:
- case 0x31:
- case 0x32:
- case 0x33:
- case 0x34:
- case 0x35:
- case 0x36:
- case 0x37:
- {
- return static_cast<int8_t>(0x20 - 1 - v[current_idx]);
- }
-
- case 0x38: // Negative integer (one-byte uint8_t follows)
- {
- idx += 1; // skip content byte
- // must be uint8_t !
- return static_cast<number_integer_t>(-1) - get_from_vector<uint8_t>(v, current_idx);
- }
-
- case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
- {
- idx += 2; // skip 2 content bytes
- return static_cast<number_integer_t>(-1) - get_from_vector<uint16_t>(v, current_idx);
- }
-
- case 0x3a: // Negative integer -1-n (four-byte uint32_t follows)
- {
- idx += 4; // skip 4 content bytes
- return static_cast<number_integer_t>(-1) - get_from_vector<uint32_t>(v, current_idx);
- }
-
- case 0x3b: // Negative integer -1-n (eight-byte uint64_t follows)
- {
- idx += 8; // skip 8 content bytes
- return static_cast<number_integer_t>(-1) - static_cast<number_integer_t>(get_from_vector<uint64_t>(v, current_idx));
- }
-
- // UTF-8 string (0x00..0x17 bytes follow)
- case 0x60:
- case 0x61:
- case 0x62:
- case 0x63:
- case 0x64:
- case 0x65:
- case 0x66:
- case 0x67:
- case 0x68:
- case 0x69:
- case 0x6a:
- case 0x6b:
- case 0x6c:
- case 0x6d:
- case 0x6e:
- case 0x6f:
- case 0x70:
- case 0x71:
- case 0x72:
- case 0x73:
- case 0x74:
- case 0x75:
- case 0x76:
- case 0x77:
- {
- const auto len = static_cast<size_t>(v[current_idx] - 0x60);
- const size_t offset = current_idx + 1;
- idx += len; // skip content bytes
- check_length(v.size(), len, offset);
- return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
- }
-
- case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
- {
- const auto len = static_cast<size_t>(get_from_vector<uint8_t>(v, current_idx));
- const size_t offset = current_idx + 2;
- idx += len + 1; // skip size byte + content bytes
- check_length(v.size(), len, offset);
- return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
- }
-
- case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
- {
- const auto len = static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));
- const size_t offset = current_idx + 3;
- idx += len + 2; // skip 2 size bytes + content bytes
- check_length(v.size(), len, offset);
- return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
- }
-
- case 0x7a: // UTF-8 string (four-byte uint32_t for n follow)
- {
- const auto len = static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));
- const size_t offset = current_idx + 5;
- idx += len + 4; // skip 4 size bytes + content bytes
- check_length(v.size(), len, offset);
- return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
- }
-
- case 0x7b: // UTF-8 string (eight-byte uint64_t for n follow)
- {
- const auto len = static_cast<size_t>(get_from_vector<uint64_t>(v, current_idx));
- const size_t offset = current_idx + 9;
- idx += len + 8; // skip 8 size bytes + content bytes
- check_length(v.size(), len, offset);
- return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
- }
-
- case 0x7f: // UTF-8 string (indefinite length)
- {
- std::string result;
- while (v.at(idx) != 0xff)
- {
- string_t s = from_cbor_internal(v, idx);
- result += s;
- }
- // skip break byte (0xFF)
- idx += 1;
- return result;
- }
-
- // array (0x00..0x17 data items follow)
- case 0x80:
- case 0x81:
- case 0x82:
- case 0x83:
- case 0x84:
- case 0x85:
- case 0x86:
- case 0x87:
- case 0x88:
- case 0x89:
- case 0x8a:
- case 0x8b:
- case 0x8c:
- case 0x8d:
- case 0x8e:
- case 0x8f:
- case 0x90:
- case 0x91:
- case 0x92:
- case 0x93:
- case 0x94:
- case 0x95:
- case 0x96:
- case 0x97:
- {
- basic_json result = value_t::array;
- const auto len = static_cast<size_t>(v[current_idx] - 0x80);
- for (size_t i = 0; i < len; ++i)
- {
- result.push_back(from_cbor_internal(v, idx));
- }
- return result;
- }
-
- case 0x98: // array (one-byte uint8_t for n follows)
- {
- basic_json result = value_t::array;
- const auto len = static_cast<size_t>(get_from_vector<uint8_t>(v, current_idx));
- idx += 1; // skip 1 size byte
- for (size_t i = 0; i < len; ++i)
- {
- result.push_back(from_cbor_internal(v, idx));
- }
- return result;
- }
-
- case 0x99: // array (two-byte uint16_t for n follow)
- {
- basic_json result = value_t::array;
- const auto len = static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));
- idx += 2; // skip 4 size bytes
- for (size_t i = 0; i < len; ++i)
- {
- result.push_back(from_cbor_internal(v, idx));
- }
- return result;
- }
-
- case 0x9a: // array (four-byte uint32_t for n follow)
- {
- basic_json result = value_t::array;
- const auto len = static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));
- idx += 4; // skip 4 size bytes
- for (size_t i = 0; i < len; ++i)
- {
- result.push_back(from_cbor_internal(v, idx));
- }
- return result;
- }
-
- case 0x9b: // array (eight-byte uint64_t for n follow)
- {
- basic_json result = value_t::array;
- const auto len = static_cast<size_t>(get_from_vector<uint64_t>(v, current_idx));
- idx += 8; // skip 8 size bytes
- for (size_t i = 0; i < len; ++i)
- {
- result.push_back(from_cbor_internal(v, idx));
- }
- return result;
- }
-
- case 0x9f: // array (indefinite length)
- {
- basic_json result = value_t::array;
- while (v.at(idx) != 0xff)
- {
- result.push_back(from_cbor_internal(v, idx));
- }
- // skip break byte (0xFF)
- idx += 1;
- return result;
- }
-
- // map (0x00..0x17 pairs of data items follow)
- case 0xa0:
- case 0xa1:
- case 0xa2:
- case 0xa3:
- case 0xa4:
- case 0xa5:
- case 0xa6:
- case 0xa7:
- case 0xa8:
- case 0xa9:
- case 0xaa:
- case 0xab:
- case 0xac:
- case 0xad:
- case 0xae:
- case 0xaf:
- case 0xb0:
- case 0xb1:
- case 0xb2:
- case 0xb3:
- case 0xb4:
- case 0xb5:
- case 0xb6:
- case 0xb7:
- {
- basic_json result = value_t::object;
- const auto len = static_cast<size_t>(v[current_idx] - 0xa0);
- for (size_t i = 0; i < len; ++i)
- {
- std::string key = from_cbor_internal(v, idx);
- result[key] = from_cbor_internal(v, idx);
- }
- return result;
- }
-
- case 0xb8: // map (one-byte uint8_t for n follows)
- {
- basic_json result = value_t::object;
- const auto len = static_cast<size_t>(get_from_vector<uint8_t>(v, current_idx));
- idx += 1; // skip 1 size byte
- for (size_t i = 0; i < len; ++i)
- {
- std::string key = from_cbor_internal(v, idx);
- result[key] = from_cbor_internal(v, idx);
- }
- return result;
- }
-
- case 0xb9: // map (two-byte uint16_t for n follow)
- {
- basic_json result = value_t::object;
- const auto len = static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));
- idx += 2; // skip 2 size bytes
- for (size_t i = 0; i < len; ++i)
- {
- std::string key = from_cbor_internal(v, idx);
- result[key] = from_cbor_internal(v, idx);
- }
- return result;
- }
-
- case 0xba: // map (four-byte uint32_t for n follow)
- {
- basic_json result = value_t::object;
- const auto len = static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));
- idx += 4; // skip 4 size bytes
- for (size_t i = 0; i < len; ++i)
- {
- std::string key = from_cbor_internal(v, idx);
- result[key] = from_cbor_internal(v, idx);
- }
- return result;
- }
-
- case 0xbb: // map (eight-byte uint64_t for n follow)
- {
- basic_json result = value_t::object;
- const auto len = static_cast<size_t>(get_from_vector<uint64_t>(v, current_idx));
- idx += 8; // skip 8 size bytes
- for (size_t i = 0; i < len; ++i)
- {
- std::string key = from_cbor_internal(v, idx);
- result[key] = from_cbor_internal(v, idx);
- }
- return result;
- }
-
- case 0xbf: // map (indefinite length)
- {
- basic_json result = value_t::object;
- while (v.at(idx) != 0xff)
- {
- std::string key = from_cbor_internal(v, idx);
- result[key] = from_cbor_internal(v, idx);
- }
- // skip break byte (0xFF)
- idx += 1;
- return result;
- }
-
- case 0xf4: // false
- {
- return false;
- }
-
- case 0xf5: // true
- {
- return true;
- }
-
- case 0xf6: // null
- {
- return value_t::null;
- }
-
- case 0xf9: // Half-Precision Float (two-byte IEEE 754)
- {
- idx += 2; // skip two content bytes
-
- // code from RFC 7049, Appendix D, Figure 3:
- // As half-precision floating-point numbers were only added to
- // IEEE 754 in 2008, today's programming platforms often still
- // only have limited support for them. It is very easy to
- // include at least decoding support for them even without such
- // support. An example of a small decoder for half-precision
- // floating-point numbers in the C language is shown in Fig. 3.
- const int half = (v.at(current_idx + 1) << 8) + v.at(current_idx + 2);
- const int exp = (half >> 10) & 0x1f;
- const int mant = half & 0x3ff;
- double val;
- if (exp == 0)
- {
- val = std::ldexp(mant, -24);
- }
- else if (exp != 31)
- {
- val = std::ldexp(mant + 1024, exp - 25);
- }
- else
- {
- val = mant == 0
- ? std::numeric_limits<double>::infinity()
- : std::numeric_limits<double>::quiet_NaN();
- }
- return (half & 0x8000) != 0 ? -val : val;
- }
-
- case 0xfa: // Single-Precision Float (four-byte IEEE 754)
- {
- // copy bytes in reverse order into the float variable
- float res;
- for (size_t byte = 0; byte < sizeof(float); ++byte)
- {
- reinterpret_cast<uint8_t*>(&res)[sizeof(float) - byte - 1] = v.at(current_idx + 1 + byte);
- }
- idx += sizeof(float); // skip content bytes
- return res;
- }
-
- case 0xfb: // Double-Precision Float (eight-byte IEEE 754)
- {
- // copy bytes in reverse order into the double variable
- double res;
- for (size_t byte = 0; byte < sizeof(double); ++byte)
- {
- reinterpret_cast<uint8_t*>(&res)[sizeof(double) - byte - 1] = v.at(current_idx + 1 + byte);
- }
- idx += sizeof(double); // skip content bytes
- return res;
- }
-
- default: // anything else (0xFF is handled inside the other types)
- {
- JSON_THROW(std::invalid_argument("error parsing a CBOR @ " + std::to_string(current_idx) + ": " + std::to_string(static_cast<int>(v[current_idx]))));
- }
- }
- }
-
- public:
- /*!
- @brief create a MessagePack serialization of a given JSON value
-
- Serializes a given JSON value @a j to a byte vector using the MessagePack
- serialization format. MessagePack is a binary serialization format which
- aims to be more compact than JSON itself, yet more efficient to parse.
-
- @param[in] j JSON value to serialize
- @return MessagePack serialization as byte vector
-
- @complexity Linear in the size of the JSON value @a j.
-
- @liveexample{The example shows the serialization of a JSON value to a byte
- vector in MessagePack format.,to_msgpack}
-
- @sa http://msgpack.org
- @sa @ref from_msgpack(const std::vector<uint8_t>&, const size_t) for the
- analogous deserialization
- @sa @ref to_cbor(const basic_json& for the related CBOR format
-
- @since version 2.0.9
- */
- static std::vector<uint8_t> to_msgpack(const basic_json& j)
- {
- std::vector<uint8_t> result;
- to_msgpack_internal(j, result);
- return result;
- }
-
- /*!
- @brief create a JSON value from a byte vector in MessagePack format
-
- Deserializes a given byte vector @a v to a JSON value using the MessagePack
- serialization format.
-
- @param[in] v a byte vector in MessagePack format
- @param[in] start_index the index to start reading from @a v (0 by default)
- @return deserialized JSON value
-
- @throw std::invalid_argument if unsupported features from MessagePack were
- used in the given vector @a v or if the input is not valid MessagePack
- @throw std::out_of_range if the given vector ends prematurely
-
- @complexity Linear in the size of the byte vector @a v.
-
- @liveexample{The example shows the deserialization of a byte vector in
- MessagePack format to a JSON value.,from_msgpack}
-
- @sa http://msgpack.org
- @sa @ref to_msgpack(const basic_json&) for the analogous serialization
- @sa @ref from_cbor(const std::vector<uint8_t>&, const size_t) for the
- related CBOR format
-
- @since version 2.0.9, parameter @a start_index since 2.1.1
- */
- static basic_json from_msgpack(const std::vector<uint8_t>& v,
- const size_t start_index = 0)
- {
- size_t i = start_index;
- return from_msgpack_internal(v, i);
- }
-
- /*!
- @brief create a MessagePack serialization of a given JSON value
-
- Serializes a given JSON value @a j to a byte vector using the CBOR (Concise
- Binary Object Representation) serialization format. CBOR is a binary
- serialization format which aims to be more compact than JSON itself, yet
- more efficient to parse.
-
- @param[in] j JSON value to serialize
- @return MessagePack serialization as byte vector
-
- @complexity Linear in the size of the JSON value @a j.
-
- @liveexample{The example shows the serialization of a JSON value to a byte
- vector in CBOR format.,to_cbor}
-
- @sa http://cbor.io
- @sa @ref from_cbor(const std::vector<uint8_t>&, const size_t) for the
- analogous deserialization
- @sa @ref to_msgpack(const basic_json& for the related MessagePack format
-
- @since version 2.0.9
- */
- static std::vector<uint8_t> to_cbor(const basic_json& j)
- {
- std::vector<uint8_t> result;
- to_cbor_internal(j, result);
- return result;
- }
-
- /*!
- @brief create a JSON value from a byte vector in CBOR format
-
- Deserializes a given byte vector @a v to a JSON value using the CBOR
- (Concise Binary Object Representation) serialization format.
-
- @param[in] v a byte vector in CBOR format
- @param[in] start_index the index to start reading from @a v (0 by default)
- @return deserialized JSON value
-
- @throw std::invalid_argument if unsupported features from CBOR were used in
- the given vector @a v or if the input is not valid MessagePack
- @throw std::out_of_range if the given vector ends prematurely
-
- @complexity Linear in the size of the byte vector @a v.
-
- @liveexample{The example shows the deserialization of a byte vector in CBOR
- format to a JSON value.,from_cbor}
-
- @sa http://cbor.io
- @sa @ref to_cbor(const basic_json&) for the analogous serialization
- @sa @ref from_msgpack(const std::vector<uint8_t>&, const size_t) for the
- related MessagePack format
-
- @since version 2.0.9, parameter @a start_index since 2.1.1
- */
- static basic_json from_cbor(const std::vector<uint8_t>& v,
- const size_t start_index = 0)
- {
- size_t i = start_index;
- return from_cbor_internal(v, i);
- }
-
- /// @}
-
- ///////////////////////////
- // convenience functions //
- ///////////////////////////
-
- /*!
- @brief return the type as string
-
- Returns the type name as string to be used in error messages - usually to
- indicate that a function was called on a wrong JSON type.
-
- @return basically a string representation of a the @a m_type member
-
- @complexity Constant.
-
- @liveexample{The following code exemplifies `type_name()` for all JSON
- types.,type_name}
-
- @since version 1.0.0, public since 2.1.0
- */
- std::string type_name() const
- {
- {
- switch (m_type)
- {
- case value_t::null:
- return "null";
- case value_t::object:
- return "object";
- case value_t::array:
- return "array";
- case value_t::string:
- return "string";
- case value_t::boolean:
- return "boolean";
- case value_t::discarded:
- return "discarded";
- default:
- return "number";
- }
- }
- }
-
- private:
- /*!
- @brief calculates the extra space to escape a JSON string
-
- @param[in] s the string to escape
- @return the number of characters required to escape string @a s
-
- @complexity Linear in the length of string @a s.
- */
- static std::size_t extra_space(const string_t& s) noexcept
- {
- return std::accumulate(s.begin(), s.end(), size_t{},
- [](size_t res, typename string_t::value_type c)
- {
- switch (c)
- {
- case '"':
- case '\\':
- case '\b':
- case '\f':
- case '\n':
- case '\r':
- case '\t':
- {
- // from c (1 byte) to \x (2 bytes)
- return res + 1;
- }
-
- default:
- {
- if (c >= 0x00 and c <= 0x1f)
- {
- // from c (1 byte) to \uxxxx (6 bytes)
- return res + 5;
- }
-
- return res;
- }
- }
- });
- }
-
- /*!
- @brief escape a string
-
- Escape a string by replacing certain special characters by a sequence of
- an escape character (backslash) and another character and other control
- characters by a sequence of "\u" followed by a four-digit hex
- representation.
-
- @param[in] s the string to escape
- @return the escaped string
-
- @complexity Linear in the length of string @a s.
- */
- static string_t escape_string(const string_t& s)
- {
- const auto space = extra_space(s);
- if (space == 0)
- {
- return s;
- }
-
- // create a result string of necessary size
- string_t result(s.size() + space, '\\');
- std::size_t pos = 0;
-
- for (const auto& c : s)
- {
- switch (c)
- {
- // quotation mark (0x22)
- case '"':
- {
- result[pos + 1] = '"';
- pos += 2;
- break;
- }
-
- // reverse solidus (0x5c)
- case '\\':
- {
- // nothing to change
- pos += 2;
- break;
- }
-
- // backspace (0x08)
- case '\b':
- {
- result[pos + 1] = 'b';
- pos += 2;
- break;
- }
-
- // formfeed (0x0c)
- case '\f':
- {
- result[pos + 1] = 'f';
- pos += 2;
- break;
- }
-
- // newline (0x0a)
- case '\n':
- {
- result[pos + 1] = 'n';
- pos += 2;
- break;
- }
-
- // carriage return (0x0d)
- case '\r':
- {
- result[pos + 1] = 'r';
- pos += 2;
- break;
- }
-
- // horizontal tab (0x09)
- case '\t':
- {
- result[pos + 1] = 't';
- pos += 2;
- break;
- }
-
- default:
- {
- if (c >= 0x00 and c <= 0x1f)
- {
- // convert a number 0..15 to its hex representation
- // (0..f)
- static const char hexify[16] =
- {
- '0', '1', '2', '3', '4', '5', '6', '7',
- '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
- };
-
- // print character c as \uxxxx
- for (const char m :
- { 'u', '0', '0', hexify[c >> 4], hexify[c & 0x0f]
- })
- {
- result[++pos] = m;
- }
-
- ++pos;
- }
- else
- {
- // all other characters are added as-is
- result[pos++] = c;
- }
- break;
- }
- }
- }
-
- return result;
- }
-
-
- /*!
- @brief locale-independent serialization for built-in arithmetic types
- */
- struct numtostr
- {
- public:
- template<typename NumberType>
- numtostr(NumberType value)
- {
- x_write(value, std::is_integral<NumberType>());
- }
-
- const char* c_str() const
- {
- return m_buf.data();
- }
-
- private:
- /// a (hopefully) large enough character buffer
- std::array < char, 64 > m_buf{{}};
-
- template<typename NumberType>
- void x_write(NumberType x, /*is_integral=*/std::true_type)
- {
- // special case for "0"
- if (x == 0)
- {
- m_buf[0] = '0';
- return;
- }
-
- const bool is_negative = x < 0;
- size_t i = 0;
-
- // spare 1 byte for '\0'
- while (x != 0 and i < m_buf.size() - 1)
- {
- const auto digit = std::labs(static_cast<long>(x % 10));
- m_buf[i++] = static_cast<char>('0' + digit);
- x /= 10;
- }
-
- // make sure the number has been processed completely
- assert(x == 0);
-
- if (is_negative)
- {
- // make sure there is capacity for the '-'
- assert(i < m_buf.size() - 2);
- m_buf[i++] = '-';
- }
-
- std::reverse(m_buf.begin(), m_buf.begin() + i);
- }
-
- template<typename NumberType>
- void x_write(NumberType x, /*is_integral=*/std::false_type)
- {
- // special case for 0.0 and -0.0
- if (x == 0)
- {
- size_t i = 0;
- if (std::signbit(x))
- {
- m_buf[i++] = '-';
- }
- m_buf[i++] = '0';
- m_buf[i++] = '.';
- m_buf[i] = '0';
- return;
- }
-
- // get number of digits for a text -> float -> text round-trip
- static constexpr auto d = std::numeric_limits<NumberType>::digits10;
-
- // the actual conversion
- const auto written_bytes = snprintf(m_buf.data(), m_buf.size(), "%.*g", d, x);
-
- // negative value indicates an error
- assert(written_bytes > 0);
- // check if buffer was large enough
- assert(static_cast<size_t>(written_bytes) < m_buf.size());
-
- // read information from locale
- const auto loc = localeconv();
- assert(loc != nullptr);
- const char thousands_sep = !loc->thousands_sep ? '\0'
- : loc->thousands_sep[0];
-
- const char decimal_point = !loc->decimal_point ? '\0'
- : loc->decimal_point[0];
-
- // erase thousands separator
- if (thousands_sep != '\0')
- {
- const auto end = std::remove(m_buf.begin(), m_buf.begin() + written_bytes, thousands_sep);
- std::fill(end, m_buf.end(), '\0');
- }
-
- // convert decimal point to '.'
- if (decimal_point != '\0' and decimal_point != '.')
- {
- for (auto& c : m_buf)
- {
- if (c == decimal_point)
- {
- c = '.';
- break;
- }
- }
- }
-
- // determine if need to append ".0"
- size_t i = 0;
- bool value_is_int_like = true;
- for (i = 0; i < m_buf.size(); ++i)
- {
- // break when end of number is reached
- if (m_buf[i] == '\0')
- {
- break;
- }
-
- // check if we find non-int character
- value_is_int_like = value_is_int_like and m_buf[i] != '.' and
- m_buf[i] != 'e' and m_buf[i] != 'E';
- }
-
- if (value_is_int_like)
- {
- // there must be 2 bytes left for ".0"
- assert((i + 2) < m_buf.size());
- // we write to the end of the number
- assert(m_buf[i] == '\0');
- assert(m_buf[i - 1] != '\0');
-
- // add ".0"
- m_buf[i] = '.';
- m_buf[i + 1] = '0';
-
- // the resulting string is properly terminated
- assert(m_buf[i + 2] == '\0');
- }
- }
- };
-
-
- /*!
- @brief internal implementation of the serialization function
-
- This function is called by the public member function dump and organizes
- the serialization internally. The indentation level is propagated as
- additional parameter. In case of arrays and objects, the function is
- called recursively. Note that
-
- - strings and object keys are escaped using `escape_string()`
- - integer numbers are converted implicitly via `operator<<`
- - floating-point numbers are converted to a string using `"%g"` format
-
- @param[out] o stream to write to
- @param[in] pretty_print whether the output shall be pretty-printed
- @param[in] indent_step the indent level
- @param[in] current_indent the current indent level (only used internally)
- */
- void dump(std::ostream& o,
- const bool pretty_print,
- const unsigned int indent_step,
- const unsigned int current_indent = 0) const
- {
- // variable to hold indentation for recursive calls
- unsigned int new_indent = current_indent;
-
- switch (m_type)
- {
- case value_t::object:
- {
- if (m_value.object->empty())
- {
- o << "{}";
- return;
- }
-
- o << "{";
-
- // increase indentation
- if (pretty_print)
- {
- new_indent += indent_step;
- o << "\n";
- }
-
- for (auto i = m_value.object->cbegin(); i != m_value.object->cend(); ++i)
- {
- if (i != m_value.object->cbegin())
- {
- o << (pretty_print ? ",\n" : ",");
- }
- o << string_t(new_indent, ' ') << "\""
- << escape_string(i->first) << "\":"
- << (pretty_print ? " " : "");
- i->second.dump(o, pretty_print, indent_step, new_indent);
- }
-
- // decrease indentation
- if (pretty_print)
- {
- new_indent -= indent_step;
- o << "\n";
- }
-
- o << string_t(new_indent, ' ') + "}";
- return;
- }
-
- case value_t::array:
- {
- if (m_value.array->empty())
- {
- o << "[]";
- return;
- }
-
- o << "[";
-
- // increase indentation
- if (pretty_print)
- {
- new_indent += indent_step;
- o << "\n";
- }
-
- for (auto i = m_value.array->cbegin(); i != m_value.array->cend(); ++i)
- {
- if (i != m_value.array->cbegin())
- {
- o << (pretty_print ? ",\n" : ",");
- }
- o << string_t(new_indent, ' ');
- i->dump(o, pretty_print, indent_step, new_indent);
- }
-
- // decrease indentation
- if (pretty_print)
- {
- new_indent -= indent_step;
- o << "\n";
- }
-
- o << string_t(new_indent, ' ') << "]";
- return;
- }
-
- case value_t::string:
- {
- o << string_t("\"") << escape_string(*m_value.string) << "\"";
- return;
- }
-
- case value_t::boolean:
- {
- o << (m_value.boolean ? "true" : "false");
- return;
- }
-
- case value_t::number_integer:
- {
- o << numtostr(m_value.number_integer).c_str();
- return;
- }
-
- case value_t::number_unsigned:
- {
- o << numtostr(m_value.number_unsigned).c_str();
- return;
- }
-
- case value_t::number_float:
- {
- o << numtostr(m_value.number_float).c_str();
- return;
- }
-
- case value_t::discarded:
- {
- o << "<discarded>";
- return;
- }
-
- case value_t::null:
- {
- o << "null";
- return;
- }
- }
- }
-
- private:
- //////////////////////
- // member variables //
- //////////////////////
-
- /// the type of the current element
- value_t m_type = value_t::null;
-
- /// the value of the current element
- json_value m_value = {};
-
-
- private:
- ///////////////
- // iterators //
- ///////////////
-
- /*!
- @brief an iterator for primitive JSON types
-
- This class models an iterator for primitive JSON types (boolean, number,
- string). It's only purpose is to allow the iterator/const_iterator classes
- to "iterate" over primitive values. Internally, the iterator is modeled by
- a `difference_type` variable. Value begin_value (`0`) models the begin,
- end_value (`1`) models past the end.
- */
- class primitive_iterator_t
- {
- public:
-
- difference_type get_value() const noexcept
- {
- return m_it;
- }
- /// set iterator to a defined beginning
- void set_begin() noexcept
- {
- m_it = begin_value;
- }
-
- /// set iterator to a defined past the end
- void set_end() noexcept
- {
- m_it = end_value;
- }
-
- /// return whether the iterator can be dereferenced
- constexpr bool is_begin() const noexcept
- {
- return (m_it == begin_value);
- }
-
- /// return whether the iterator is at end
- constexpr bool is_end() const noexcept
- {
- return (m_it == end_value);
- }
-
- friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
- {
- return lhs.m_it == rhs.m_it;
- }
-
- friend constexpr bool operator!=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
- {
- return !(lhs == rhs);
- }
-
- friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
- {
- return lhs.m_it < rhs.m_it;
- }
-
- friend constexpr bool operator<=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
- {
- return lhs.m_it <= rhs.m_it;
- }
-
- friend constexpr bool operator>(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
- {
- return lhs.m_it > rhs.m_it;
- }
-
- friend constexpr bool operator>=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
- {
- return lhs.m_it >= rhs.m_it;
- }
-
- primitive_iterator_t operator+(difference_type i)
- {
- auto result = *this;
- result += i;
- return result;
- }
-
- friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
- {
- return lhs.m_it - rhs.m_it;
- }
-
- friend std::ostream& operator<<(std::ostream& os, primitive_iterator_t it)
- {
- return os << it.m_it;
- }
-
- primitive_iterator_t& operator++()
- {
- ++m_it;
- return *this;
- }
-
- primitive_iterator_t operator++(int)
- {
- auto result = *this;
- m_it++;
- return result;
- }
-
- primitive_iterator_t& operator--()
- {
- --m_it;
- return *this;
- }
-
- primitive_iterator_t operator--(int)
- {
- auto result = *this;
- m_it--;
- return result;
- }
-
- primitive_iterator_t& operator+=(difference_type n)
- {
- m_it += n;
- return *this;
- }
-
- primitive_iterator_t& operator-=(difference_type n)
- {
- m_it -= n;
- return *this;
- }
-
- private:
- static constexpr difference_type begin_value = 0;
- static constexpr difference_type end_value = begin_value + 1;
-
- /// iterator as signed integer type
- difference_type m_it = std::numeric_limits<std::ptrdiff_t>::denorm_min();
- };
-
- /*!
- @brief an iterator value
-
- @note This structure could easily be a union, but MSVC currently does not
- allow unions members with complex constructors, see
- https://github.com/nlohmann/json/pull/105.
- */
- struct internal_iterator
- {
- /// iterator for JSON objects
- typename object_t::iterator object_iterator;
- /// iterator for JSON arrays
- typename array_t::iterator array_iterator;
- /// generic iterator for all other types
- primitive_iterator_t primitive_iterator;
-
- /// create an uninitialized internal_iterator
- internal_iterator() noexcept
- : object_iterator(), array_iterator(), primitive_iterator()
- {}
- };
-
- /// proxy class for the iterator_wrapper functions
- template<typename IteratorType>
- class iteration_proxy
- {
- private:
- /// helper class for iteration
- class iteration_proxy_internal
- {
- private:
- /// the iterator
- IteratorType anchor;
- /// an index for arrays (used to create key names)
- size_t array_index = 0;
-
- public:
- explicit iteration_proxy_internal(IteratorType it) noexcept
- : anchor(it)
- {}
-
- /// dereference operator (needed for range-based for)
- iteration_proxy_internal& operator*()
- {
- return *this;
- }
-
- /// increment operator (needed for range-based for)
- iteration_proxy_internal& operator++()
- {
- ++anchor;
- ++array_index;
-
- return *this;
- }
-
- /// inequality operator (needed for range-based for)
- bool operator!= (const iteration_proxy_internal& o) const
- {
- return anchor != o.anchor;
- }
-
- /// return key of the iterator
- typename basic_json::string_t key() const
- {
- assert(anchor.m_object != nullptr);
-
- switch (anchor.m_object->type())
- {
- // use integer array index as key
- case value_t::array:
- {
- return std::to_string(array_index);
- }
-
- // use key from the object
- case value_t::object:
- {
- return anchor.key();
- }
-
- // use an empty key for all primitive types
- default:
- {
- return "";
- }
- }
- }
-
- /// return value of the iterator
- typename IteratorType::reference value() const
- {
- return anchor.value();
- }
- };
-
- /// the container to iterate
- typename IteratorType::reference container;
-
- public:
- /// construct iteration proxy from a container
- explicit iteration_proxy(typename IteratorType::reference cont)
- : container(cont)
- {}
-
- /// return iterator begin (needed for range-based for)
- iteration_proxy_internal begin() noexcept
- {
- return iteration_proxy_internal(container.begin());
- }
-
- /// return iterator end (needed for range-based for)
- iteration_proxy_internal end() noexcept
- {
- return iteration_proxy_internal(container.end());
- }
- };
-
- public:
- /*!
- @brief a template for a random access iterator for the @ref basic_json class
-
- This class implements a both iterators (iterator and const_iterator) for the
- @ref basic_json class.
-
- @note An iterator is called *initialized* when a pointer to a JSON value
- has been set (e.g., by a constructor or a copy assignment). If the
- iterator is default-constructed, it is *uninitialized* and most
- methods are undefined. **The library uses assertions to detect calls
- on uninitialized iterators.**
-
- @requirement The class satisfies the following concept requirements:
- - [RandomAccessIterator](http://en.cppreference.com/w/cpp/concept/RandomAccessIterator):
- The iterator that can be moved to point (forward and backward) to any
- element in constant time.
-
- @since version 1.0.0, simplified in version 2.0.9
- */
- template<typename U>
- class iter_impl : public std::iterator<std::random_access_iterator_tag, U>
- {
- /// allow basic_json to access private members
- friend class basic_json;
-
- // make sure U is basic_json or const basic_json
- static_assert(std::is_same<U, basic_json>::value
- or std::is_same<U, const basic_json>::value,
- "iter_impl only accepts (const) basic_json");
-
- public:
- /// the type of the values when the iterator is dereferenced
- using value_type = typename basic_json::value_type;
- /// a type to represent differences between iterators
- using difference_type = typename basic_json::difference_type;
- /// defines a pointer to the type iterated over (value_type)
- using pointer = typename std::conditional<std::is_const<U>::value,
- typename basic_json::const_pointer,
- typename basic_json::pointer>::type;
- /// defines a reference to the type iterated over (value_type)
- using reference = typename std::conditional<std::is_const<U>::value,
- typename basic_json::const_reference,
- typename basic_json::reference>::type;
- /// the category of the iterator
- using iterator_category = std::bidirectional_iterator_tag;
-
- /// default constructor
- iter_impl() = default;
-
- /*!
- @brief constructor for a given JSON instance
- @param[in] object pointer to a JSON object for this iterator
- @pre object != nullptr
- @post The iterator is initialized; i.e. `m_object != nullptr`.
- */
- explicit iter_impl(pointer object) noexcept
- : m_object(object)
- {
- assert(m_object != nullptr);
-
- switch (m_object->m_type)
- {
- case basic_json::value_t::object:
- {
- m_it.object_iterator = typename object_t::iterator();
- break;
- }
-
- case basic_json::value_t::array:
- {
- m_it.array_iterator = typename array_t::iterator();
- break;
- }
-
- default:
- {
- m_it.primitive_iterator = primitive_iterator_t();
- break;
- }
- }
- }
-
- /*
- Use operator `const_iterator` instead of `const_iterator(const iterator&
- other) noexcept` to avoid two class definitions for @ref iterator and
- @ref const_iterator.
-
- This function is only called if this class is an @ref iterator. If this
- class is a @ref const_iterator this function is not called.
- */
- operator const_iterator() const
- {
- const_iterator ret;
-
- if (m_object)
- {
- ret.m_object = m_object;
- ret.m_it = m_it;
- }
-
- return ret;
- }
-
- /*!
- @brief copy constructor
- @param[in] other iterator to copy from
- @note It is not checked whether @a other is initialized.
- */
- iter_impl(const iter_impl& other) noexcept
- : m_object(other.m_object), m_it(other.m_it)
- {}
-
- /*!
- @brief copy assignment
- @param[in,out] other iterator to copy from
- @note It is not checked whether @a other is initialized.
- */
- iter_impl& operator=(iter_impl other) noexcept(
- std::is_nothrow_move_constructible<pointer>::value and
- std::is_nothrow_move_assignable<pointer>::value and
- std::is_nothrow_move_constructible<internal_iterator>::value and
- std::is_nothrow_move_assignable<internal_iterator>::value
- )
- {
- std::swap(m_object, other.m_object);
- std::swap(m_it, other.m_it);
- return *this;
- }
-
- private:
- /*!
- @brief set the iterator to the first value
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- void set_begin() noexcept
- {
- assert(m_object != nullptr);
-
- switch (m_object->m_type)
- {
- case basic_json::value_t::object:
- {
- m_it.object_iterator = m_object->m_value.object->begin();
- break;
- }
-
- case basic_json::value_t::array:
- {
- m_it.array_iterator = m_object->m_value.array->begin();
- break;
- }
-
- case basic_json::value_t::null:
- {
- // set to end so begin()==end() is true: null is empty
- m_it.primitive_iterator.set_end();
- break;
- }
-
- default:
- {
- m_it.primitive_iterator.set_begin();
- break;
- }
- }
- }
-
- /*!
- @brief set the iterator past the last value
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- void set_end() noexcept
- {
- assert(m_object != nullptr);
-
- switch (m_object->m_type)
- {
- case basic_json::value_t::object:
- {
- m_it.object_iterator = m_object->m_value.object->end();
- break;
- }
-
- case basic_json::value_t::array:
- {
- m_it.array_iterator = m_object->m_value.array->end();
- break;
- }
-
- default:
- {
- m_it.primitive_iterator.set_end();
- break;
- }
- }
- }
-
- public:
- /*!
- @brief return a reference to the value pointed to by the iterator
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- reference operator*() const
- {
- assert(m_object != nullptr);
-
- switch (m_object->m_type)
- {
- case basic_json::value_t::object:
- {
- assert(m_it.object_iterator != m_object->m_value.object->end());
- return m_it.object_iterator->second;
- }
-
- case basic_json::value_t::array:
- {
- assert(m_it.array_iterator != m_object->m_value.array->end());
- return *m_it.array_iterator;
- }
-
- case basic_json::value_t::null:
- {
- JSON_THROW(std::out_of_range("cannot get value"));
- }
-
- default:
- {
- if (m_it.primitive_iterator.is_begin())
- {
- return *m_object;
- }
-
- JSON_THROW(std::out_of_range("cannot get value"));
- }
- }
- }
-
- /*!
- @brief dereference the iterator
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- pointer operator->() const
- {
- assert(m_object != nullptr);
-
- switch (m_object->m_type)
- {
- case basic_json::value_t::object:
- {
- assert(m_it.object_iterator != m_object->m_value.object->end());
- return &(m_it.object_iterator->second);
- }
-
- case basic_json::value_t::array:
- {
- assert(m_it.array_iterator != m_object->m_value.array->end());
- return &*m_it.array_iterator;
- }
-
- default:
- {
- if (m_it.primitive_iterator.is_begin())
- {
- return m_object;
- }
-
- JSON_THROW(std::out_of_range("cannot get value"));
- }
- }
- }
-
- /*!
- @brief post-increment (it++)
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- iter_impl operator++(int)
- {
- auto result = *this;
- ++(*this);
- return result;
- }
-
- /*!
- @brief pre-increment (++it)
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- iter_impl& operator++()
- {
- assert(m_object != nullptr);
-
- switch (m_object->m_type)
- {
- case basic_json::value_t::object:
- {
- std::advance(m_it.object_iterator, 1);
- break;
- }
-
- case basic_json::value_t::array:
- {
- std::advance(m_it.array_iterator, 1);
- break;
- }
-
- default:
- {
- ++m_it.primitive_iterator;
- break;
- }
- }
-
- return *this;
- }
-
- /*!
- @brief post-decrement (it--)
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- iter_impl operator--(int)
- {
- auto result = *this;
- --(*this);
- return result;
- }
-
- /*!
- @brief pre-decrement (--it)
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- iter_impl& operator--()
- {
- assert(m_object != nullptr);
-
- switch (m_object->m_type)
- {
- case basic_json::value_t::object:
- {
- std::advance(m_it.object_iterator, -1);
- break;
- }
-
- case basic_json::value_t::array:
- {
- std::advance(m_it.array_iterator, -1);
- break;
- }
-
- default:
- {
- --m_it.primitive_iterator;
- break;
- }
- }
-
- return *this;
- }
-
- /*!
- @brief comparison: equal
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- bool operator==(const iter_impl& other) const
- {
- // if objects are not the same, the comparison is undefined
- if (m_object != other.m_object)
- {
- JSON_THROW(std::domain_error("cannot compare iterators of different containers"));
- }
-
- assert(m_object != nullptr);
-
- switch (m_object->m_type)
- {
- case basic_json::value_t::object:
- {
- return (m_it.object_iterator == other.m_it.object_iterator);
- }
-
- case basic_json::value_t::array:
- {
- return (m_it.array_iterator == other.m_it.array_iterator);
- }
-
- default:
- {
- return (m_it.primitive_iterator == other.m_it.primitive_iterator);
- }
- }
- }
-
- /*!
- @brief comparison: not equal
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- bool operator!=(const iter_impl& other) const
- {
- return not operator==(other);
- }
-
- /*!
- @brief comparison: smaller
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- bool operator<(const iter_impl& other) const
- {
- // if objects are not the same, the comparison is undefined
- if (m_object != other.m_object)
- {
- JSON_THROW(std::domain_error("cannot compare iterators of different containers"));
- }
-
- assert(m_object != nullptr);
-
- switch (m_object->m_type)
- {
- case basic_json::value_t::object:
- {
- JSON_THROW(std::domain_error("cannot compare order of object iterators"));
- }
-
- case basic_json::value_t::array:
- {
- return (m_it.array_iterator < other.m_it.array_iterator);
- }
-
- default:
- {
- return (m_it.primitive_iterator < other.m_it.primitive_iterator);
- }
- }
- }
-
- /*!
- @brief comparison: less than or equal
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- bool operator<=(const iter_impl& other) const
- {
- return not other.operator < (*this);
- }
-
- /*!
- @brief comparison: greater than
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- bool operator>(const iter_impl& other) const
- {
- return not operator<=(other);
- }
-
- /*!
- @brief comparison: greater than or equal
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- bool operator>=(const iter_impl& other) const
- {
- return not operator<(other);
- }
-
- /*!
- @brief add to iterator
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- iter_impl& operator+=(difference_type i)
- {
- assert(m_object != nullptr);
-
- switch (m_object->m_type)
- {
- case basic_json::value_t::object:
- {
- JSON_THROW(std::domain_error("cannot use offsets with object iterators"));
- }
-
- case basic_json::value_t::array:
- {
- std::advance(m_it.array_iterator, i);
- break;
- }
-
- default:
- {
- m_it.primitive_iterator += i;
- break;
- }
- }
-
- return *this;
- }
-
- /*!
- @brief subtract from iterator
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- iter_impl& operator-=(difference_type i)
- {
- return operator+=(-i);
- }
-
- /*!
- @brief add to iterator
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- iter_impl operator+(difference_type i)
- {
- auto result = *this;
- result += i;
- return result;
- }
-
- /*!
- @brief subtract from iterator
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- iter_impl operator-(difference_type i)
- {
- auto result = *this;
- result -= i;
- return result;
- }
-
- /*!
- @brief return difference
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- difference_type operator-(const iter_impl& other) const
- {
- assert(m_object != nullptr);
-
- switch (m_object->m_type)
- {
- case basic_json::value_t::object:
- {
- JSON_THROW(std::domain_error("cannot use offsets with object iterators"));
- }
-
- case basic_json::value_t::array:
- {
- return m_it.array_iterator - other.m_it.array_iterator;
- }
-
- default:
- {
- return m_it.primitive_iterator - other.m_it.primitive_iterator;
- }
- }
- }
-
- /*!
- @brief access to successor
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- reference operator[](difference_type n) const
- {
- assert(m_object != nullptr);
-
- switch (m_object->m_type)
- {
- case basic_json::value_t::object:
- {
- JSON_THROW(std::domain_error("cannot use operator[] for object iterators"));
- }
-
- case basic_json::value_t::array:
- {
- return *std::next(m_it.array_iterator, n);
- }
-
- case basic_json::value_t::null:
- {
- JSON_THROW(std::out_of_range("cannot get value"));
- }
-
- default:
- {
- if (m_it.primitive_iterator.get_value() == -n)
- {
- return *m_object;
- }
-
- JSON_THROW(std::out_of_range("cannot get value"));
- }
- }
- }
-
- /*!
- @brief return the key of an object iterator
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- typename object_t::key_type key() const
- {
- assert(m_object != nullptr);
-
- if (m_object->is_object())
- {
- return m_it.object_iterator->first;
- }
-
- JSON_THROW(std::domain_error("cannot use key() for non-object iterators"));
- }
-
- /*!
- @brief return the value of an iterator
- @pre The iterator is initialized; i.e. `m_object != nullptr`.
- */
- reference value() const
- {
- return operator*();
- }
-
- private:
- /// associated JSON instance
- pointer m_object = nullptr;
- /// the actual iterator of the associated instance
- internal_iterator m_it = internal_iterator();
- };
-
- /*!
- @brief a template for a reverse iterator class
-
- @tparam Base the base iterator type to reverse. Valid types are @ref
- iterator (to create @ref reverse_iterator) and @ref const_iterator (to
- create @ref const_reverse_iterator).
-
- @requirement The class satisfies the following concept requirements:
- - [RandomAccessIterator](http://en.cppreference.com/w/cpp/concept/RandomAccessIterator):
- The iterator that can be moved to point (forward and backward) to any
- element in constant time.
- - [OutputIterator](http://en.cppreference.com/w/cpp/concept/OutputIterator):
- It is possible to write to the pointed-to element (only if @a Base is
- @ref iterator).
-
- @since version 1.0.0
- */
- template<typename Base>
- class json_reverse_iterator : public std::reverse_iterator<Base>
- {
- public:
- /// shortcut to the reverse iterator adaptor
- using base_iterator = std::reverse_iterator<Base>;
- /// the reference type for the pointed-to element
- using reference = typename Base::reference;
-
- /// create reverse iterator from iterator
- json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
- : base_iterator(it)
- {}
-
- /// create reverse iterator from base class
- json_reverse_iterator(const base_iterator& it) noexcept
- : base_iterator(it)
- {}
-
- /// post-increment (it++)
- json_reverse_iterator operator++(int)
- {
- return base_iterator::operator++(1);
- }
-
- /// pre-increment (++it)
- json_reverse_iterator& operator++()
- {
- base_iterator::operator++();
- return *this;
- }
-
- /// post-decrement (it--)
- json_reverse_iterator operator--(int)
- {
- return base_iterator::operator--(1);
- }
-
- /// pre-decrement (--it)
- json_reverse_iterator& operator--()
- {
- base_iterator::operator--();
- return *this;
- }
-
- /// add to iterator
- json_reverse_iterator& operator+=(difference_type i)
- {
- base_iterator::operator+=(i);
- return *this;
- }
-
- /// add to iterator
- json_reverse_iterator operator+(difference_type i) const
- {
- auto result = *this;
- result += i;
- return result;
- }
-
- /// subtract from iterator
- json_reverse_iterator operator-(difference_type i) const
- {
- auto result = *this;
- result -= i;
- return result;
- }
-
- /// return difference
- difference_type operator-(const json_reverse_iterator& other) const
- {
- return this->base() - other.base();
- }
-
- /// access to successor
- reference operator[](difference_type n) const
- {
- return *(this->operator+(n));
- }
-
- /// return the key of an object iterator
- typename object_t::key_type key() const
- {
- auto it = --this->base();
- return it.key();
- }
-
- /// return the value of an iterator
- reference value() const
- {
- auto it = --this->base();
- return it.operator * ();
- }
- };
-
-
- private:
- //////////////////////
- // lexer and parser //
- //////////////////////
-
- /*!
- @brief lexical analysis
-
- This class organizes the lexical analysis during JSON deserialization. The
- core of it is a scanner generated by [re2c](http://re2c.org) that
- processes a buffer and recognizes tokens according to RFC 7159.
- */
- class lexer
- {
- public:
- /// token types for the parser
- enum class token_type
- {
- uninitialized, ///< indicating the scanner is uninitialized
- literal_true, ///< the `true` literal
- literal_false, ///< the `false` literal
- literal_null, ///< the `null` literal
- value_string, ///< a string -- use get_string() for actual value
- value_unsigned, ///< an unsigned integer -- use get_number() for actual value
- value_integer, ///< a signed integer -- use get_number() for actual value
- value_float, ///< an floating point number -- use get_number() for actual value
- begin_array, ///< the character for array begin `[`
- begin_object, ///< the character for object begin `{`
- end_array, ///< the character for array end `]`
- end_object, ///< the character for object end `}`
- name_separator, ///< the name separator `:`
- value_separator, ///< the value separator `,`
- parse_error, ///< indicating a parse error
- end_of_input ///< indicating the end of the input buffer
- };
-
- /// the char type to use in the lexer
- using lexer_char_t = unsigned char;
-
- /// a lexer from a buffer with given length
- lexer(const lexer_char_t* buff, const size_t len) noexcept
- : m_content(buff)
- {
- assert(m_content != nullptr);
- m_start = m_cursor = m_content;
- m_limit = m_content + len;
- }
-
- /// a lexer from an input stream
- explicit lexer(std::istream& s)
- : m_stream(&s), m_line_buffer()
- {
- // immediately abort if stream is erroneous
- if (s.fail())
- {
- JSON_THROW(std::invalid_argument("stream error"));
- }
-
- // fill buffer
- fill_line_buffer();
-
- // skip UTF-8 byte-order mark
- if (m_line_buffer.size() >= 3 and m_line_buffer.substr(0, 3) == "\xEF\xBB\xBF")
- {
- m_line_buffer[0] = ' ';
- m_line_buffer[1] = ' ';
- m_line_buffer[2] = ' ';
- }
- }
-
- // switch off unwanted functions (due to pointer members)
- lexer() = delete;
- lexer(const lexer&) = delete;
- lexer operator=(const lexer&) = delete;
-
- /*!
- @brief create a string from one or two Unicode code points
-
- There are two cases: (1) @a codepoint1 is in the Basic Multilingual
- Plane (U+0000 through U+FFFF) and @a codepoint2 is 0, or (2)
- @a codepoint1 and @a codepoint2 are a UTF-16 surrogate pair to
- represent a code point above U+FFFF.
-
- @param[in] codepoint1 the code point (can be high surrogate)
- @param[in] codepoint2 the code point (can be low surrogate or 0)
-
- @return string representation of the code point; the length of the
- result string is between 1 and 4 characters.
-
- @throw std::out_of_range if code point is > 0x10ffff; example: `"code
- points above 0x10FFFF are invalid"`
- @throw std::invalid_argument if the low surrogate is invalid; example:
- `""missing or wrong low surrogate""`
-
- @complexity Constant.
-
- @see <http://en.wikipedia.org/wiki/UTF-8#Sample_code>
- */
- static string_t to_unicode(const std::size_t codepoint1,
- const std::size_t codepoint2 = 0)
- {
- // calculate the code point from the given code points
- std::size_t codepoint = codepoint1;
-
- // check if codepoint1 is a high surrogate
- if (codepoint1 >= 0xD800 and codepoint1 <= 0xDBFF)
- {
- // check if codepoint2 is a low surrogate
- if (codepoint2 >= 0xDC00 and codepoint2 <= 0xDFFF)
- {
- codepoint =
- // high surrogate occupies the most significant 22 bits
- (codepoint1 << 10)
- // low surrogate occupies the least significant 15 bits
- + codepoint2
- // there is still the 0xD800, 0xDC00 and 0x10000 noise
- // in the result so we have to subtract with:
- // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
- - 0x35FDC00;
- }
- else
- {
- JSON_THROW(std::invalid_argument("missing or wrong low surrogate"));
- }
- }
-
- string_t result;
-
- if (codepoint < 0x80)
- {
- // 1-byte characters: 0xxxxxxx (ASCII)
- result.append(1, static_cast<typename string_t::value_type>(codepoint));
- }
- else if (codepoint <= 0x7ff)
- {
- // 2-byte characters: 110xxxxx 10xxxxxx
- result.append(1, static_cast<typename string_t::value_type>(0xC0 | ((codepoint >> 6) & 0x1F)));
- result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
- }
- else if (codepoint <= 0xffff)
- {
- // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
- result.append(1, static_cast<typename string_t::value_type>(0xE0 | ((codepoint >> 12) & 0x0F)));
- result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
- result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
- }
- else if (codepoint <= 0x10ffff)
- {
- // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
- result.append(1, static_cast<typename string_t::value_type>(0xF0 | ((codepoint >> 18) & 0x07)));
- result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 12) & 0x3F)));
- result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
- result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
- }
- else
- {
- JSON_THROW(std::out_of_range("code points above 0x10FFFF are invalid"));
- }
-
- return result;
- }
-
- /// return name of values of type token_type (only used for errors)
- static std::string token_type_name(const token_type t)
- {
- switch (t)
- {
- case token_type::uninitialized:
- return "<uninitialized>";
- case token_type::literal_true:
- return "true literal";
- case token_type::literal_false:
- return "false literal";
- case token_type::literal_null:
- return "null literal";
- case token_type::value_string:
- return "string literal";
- case lexer::token_type::value_unsigned:
- case lexer::token_type::value_integer:
- case lexer::token_type::value_float:
- return "number literal";
- case token_type::begin_array:
- return "'['";
- case token_type::begin_object:
- return "'{'";
- case token_type::end_array:
- return "']'";
- case token_type::end_object:
- return "'}'";
- case token_type::name_separator:
- return "':'";
- case token_type::value_separator:
- return "','";
- case token_type::parse_error:
- return "<parse error>";
- case token_type::end_of_input:
- return "end of input";
- default:
- {
- // catch non-enum values
- return "unknown token"; // LCOV_EXCL_LINE
- }
- }
- }
-
- /*!
- This function implements a scanner for JSON. It is specified using
- regular expressions that try to follow RFC 7159 as close as possible.
- These regular expressions are then translated into a minimized
- deterministic finite automaton (DFA) by the tool
- [re2c](http://re2c.org). As a result, the translated code for this
- function consists of a large block of code with `goto` jumps.
-
- @return the class of the next token read from the buffer
-
- @complexity Linear in the length of the input.\n
-
- Proposition: The loop below will always terminate for finite input.\n
-
- Proof (by contradiction): Assume a finite input. To loop forever, the
- loop must never hit code with a `break` statement. The only code
- snippets without a `break` statement are the continue statements for
- whitespace and byte-order-marks. To loop forever, the input must be an
- infinite sequence of whitespace or byte-order-marks. This contradicts
- the assumption of finite input, q.e.d.
- */
- token_type scan()
- {
- while (true)
- {
- // pointer for backtracking information
- m_marker = nullptr;
-
- // remember the begin of the token
- m_start = m_cursor;
- assert(m_start != nullptr);
-
-
- {
- lexer_char_t yych;
- unsigned int yyaccept = 0;
- static const unsigned char yybm[] =
- {
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 32, 32, 0, 0, 32, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 160, 128, 0, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 192, 192, 192, 192, 192, 192, 192, 192,
- 192, 192, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 0, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- };
- if ((m_limit - m_cursor) < 5)
- {
- fill_line_buffer(5); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yybm[0 + yych] & 32)
- {
- goto basic_json_parser_6;
- }
- if (yych <= '[')
- {
- if (yych <= '-')
- {
- if (yych <= '"')
- {
- if (yych <= 0x00)
- {
- goto basic_json_parser_2;
- }
- if (yych <= '!')
- {
- goto basic_json_parser_4;
- }
- goto basic_json_parser_9;
- }
- else
- {
- if (yych <= '+')
- {
- goto basic_json_parser_4;
- }
- if (yych <= ',')
- {
- goto basic_json_parser_10;
- }
- goto basic_json_parser_12;
- }
- }
- else
- {
- if (yych <= '9')
- {
- if (yych <= '/')
- {
- goto basic_json_parser_4;
- }
- if (yych <= '0')
- {
- goto basic_json_parser_13;
- }
- goto basic_json_parser_15;
- }
- else
- {
- if (yych <= ':')
- {
- goto basic_json_parser_17;
- }
- if (yych <= 'Z')
- {
- goto basic_json_parser_4;
- }
- goto basic_json_parser_19;
- }
- }
- }
- else
- {
- if (yych <= 'n')
- {
- if (yych <= 'e')
- {
- if (yych == ']')
- {
- goto basic_json_parser_21;
- }
- goto basic_json_parser_4;
- }
- else
- {
- if (yych <= 'f')
- {
- goto basic_json_parser_23;
- }
- if (yych <= 'm')
- {
- goto basic_json_parser_4;
- }
- goto basic_json_parser_24;
- }
- }
- else
- {
- if (yych <= 'z')
- {
- if (yych == 't')
- {
- goto basic_json_parser_25;
- }
- goto basic_json_parser_4;
- }
- else
- {
- if (yych <= '{')
- {
- goto basic_json_parser_26;
- }
- if (yych == '}')
- {
- goto basic_json_parser_28;
- }
- goto basic_json_parser_4;
- }
- }
- }
-basic_json_parser_2:
- ++m_cursor;
- {
- last_token_type = token_type::end_of_input;
- break;
- }
-basic_json_parser_4:
- ++m_cursor;
-basic_json_parser_5:
- {
- last_token_type = token_type::parse_error;
- break;
- }
-basic_json_parser_6:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yybm[0 + yych] & 32)
- {
- goto basic_json_parser_6;
- }
- {
- continue;
- }
-basic_json_parser_9:
- yyaccept = 0;
- yych = *(m_marker = ++m_cursor);
- if (yych <= 0x1F)
- {
- goto basic_json_parser_5;
- }
- if (yych <= 0x7F)
- {
- goto basic_json_parser_31;
- }
- if (yych <= 0xC1)
- {
- goto basic_json_parser_5;
- }
- if (yych <= 0xF4)
- {
- goto basic_json_parser_31;
- }
- goto basic_json_parser_5;
-basic_json_parser_10:
- ++m_cursor;
- {
- last_token_type = token_type::value_separator;
- break;
- }
-basic_json_parser_12:
- yych = *++m_cursor;
- if (yych <= '/')
- {
- goto basic_json_parser_5;
- }
- if (yych <= '0')
- {
- goto basic_json_parser_43;
- }
- if (yych <= '9')
- {
- goto basic_json_parser_45;
- }
- goto basic_json_parser_5;
-basic_json_parser_13:
- yyaccept = 1;
- yych = *(m_marker = ++m_cursor);
- if (yych <= '9')
- {
- if (yych == '.')
- {
- goto basic_json_parser_47;
- }
- if (yych >= '0')
- {
- goto basic_json_parser_48;
- }
- }
- else
- {
- if (yych <= 'E')
- {
- if (yych >= 'E')
- {
- goto basic_json_parser_51;
- }
- }
- else
- {
- if (yych == 'e')
- {
- goto basic_json_parser_51;
- }
- }
- }
-basic_json_parser_14:
- {
- last_token_type = token_type::value_unsigned;
- break;
- }
-basic_json_parser_15:
- yyaccept = 1;
- m_marker = ++m_cursor;
- if ((m_limit - m_cursor) < 3)
- {
- fill_line_buffer(3); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yybm[0 + yych] & 64)
- {
- goto basic_json_parser_15;
- }
- if (yych <= 'D')
- {
- if (yych == '.')
- {
- goto basic_json_parser_47;
- }
- goto basic_json_parser_14;
- }
- else
- {
- if (yych <= 'E')
- {
- goto basic_json_parser_51;
- }
- if (yych == 'e')
- {
- goto basic_json_parser_51;
- }
- goto basic_json_parser_14;
- }
-basic_json_parser_17:
- ++m_cursor;
- {
- last_token_type = token_type::name_separator;
- break;
- }
-basic_json_parser_19:
- ++m_cursor;
- {
- last_token_type = token_type::begin_array;
- break;
- }
-basic_json_parser_21:
- ++m_cursor;
- {
- last_token_type = token_type::end_array;
- break;
- }
-basic_json_parser_23:
- yyaccept = 0;
- yych = *(m_marker = ++m_cursor);
- if (yych == 'a')
- {
- goto basic_json_parser_52;
- }
- goto basic_json_parser_5;
-basic_json_parser_24:
- yyaccept = 0;
- yych = *(m_marker = ++m_cursor);
- if (yych == 'u')
- {
- goto basic_json_parser_53;
- }
- goto basic_json_parser_5;
-basic_json_parser_25:
- yyaccept = 0;
- yych = *(m_marker = ++m_cursor);
- if (yych == 'r')
- {
- goto basic_json_parser_54;
- }
- goto basic_json_parser_5;
-basic_json_parser_26:
- ++m_cursor;
- {
- last_token_type = token_type::begin_object;
- break;
- }
-basic_json_parser_28:
- ++m_cursor;
- {
- last_token_type = token_type::end_object;
- break;
- }
-basic_json_parser_30:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
-basic_json_parser_31:
- if (yybm[0 + yych] & 128)
- {
- goto basic_json_parser_30;
- }
- if (yych <= 0xE0)
- {
- if (yych <= '\\')
- {
- if (yych <= 0x1F)
- {
- goto basic_json_parser_32;
- }
- if (yych <= '"')
- {
- goto basic_json_parser_33;
- }
- goto basic_json_parser_35;
- }
- else
- {
- if (yych <= 0xC1)
- {
- goto basic_json_parser_32;
- }
- if (yych <= 0xDF)
- {
- goto basic_json_parser_36;
- }
- goto basic_json_parser_37;
- }
- }
- else
- {
- if (yych <= 0xEF)
- {
- if (yych == 0xED)
- {
- goto basic_json_parser_39;
- }
- goto basic_json_parser_38;
- }
- else
- {
- if (yych <= 0xF0)
- {
- goto basic_json_parser_40;
- }
- if (yych <= 0xF3)
- {
- goto basic_json_parser_41;
- }
- if (yych <= 0xF4)
- {
- goto basic_json_parser_42;
- }
- }
- }
-basic_json_parser_32:
- m_cursor = m_marker;
- if (yyaccept <= 1)
- {
- if (yyaccept == 0)
- {
- goto basic_json_parser_5;
- }
- else
- {
- goto basic_json_parser_14;
- }
- }
- else
- {
- if (yyaccept == 2)
- {
- goto basic_json_parser_44;
- }
- else
- {
- goto basic_json_parser_58;
- }
- }
-basic_json_parser_33:
- ++m_cursor;
- {
- last_token_type = token_type::value_string;
- break;
- }
-basic_json_parser_35:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= 'e')
- {
- if (yych <= '/')
- {
- if (yych == '"')
- {
- goto basic_json_parser_30;
- }
- if (yych <= '.')
- {
- goto basic_json_parser_32;
- }
- goto basic_json_parser_30;
- }
- else
- {
- if (yych <= '\\')
- {
- if (yych <= '[')
- {
- goto basic_json_parser_32;
- }
- goto basic_json_parser_30;
- }
- else
- {
- if (yych == 'b')
- {
- goto basic_json_parser_30;
- }
- goto basic_json_parser_32;
- }
- }
- }
- else
- {
- if (yych <= 'q')
- {
- if (yych <= 'f')
- {
- goto basic_json_parser_30;
- }
- if (yych == 'n')
- {
- goto basic_json_parser_30;
- }
- goto basic_json_parser_32;
- }
- else
- {
- if (yych <= 's')
- {
- if (yych <= 'r')
- {
- goto basic_json_parser_30;
- }
- goto basic_json_parser_32;
- }
- else
- {
- if (yych <= 't')
- {
- goto basic_json_parser_30;
- }
- if (yych <= 'u')
- {
- goto basic_json_parser_55;
- }
- goto basic_json_parser_32;
- }
- }
- }
-basic_json_parser_36:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= 0x7F)
- {
- goto basic_json_parser_32;
- }
- if (yych <= 0xBF)
- {
- goto basic_json_parser_30;
- }
- goto basic_json_parser_32;
-basic_json_parser_37:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= 0x9F)
- {
- goto basic_json_parser_32;
- }
- if (yych <= 0xBF)
- {
- goto basic_json_parser_36;
- }
- goto basic_json_parser_32;
-basic_json_parser_38:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= 0x7F)
- {
- goto basic_json_parser_32;
- }
- if (yych <= 0xBF)
- {
- goto basic_json_parser_36;
- }
- goto basic_json_parser_32;
-basic_json_parser_39:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= 0x7F)
- {
- goto basic_json_parser_32;
- }
- if (yych <= 0x9F)
- {
- goto basic_json_parser_36;
- }
- goto basic_json_parser_32;
-basic_json_parser_40:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= 0x8F)
- {
- goto basic_json_parser_32;
- }
- if (yych <= 0xBF)
- {
- goto basic_json_parser_38;
- }
- goto basic_json_parser_32;
-basic_json_parser_41:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= 0x7F)
- {
- goto basic_json_parser_32;
- }
- if (yych <= 0xBF)
- {
- goto basic_json_parser_38;
- }
- goto basic_json_parser_32;
-basic_json_parser_42:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= 0x7F)
- {
- goto basic_json_parser_32;
- }
- if (yych <= 0x8F)
- {
- goto basic_json_parser_38;
- }
- goto basic_json_parser_32;
-basic_json_parser_43:
- yyaccept = 2;
- yych = *(m_marker = ++m_cursor);
- if (yych <= '9')
- {
- if (yych == '.')
- {
- goto basic_json_parser_47;
- }
- if (yych >= '0')
- {
- goto basic_json_parser_48;
- }
- }
- else
- {
- if (yych <= 'E')
- {
- if (yych >= 'E')
- {
- goto basic_json_parser_51;
- }
- }
- else
- {
- if (yych == 'e')
- {
- goto basic_json_parser_51;
- }
- }
- }
-basic_json_parser_44:
- {
- last_token_type = token_type::value_integer;
- break;
- }
-basic_json_parser_45:
- yyaccept = 2;
- m_marker = ++m_cursor;
- if ((m_limit - m_cursor) < 3)
- {
- fill_line_buffer(3); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= '9')
- {
- if (yych == '.')
- {
- goto basic_json_parser_47;
- }
- if (yych <= '/')
- {
- goto basic_json_parser_44;
- }
- goto basic_json_parser_45;
- }
- else
- {
- if (yych <= 'E')
- {
- if (yych <= 'D')
- {
- goto basic_json_parser_44;
- }
- goto basic_json_parser_51;
- }
- else
- {
- if (yych == 'e')
- {
- goto basic_json_parser_51;
- }
- goto basic_json_parser_44;
- }
- }
-basic_json_parser_47:
- yych = *++m_cursor;
- if (yych <= '/')
- {
- goto basic_json_parser_32;
- }
- if (yych <= '9')
- {
- goto basic_json_parser_56;
- }
- goto basic_json_parser_32;
-basic_json_parser_48:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= '/')
- {
- goto basic_json_parser_50;
- }
- if (yych <= '9')
- {
- goto basic_json_parser_48;
- }
-basic_json_parser_50:
- {
- last_token_type = token_type::parse_error;
- break;
- }
-basic_json_parser_51:
- yych = *++m_cursor;
- if (yych <= ',')
- {
- if (yych == '+')
- {
- goto basic_json_parser_59;
- }
- goto basic_json_parser_32;
- }
- else
- {
- if (yych <= '-')
- {
- goto basic_json_parser_59;
- }
- if (yych <= '/')
- {
- goto basic_json_parser_32;
- }
- if (yych <= '9')
- {
- goto basic_json_parser_60;
- }
- goto basic_json_parser_32;
- }
-basic_json_parser_52:
- yych = *++m_cursor;
- if (yych == 'l')
- {
- goto basic_json_parser_62;
- }
- goto basic_json_parser_32;
-basic_json_parser_53:
- yych = *++m_cursor;
- if (yych == 'l')
- {
- goto basic_json_parser_63;
- }
- goto basic_json_parser_32;
-basic_json_parser_54:
- yych = *++m_cursor;
- if (yych == 'u')
- {
- goto basic_json_parser_64;
- }
- goto basic_json_parser_32;
-basic_json_parser_55:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= '@')
- {
- if (yych <= '/')
- {
- goto basic_json_parser_32;
- }
- if (yych <= '9')
- {
- goto basic_json_parser_65;
- }
- goto basic_json_parser_32;
- }
- else
- {
- if (yych <= 'F')
- {
- goto basic_json_parser_65;
- }
- if (yych <= '`')
- {
- goto basic_json_parser_32;
- }
- if (yych <= 'f')
- {
- goto basic_json_parser_65;
- }
- goto basic_json_parser_32;
- }
-basic_json_parser_56:
- yyaccept = 3;
- m_marker = ++m_cursor;
- if ((m_limit - m_cursor) < 3)
- {
- fill_line_buffer(3); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= 'D')
- {
- if (yych <= '/')
- {
- goto basic_json_parser_58;
- }
- if (yych <= '9')
- {
- goto basic_json_parser_56;
- }
- }
- else
- {
- if (yych <= 'E')
- {
- goto basic_json_parser_51;
- }
- if (yych == 'e')
- {
- goto basic_json_parser_51;
- }
- }
-basic_json_parser_58:
- {
- last_token_type = token_type::value_float;
- break;
- }
-basic_json_parser_59:
- yych = *++m_cursor;
- if (yych <= '/')
- {
- goto basic_json_parser_32;
- }
- if (yych >= ':')
- {
- goto basic_json_parser_32;
- }
-basic_json_parser_60:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= '/')
- {
- goto basic_json_parser_58;
- }
- if (yych <= '9')
- {
- goto basic_json_parser_60;
- }
- goto basic_json_parser_58;
-basic_json_parser_62:
- yych = *++m_cursor;
- if (yych == 's')
- {
- goto basic_json_parser_66;
- }
- goto basic_json_parser_32;
-basic_json_parser_63:
- yych = *++m_cursor;
- if (yych == 'l')
- {
- goto basic_json_parser_67;
- }
- goto basic_json_parser_32;
-basic_json_parser_64:
- yych = *++m_cursor;
- if (yych == 'e')
- {
- goto basic_json_parser_69;
- }
- goto basic_json_parser_32;
-basic_json_parser_65:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= '@')
- {
- if (yych <= '/')
- {
- goto basic_json_parser_32;
- }
- if (yych <= '9')
- {
- goto basic_json_parser_71;
- }
- goto basic_json_parser_32;
- }
- else
- {
- if (yych <= 'F')
- {
- goto basic_json_parser_71;
- }
- if (yych <= '`')
- {
- goto basic_json_parser_32;
- }
- if (yych <= 'f')
- {
- goto basic_json_parser_71;
- }
- goto basic_json_parser_32;
- }
-basic_json_parser_66:
- yych = *++m_cursor;
- if (yych == 'e')
- {
- goto basic_json_parser_72;
- }
- goto basic_json_parser_32;
-basic_json_parser_67:
- ++m_cursor;
- {
- last_token_type = token_type::literal_null;
- break;
- }
-basic_json_parser_69:
- ++m_cursor;
- {
- last_token_type = token_type::literal_true;
- break;
- }
-basic_json_parser_71:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= '@')
- {
- if (yych <= '/')
- {
- goto basic_json_parser_32;
- }
- if (yych <= '9')
- {
- goto basic_json_parser_74;
- }
- goto basic_json_parser_32;
- }
- else
- {
- if (yych <= 'F')
- {
- goto basic_json_parser_74;
- }
- if (yych <= '`')
- {
- goto basic_json_parser_32;
- }
- if (yych <= 'f')
- {
- goto basic_json_parser_74;
- }
- goto basic_json_parser_32;
- }
-basic_json_parser_72:
- ++m_cursor;
- {
- last_token_type = token_type::literal_false;
- break;
- }
-basic_json_parser_74:
- ++m_cursor;
- if (m_limit <= m_cursor)
- {
- fill_line_buffer(1); // LCOV_EXCL_LINE
- }
- yych = *m_cursor;
- if (yych <= '@')
- {
- if (yych <= '/')
- {
- goto basic_json_parser_32;
- }
- if (yych <= '9')
- {
- goto basic_json_parser_30;
- }
- goto basic_json_parser_32;
- }
- else
- {
- if (yych <= 'F')
- {
- goto basic_json_parser_30;
- }
- if (yych <= '`')
- {
- goto basic_json_parser_32;
- }
- if (yych <= 'f')
- {
- goto basic_json_parser_30;
- }
- goto basic_json_parser_32;
- }
- }
-
- }
-
- return last_token_type;
- }
-
- /*!
- @brief append data from the stream to the line buffer
-
- This function is called by the scan() function when the end of the
- buffer (`m_limit`) is reached and the `m_cursor` pointer cannot be
- incremented without leaving the limits of the line buffer. Note re2c
- decides when to call this function.
-
- If the lexer reads from contiguous storage, there is no trailing null
- byte. Therefore, this function must make sure to add these padding
- null bytes.
-
- If the lexer reads from an input stream, this function reads the next
- line of the input.
-
- @pre
- p p p p p p u u u u u x . . . . . .
- ^ ^ ^ ^
- m_content m_start | m_limit
- m_cursor
-
- @post
- u u u u u x x x x x x x . . . . . .
- ^ ^ ^
- | m_cursor m_limit
- m_start
- m_content
- */
- void fill_line_buffer(size_t n = 0)
- {
- // if line buffer is used, m_content points to its data
- assert(m_line_buffer.empty()
- or m_content == reinterpret_cast<const lexer_char_t*>(m_line_buffer.data()));
-
- // if line buffer is used, m_limit is set past the end of its data
- assert(m_line_buffer.empty()
- or m_limit == m_content + m_line_buffer.size());
-
- // pointer relationships
- assert(m_content <= m_start);
- assert(m_start <= m_cursor);
- assert(m_cursor <= m_limit);
- assert(m_marker == nullptr or m_marker <= m_limit);
-
- // number of processed characters (p)
- const auto num_processed_chars = static_cast<size_t>(m_start - m_content);
- // offset for m_marker wrt. to m_start
- const auto offset_marker = (m_marker == nullptr) ? 0 : m_marker - m_start;
- // number of unprocessed characters (u)
- const auto offset_cursor = m_cursor - m_start;
-
- // no stream is used or end of file is reached
- if (m_stream == nullptr or m_stream->eof())
- {
- // m_start may or may not be pointing into m_line_buffer at
- // this point. We trust the standard library to do the right
- // thing. See http://stackoverflow.com/q/28142011/266378
- m_line_buffer.assign(m_start, m_limit);
-
- // append n characters to make sure that there is sufficient
- // space between m_cursor and m_limit
- m_line_buffer.append(1, '\x00');
- if (n > 0)
- {
- m_line_buffer.append(n - 1, '\x01');
- }
- }
- else
- {
- // delete processed characters from line buffer
- m_line_buffer.erase(0, num_processed_chars);
- // read next line from input stream
- m_line_buffer_tmp.clear();
- std::getline(*m_stream, m_line_buffer_tmp, '\n');
-
- // add line with newline symbol to the line buffer
- m_line_buffer += m_line_buffer_tmp;
- m_line_buffer.push_back('\n');
- }
-
- // set pointers
- m_content = reinterpret_cast<const lexer_char_t*>(m_line_buffer.data());
- assert(m_content != nullptr);
- m_start = m_content;
- m_marker = m_start + offset_marker;
- m_cursor = m_start + offset_cursor;
- m_limit = m_start + m_line_buffer.size();
- }
-
- /// return string representation of last read token
- string_t get_token_string() const
- {
- assert(m_start != nullptr);
- return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),
- static_cast<size_t>(m_cursor - m_start));
- }
-
- /*!
- @brief return string value for string tokens
-
- The function iterates the characters between the opening and closing
- quotes of the string value. The complete string is the range
- [m_start,m_cursor). Consequently, we iterate from m_start+1 to
- m_cursor-1.
-
- We differentiate two cases:
-
- 1. Escaped characters. In this case, a new character is constructed
- according to the nature of the escape. Some escapes create new
- characters (e.g., `"\\n"` is replaced by `"\n"`), some are copied
- as is (e.g., `"\\\\"`). Furthermore, Unicode escapes of the shape
- `"\\uxxxx"` need special care. In this case, to_unicode takes care
- of the construction of the values.
- 2. Unescaped characters are copied as is.
-
- @pre `m_cursor - m_start >= 2`, meaning the length of the last token
- is at least 2 bytes which is trivially true for any string (which
- consists of at least two quotes).
-
- " c1 c2 c3 ... "
- ^ ^
- m_start m_cursor
-
- @complexity Linear in the length of the string.\n
-
- Lemma: The loop body will always terminate.\n
-
- Proof (by contradiction): Assume the loop body does not terminate. As
- the loop body does not contain another loop, one of the called
- functions must never return. The called functions are `std::strtoul`
- and to_unicode. Neither function can loop forever, so the loop body
- will never loop forever which contradicts the assumption that the loop
- body does not terminate, q.e.d.\n
-
- Lemma: The loop condition for the for loop is eventually false.\n
-
- Proof (by contradiction): Assume the loop does not terminate. Due to
- the above lemma, this can only be due to a tautological loop
- condition; that is, the loop condition i < m_cursor - 1 must always be
- true. Let x be the change of i for any loop iteration. Then
- m_start + 1 + x < m_cursor - 1 must hold to loop indefinitely. This
- can be rephrased to m_cursor - m_start - 2 > x. With the
- precondition, we x <= 0, meaning that the loop condition holds
- indefinitely if i is always decreased. However, observe that the value
- of i is strictly increasing with each iteration, as it is incremented
- by 1 in the iteration expression and never decremented inside the loop
- body. Hence, the loop condition will eventually be false which
- contradicts the assumption that the loop condition is a tautology,
- q.e.d.
-
- @return string value of current token without opening and closing
- quotes
- @throw std::out_of_range if to_unicode fails
- */
- string_t get_string() const
- {
- assert(m_cursor - m_start >= 2);
-
- string_t result;
- result.reserve(static_cast<size_t>(m_cursor - m_start - 2));
-
- // iterate the result between the quotes
- for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
- {
- // find next escape character
- auto e = std::find(i, m_cursor - 1, '\\');
- if (e != i)
- {
- // see https://github.com/nlohmann/json/issues/365#issuecomment-262874705
- for (auto k = i; k < e; k++)
- {
- result.push_back(static_cast<typename string_t::value_type>(*k));
- }
- i = e - 1; // -1 because of ++i
- }
- else
- {
- // processing escaped character
- // read next character
- ++i;
-
- switch (*i)
- {
- // the default escapes
- case 't':
- {
- result += "\t";
- break;
- }
- case 'b':
- {
- result += "\b";
- break;
- }
- case 'f':
- {
- result += "\f";
- break;
- }
- case 'n':
- {
- result += "\n";
- break;
- }
- case 'r':
- {
- result += "\r";
- break;
- }
- case '\\':
- {
- result += "\\";
- break;
- }
- case '/':
- {
- result += "/";
- break;
- }
- case '"':
- {
- result += "\"";
- break;
- }
-
- // unicode
- case 'u':
- {
- // get code xxxx from uxxxx
- auto codepoint = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>(i + 1),
- 4).c_str(), nullptr, 16);
-
- // check if codepoint is a high surrogate
- if (codepoint >= 0xD800 and codepoint <= 0xDBFF)
- {
- // make sure there is a subsequent unicode
- if ((i + 6 >= m_limit) or * (i + 5) != '\\' or * (i + 6) != 'u')
- {
- JSON_THROW(std::invalid_argument("missing low surrogate"));
- }
-
- // get code yyyy from uxxxx\uyyyy
- auto codepoint2 = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>
- (i + 7), 4).c_str(), nullptr, 16);
- result += to_unicode(codepoint, codepoint2);
- // skip the next 10 characters (xxxx\uyyyy)
- i += 10;
- }
- else if (codepoint >= 0xDC00 and codepoint <= 0xDFFF)
- {
- // we found a lone low surrogate
- JSON_THROW(std::invalid_argument("missing high surrogate"));
- }
- else
- {
- // add unicode character(s)
- result += to_unicode(codepoint);
- // skip the next four characters (xxxx)
- i += 4;
- }
- break;
- }
- }
- }
- }
-
- return result;
- }
-
-
- /*!
- @brief parse string into a built-in arithmetic type as if the current
- locale is POSIX.
-
- @note in floating-point case strtod may parse past the token's end -
- this is not an error
-
- @note any leading blanks are not handled
- */
- struct strtonum
- {
- public:
- strtonum(const char* start, const char* end)
- : m_start(start), m_end(end)
- {}
-
- /*!
- @return true iff parsed successfully as number of type T
-
- @param[in,out] val shall contain parsed value, or undefined value
- if could not parse
- */
- template<typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value>::type>
- bool to(T& val) const
- {
- return parse(val, std::is_integral<T>());
- }
-
- private:
- const char* const m_start = nullptr;
- const char* const m_end = nullptr;
-
- // floating-point conversion
-
- // overloaded wrappers for strtod/strtof/strtold
- // that will be called from parse<floating_point_t>
- static void strtof(float& f, const char* str, char** endptr)
- {
- f = std::strtof(str, endptr);
- }
-
- static void strtof(double& f, const char* str, char** endptr)
- {
- f = std::strtod(str, endptr);
- }
-
- static void strtof(long double& f, const char* str, char** endptr)
- {
- f = std::strtold(str, endptr);
- }
-
- template<typename T>
- bool parse(T& value, /*is_integral=*/std::false_type) const
- {
- // replace decimal separator with locale-specific version,
- // when necessary; data will point to either the original
- // string, or buf, or tempstr containing the fixed string.
- std::string tempstr;
- std::array<char, 64> buf;
- const size_t len = static_cast<size_t>(m_end - m_start);
-
- // lexer will reject empty numbers
- assert(len > 0);
-
- // since dealing with strtod family of functions, we're
- // getting the decimal point char from the C locale facilities
- // instead of C++'s numpunct facet of the current std::locale
- const auto loc = localeconv();
- assert(loc != nullptr);
- const char decimal_point_char = (loc->decimal_point == nullptr) ? '.' : loc->decimal_point[0];
-
- const char* data = m_start;
-
- if (decimal_point_char != '.')
- {
- const size_t ds_pos = static_cast<size_t>(std::find(m_start, m_end, '.') - m_start);
-
- if (ds_pos != len)
- {
- // copy the data into the local buffer or tempstr, if
- // buffer is too small; replace decimal separator, and
- // update data to point to the modified bytes
- if ((len + 1) < buf.size())
- {
- std::copy(m_start, m_end, buf.begin());
- buf[len] = 0;
- buf[ds_pos] = decimal_point_char;
- data = buf.data();
- }
- else
- {
- tempstr.assign(m_start, m_end);
- tempstr[ds_pos] = decimal_point_char;
- data = tempstr.c_str();
- }
- }
- }
-
- char* endptr = nullptr;
- value = 0;
- // this calls appropriate overload depending on T
- strtof(value, data, &endptr);
-
- // parsing was successful iff strtof parsed exactly the number
- // of characters determined by the lexer (len)
- const bool ok = (endptr == (data + len));
-
- if (ok and (value == static_cast<T>(0.0)) and (*data == '-'))
- {
- // some implementations forget to negate the zero
- value = -0.0;
- }
-
- return ok;
- }
-
- // integral conversion
-
- signed long long parse_integral(char** endptr, /*is_signed*/std::true_type) const
- {
- return std::strtoll(m_start, endptr, 10);
- }
-
- unsigned long long parse_integral(char** endptr, /*is_signed*/std::false_type) const
- {
- return std::strtoull(m_start, endptr, 10);
- }
-
- template<typename T>
- bool parse(T& value, /*is_integral=*/std::true_type) const
- {
- char* endptr = nullptr;
- errno = 0; // these are thread-local
- const auto x = parse_integral(&endptr, std::is_signed<T>());
-
- // called right overload?
- static_assert(std::is_signed<T>() == std::is_signed<decltype(x)>(), "");
-
- value = static_cast<T>(x);
-
- return (x == static_cast<decltype(x)>(value)) // x fits into destination T
- and (x < 0) == (value < 0) // preserved sign
- //and ((x != 0) or is_integral()) // strto[u]ll did nto fail
- and (errno == 0) // strto[u]ll did not overflow
- and (m_start < m_end) // token was not empty
- and (endptr == m_end); // parsed entire token exactly
- }
- };
-
- /*!
- @brief return number value for number tokens
-
- This function translates the last token into the most appropriate
- number type (either integer, unsigned integer or floating point),
- which is passed back to the caller via the result parameter.
-
- integral numbers that don't fit into the the range of the respective
- type are parsed as number_float_t
-
- floating-point values do not satisfy std::isfinite predicate
- are converted to value_t::null
-
- throws if the entire string [m_start .. m_cursor) cannot be
- interpreted as a number
-
- @param[out] result @ref basic_json object to receive the number.
- @param[in] token the type of the number token
- */
- bool get_number(basic_json& result, const token_type token) const
- {
- assert(m_start != nullptr);
- assert(m_start < m_cursor);
- assert((token == token_type::value_unsigned) or
- (token == token_type::value_integer) or
- (token == token_type::value_float));
-
- strtonum num_converter(reinterpret_cast<const char*>(m_start),
- reinterpret_cast<const char*>(m_cursor));
-
- switch (token)
- {
- case lexer::token_type::value_unsigned:
- {
- number_unsigned_t val;
- if (num_converter.to(val))
- {
- // parsing successful
- result.m_type = value_t::number_unsigned;
- result.m_value = val;
- return true;
- }
- break;
- }
-
- case lexer::token_type::value_integer:
- {
- number_integer_t val;
- if (num_converter.to(val))
- {
- // parsing successful
- result.m_type = value_t::number_integer;
- result.m_value = val;
- return true;
- }
- break;
- }
-
- default:
- {
- break;
- }
- }
-
- // parse float (either explicitly or because a previous conversion
- // failed)
- number_float_t val;
- if (num_converter.to(val))
- {
- // parsing successful
- result.m_type = value_t::number_float;
- result.m_value = val;
-
- // replace infinity and NAN by null
- if (not std::isfinite(result.m_value.number_float))
- {
- result.m_type = value_t::null;
- result.m_value = basic_json::json_value();
- }
-
- return true;
- }
-
- // couldn't parse number in any format
- return false;
- }
-
- private:
- /// optional input stream
- std::istream* m_stream = nullptr;
- /// line buffer buffer for m_stream
- string_t m_line_buffer {};
- /// used for filling m_line_buffer
- string_t m_line_buffer_tmp {};
- /// the buffer pointer
- const lexer_char_t* m_content = nullptr;
- /// pointer to the beginning of the current symbol
- const lexer_char_t* m_start = nullptr;
- /// pointer for backtracking information
- const lexer_char_t* m_marker = nullptr;
- /// pointer to the current symbol
- const lexer_char_t* m_cursor = nullptr;
- /// pointer to the end of the buffer
- const lexer_char_t* m_limit = nullptr;
- /// the last token type
- token_type last_token_type = token_type::end_of_input;
- };
-
- /*!
- @brief syntax analysis
-
- This class implements a recursive decent parser.
- */
- class parser
- {
- public:
- /// a parser reading from a string literal
- parser(const char* buff, const parser_callback_t cb = nullptr)
- : callback(cb),
- m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(buff), std::strlen(buff))
- {}
-
- /// a parser reading from an input stream
- parser(std::istream& is, const parser_callback_t cb = nullptr)
- : callback(cb), m_lexer(is)
- {}
-
- /// a parser reading from an iterator range with contiguous storage
- template<class IteratorType, typename std::enable_if<
- std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value
- , int>::type
- = 0>
- parser(IteratorType first, IteratorType last, const parser_callback_t cb = nullptr)
- : callback(cb),
- m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(&(*first)),
- static_cast<size_t>(std::distance(first, last)))
- {}
-
- /// public parser interface
- basic_json parse()
- {
- // read first token
- get_token();
-
- basic_json result = parse_internal(true);
- result.assert_invariant();
-
- expect(lexer::token_type::end_of_input);
-
- // return parser result and replace it with null in case the
- // top-level value was discarded by the callback function
- return result.is_discarded() ? basic_json() : std::move(result);
- }
-
- private:
- /// the actual parser
- basic_json parse_internal(bool keep)
- {
- auto result = basic_json(value_t::discarded);
-
- switch (last_token)
- {
- case lexer::token_type::begin_object:
- {
- if (keep and (not callback
- or ((keep = callback(depth++, parse_event_t::object_start, result)) != 0)))
- {
- // explicitly set result to object to cope with {}
- result.m_type = value_t::object;
- result.m_value = value_t::object;
- }
-
- // read next token
- get_token();
-
- // closing } -> we are done
- if (last_token == lexer::token_type::end_object)
- {
- get_token();
- if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
- {
- result = basic_json(value_t::discarded);
- }
- return result;
- }
-
- // no comma is expected here
- unexpect(lexer::token_type::value_separator);
-
- // otherwise: parse key-value pairs
- do
- {
- // ugly, but could be fixed with loop reorganization
- if (last_token == lexer::token_type::value_separator)
- {
- get_token();
- }
-
- // store key
- expect(lexer::token_type::value_string);
- const auto key = m_lexer.get_string();
-
- bool keep_tag = false;
- if (keep)
- {
- if (callback)
- {
- basic_json k(key);
- keep_tag = callback(depth, parse_event_t::key, k);
- }
- else
- {
- keep_tag = true;
- }
- }
-
- // parse separator (:)
- get_token();
- expect(lexer::token_type::name_separator);
-
- // parse and add value
- get_token();
- auto value = parse_internal(keep);
- if (keep and keep_tag and not value.is_discarded())
- {
- result[key] = std::move(value);
- }
- }
- while (last_token == lexer::token_type::value_separator);
-
- // closing }
- expect(lexer::token_type::end_object);
- get_token();
- if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
- {
- result = basic_json(value_t::discarded);
- }
-
- return result;
- }
-
- case lexer::token_type::begin_array:
- {
- if (keep and (not callback
- or ((keep = callback(depth++, parse_event_t::array_start, result)) != 0)))
- {
- // explicitly set result to object to cope with []
- result.m_type = value_t::array;
- result.m_value = value_t::array;
- }
-
- // read next token
- get_token();
-
- // closing ] -> we are done
- if (last_token == lexer::token_type::end_array)
- {
- get_token();
- if (callback and not callback(--depth, parse_event_t::array_end, result))
- {
- result = basic_json(value_t::discarded);
- }
- return result;
- }
-
- // no comma is expected here
- unexpect(lexer::token_type::value_separator);
-
- // otherwise: parse values
- do
- {
- // ugly, but could be fixed with loop reorganization
- if (last_token == lexer::token_type::value_separator)
- {
- get_token();
- }
-
- // parse value
- auto value = parse_internal(keep);
- if (keep and not value.is_discarded())
- {
- result.push_back(std::move(value));
- }
- }
- while (last_token == lexer::token_type::value_separator);
-
- // closing ]
- expect(lexer::token_type::end_array);
- get_token();
- if (keep and callback and not callback(--depth, parse_event_t::array_end, result))
- {
- result = basic_json(value_t::discarded);
- }
-
- return result;
- }
-
- case lexer::token_type::literal_null:
- {
- get_token();
- result.m_type = value_t::null;
- break;
- }
-
- case lexer::token_type::value_string:
- {
- const auto s = m_lexer.get_string();
- get_token();
- result = basic_json(s);
- break;
- }
-
- case lexer::token_type::literal_true:
- {
- get_token();
- result.m_type = value_t::boolean;
- result.m_value = true;
- break;
- }
-
- case lexer::token_type::literal_false:
- {
- get_token();
- result.m_type = value_t::boolean;
- result.m_value = false;
- break;
- }
-
- case lexer::token_type::value_unsigned:
- case lexer::token_type::value_integer:
- case lexer::token_type::value_float:
- {
- m_lexer.get_number(result, last_token);
- get_token();
- break;
- }
-
- default:
- {
- // the last token was unexpected
- unexpect(last_token);
- }
- }
-
- if (keep and callback and not callback(depth, parse_event_t::value, result))
- {
- result = basic_json(value_t::discarded);
- }
- return result;
- }
-
- /// get next token from lexer
- typename lexer::token_type get_token()
- {
- last_token = m_lexer.scan();
- return last_token;
- }
-
- void expect(typename lexer::token_type t) const
- {
- if (t != last_token)
- {
- std::string error_msg = "parse error - unexpected ";
- error_msg += (last_token == lexer::token_type::parse_error ? ("'" + m_lexer.get_token_string() +
- "'") :
- lexer::token_type_name(last_token));
- error_msg += "; expected " + lexer::token_type_name(t);
- JSON_THROW(std::invalid_argument(error_msg));
- }
- }
-
- void unexpect(typename lexer::token_type t) const
- {
- if (t == last_token)
- {
- std::string error_msg = "parse error - unexpected ";
- error_msg += (last_token == lexer::token_type::parse_error ? ("'" + m_lexer.get_token_string() +
- "'") :
- lexer::token_type_name(last_token));
- JSON_THROW(std::invalid_argument(error_msg));
- }
- }
-
- private:
- /// current level of recursion
- int depth = 0;
- /// callback function
- const parser_callback_t callback = nullptr;
- /// the type of the last read token
- typename lexer::token_type last_token = lexer::token_type::uninitialized;
- /// the lexer
- lexer m_lexer;
- };
-
- public:
- /*!
- @brief JSON Pointer
-
- A JSON pointer defines a string syntax for identifying a specific value
- within a JSON document. It can be used with functions `at` and
- `operator[]`. Furthermore, JSON pointers are the base for JSON patches.
-
- @sa [RFC 6901](https://tools.ietf.org/html/rfc6901)
-
- @since version 2.0.0
- */
- class json_pointer
- {
- /// allow basic_json to access private members
- friend class basic_json;
-
- public:
- /*!
- @brief create JSON pointer
-
- Create a JSON pointer according to the syntax described in
- [Section 3 of RFC6901](https://tools.ietf.org/html/rfc6901#section-3).
-
- @param[in] s string representing the JSON pointer; if omitted, the
- empty string is assumed which references the whole JSON
- value
-
- @throw std::domain_error if reference token is nonempty and does not
- begin with a slash (`/`); example: `"JSON pointer must be empty or
- begin with /"`
- @throw std::domain_error if a tilde (`~`) is not followed by `0`
- (representing `~`) or `1` (representing `/`); example: `"escape error:
- ~ must be followed with 0 or 1"`
-
- @liveexample{The example shows the construction several valid JSON
- pointers as well as the exceptional behavior.,json_pointer}
-
- @since version 2.0.0
- */
- explicit json_pointer(const std::string& s = "")
- : reference_tokens(split(s))
- {}
-
- /*!
- @brief return a string representation of the JSON pointer
-
- @invariant For each JSON pointer `ptr`, it holds:
- @code {.cpp}
- ptr == json_pointer(ptr.to_string());
- @endcode
-
- @return a string representation of the JSON pointer
-
- @liveexample{The example shows the result of `to_string`.,
- json_pointer__to_string}
-
- @since version 2.0.0
- */
- std::string to_string() const noexcept
- {
- return std::accumulate(reference_tokens.begin(),
- reference_tokens.end(), std::string{},
- [](const std::string & a, const std::string & b)
- {
- return a + "/" + escape(b);
- });
- }
-
- /// @copydoc to_string()
- operator std::string() const
- {
- return to_string();
- }
-
- private:
- /// remove and return last reference pointer
- std::string pop_back()
- {
- if (is_root())
- {
- JSON_THROW(std::domain_error("JSON pointer has no parent"));
- }
-
- auto last = reference_tokens.back();
- reference_tokens.pop_back();
- return last;
- }
-
- /// return whether pointer points to the root document
- bool is_root() const
- {
- return reference_tokens.empty();
- }
-
- json_pointer top() const
- {
- if (is_root())
- {
- JSON_THROW(std::domain_error("JSON pointer has no parent"));
- }
-
- json_pointer result = *this;
- result.reference_tokens = {reference_tokens[0]};
- return result;
- }
-
- /*!
- @brief create and return a reference to the pointed to value
-
- @complexity Linear in the number of reference tokens.
- */
- reference get_and_create(reference j) const
- {
- pointer result = &j;
-
- // in case no reference tokens exist, return a reference to the
- // JSON value j which will be overwritten by a primitive value
- for (const auto& reference_token : reference_tokens)
- {
- switch (result->m_type)
- {
- case value_t::null:
- {
- if (reference_token == "0")
- {
- // start a new array if reference token is 0
- result = &result->operator[](0);
- }
- else
- {
- // start a new object otherwise
- result = &result->operator[](reference_token);
- }
- break;
- }
-
- case value_t::object:
- {
- // create an entry in the object
- result = &result->operator[](reference_token);
- break;
- }
-
- case value_t::array:
- {
- // create an entry in the array
- result = &result->operator[](static_cast<size_type>(std::stoi(reference_token)));
- break;
- }
-
- /*
- The following code is only reached if there exists a
- reference token _and_ the current value is primitive. In
- this case, we have an error situation, because primitive
- values may only occur as single value; that is, with an
- empty list of reference tokens.
- */
- default:
- {
- JSON_THROW(std::domain_error("invalid value to unflatten"));
- }
- }
- }
-
- return *result;
- }
-
- /*!
- @brief return a reference to the pointed to value
-
- @note This version does not throw if a value is not present, but tries
- to create nested values instead. For instance, calling this function
- with pointer `"/this/that"` on a null value is equivalent to calling
- `operator[]("this").operator[]("that")` on that value, effectively
- changing the null value to an object.
-
- @param[in] ptr a JSON value
-
- @return reference to the JSON value pointed to by the JSON pointer
-
- @complexity Linear in the length of the JSON pointer.
-
- @throw std::out_of_range if the JSON pointer can not be resolved
- @throw std::domain_error if an array index begins with '0'
- @throw std::invalid_argument if an array index was not a number
- */
- reference get_unchecked(pointer ptr) const
- {
- for (const auto& reference_token : reference_tokens)
- {
- // convert null values to arrays or objects before continuing
- if (ptr->m_type == value_t::null)
- {
- // check if reference token is a number
- const bool nums = std::all_of(reference_token.begin(),
- reference_token.end(),
- [](const char x)
- {
- return std::isdigit(x);
- });
-
- // change value to array for numbers or "-" or to object
- // otherwise
- if (nums or reference_token == "-")
- {
- *ptr = value_t::array;
- }
- else
- {
- *ptr = value_t::object;
- }
- }
-
- switch (ptr->m_type)
- {
- case value_t::object:
- {
- // use unchecked object access
- ptr = &ptr->operator[](reference_token);
- break;
- }
-
- case value_t::array:
- {
- // error condition (cf. RFC 6901, Sect. 4)
- if (reference_token.size() > 1 and reference_token[0] == '0')
- {
- JSON_THROW(std::domain_error("array index must not begin with '0'"));
- }
-
- if (reference_token == "-")
- {
- // explicitly treat "-" as index beyond the end
- ptr = &ptr->operator[](ptr->m_value.array->size());
- }
- else
- {
- // convert array index to number; unchecked access
- ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
- }
- break;
- }
-
- default:
- {
- JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
- }
- }
- }
-
- return *ptr;
- }
-
- reference get_checked(pointer ptr) const
- {
- for (const auto& reference_token : reference_tokens)
- {
- switch (ptr->m_type)
- {
- case value_t::object:
- {
- // note: at performs range check
- ptr = &ptr->at(reference_token);
- break;
- }
-
- case value_t::array:
- {
- if (reference_token == "-")
- {
- // "-" always fails the range check
- JSON_THROW(std::out_of_range("array index '-' (" +
- std::to_string(ptr->m_value.array->size()) +
- ") is out of range"));
- }
-
- // error condition (cf. RFC 6901, Sect. 4)
- if (reference_token.size() > 1 and reference_token[0] == '0')
- {
- JSON_THROW(std::domain_error("array index must not begin with '0'"));
- }
-
- // note: at performs range check
- ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
- break;
- }
-
- default:
- {
- JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
- }
- }
- }
-
- return *ptr;
- }
-
- /*!
- @brief return a const reference to the pointed to value
-
- @param[in] ptr a JSON value
-
- @return const reference to the JSON value pointed to by the JSON
- pointer
- */
- const_reference get_unchecked(const_pointer ptr) const
- {
- for (const auto& reference_token : reference_tokens)
- {
- switch (ptr->m_type)
- {
- case value_t::object:
- {
- // use unchecked object access
- ptr = &ptr->operator[](reference_token);
- break;
- }
-
- case value_t::array:
- {
- if (reference_token == "-")
- {
- // "-" cannot be used for const access
- JSON_THROW(std::out_of_range("array index '-' (" +
- std::to_string(ptr->m_value.array->size()) +
- ") is out of range"));
- }
-
- // error condition (cf. RFC 6901, Sect. 4)
- if (reference_token.size() > 1 and reference_token[0] == '0')
- {
- JSON_THROW(std::domain_error("array index must not begin with '0'"));
- }
-
- // use unchecked array access
- ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
- break;
- }
-
- default:
- {
- JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
- }
- }
- }
-
- return *ptr;
- }
-
- const_reference get_checked(const_pointer ptr) const
- {
- for (const auto& reference_token : reference_tokens)
- {
- switch (ptr->m_type)
- {
- case value_t::object:
- {
- // note: at performs range check
- ptr = &ptr->at(reference_token);
- break;
- }
-
- case value_t::array:
- {
- if (reference_token == "-")
- {
- // "-" always fails the range check
- JSON_THROW(std::out_of_range("array index '-' (" +
- std::to_string(ptr->m_value.array->size()) +
- ") is out of range"));
- }
-
- // error condition (cf. RFC 6901, Sect. 4)
- if (reference_token.size() > 1 and reference_token[0] == '0')
- {
- JSON_THROW(std::domain_error("array index must not begin with '0'"));
- }
-
- // note: at performs range check
- ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
- break;
- }
-
- default:
- {
- JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
- }
- }
- }
-
- return *ptr;
- }
-
- /// split the string input to reference tokens
- static std::vector<std::string> split(const std::string& reference_string)
- {
- std::vector<std::string> result;
-
- // special case: empty reference string -> no reference tokens
- if (reference_string.empty())
- {
- return result;
- }
-
- // check if nonempty reference string begins with slash
- if (reference_string[0] != '/')
- {
- JSON_THROW(std::domain_error("JSON pointer must be empty or begin with '/'"));
- }
-
- // extract the reference tokens:
- // - slash: position of the last read slash (or end of string)
- // - start: position after the previous slash
- for (
- // search for the first slash after the first character
- size_t slash = reference_string.find_first_of('/', 1),
- // set the beginning of the first reference token
- start = 1;
- // we can stop if start == string::npos+1 = 0
- start != 0;
- // set the beginning of the next reference token
- // (will eventually be 0 if slash == std::string::npos)
- start = slash + 1,
- // find next slash
- slash = reference_string.find_first_of('/', start))
- {
- // use the text between the beginning of the reference token
- // (start) and the last slash (slash).
- auto reference_token = reference_string.substr(start, slash - start);
-
- // check reference tokens are properly escaped
- for (size_t pos = reference_token.find_first_of('~');
- pos != std::string::npos;
- pos = reference_token.find_first_of('~', pos + 1))
- {
- assert(reference_token[pos] == '~');
-
- // ~ must be followed by 0 or 1
- if (pos == reference_token.size() - 1 or
- (reference_token[pos + 1] != '0' and
- reference_token[pos + 1] != '1'))
- {
- JSON_THROW(std::domain_error("escape error: '~' must be followed with '0' or '1'"));
- }
- }
-
- // finally, store the reference token
- unescape(reference_token);
- result.push_back(reference_token);
- }
-
- return result;
- }
-
- private:
- /*!
- @brief replace all occurrences of a substring by another string
-
- @param[in,out] s the string to manipulate; changed so that all
- occurrences of @a f are replaced with @a t
- @param[in] f the substring to replace with @a t
- @param[in] t the string to replace @a f
-
- @pre The search string @a f must not be empty.
-
- @since version 2.0.0
- */
- static void replace_substring(std::string& s,
- const std::string& f,
- const std::string& t)
- {
- assert(not f.empty());
-
- for (
- size_t pos = s.find(f); // find first occurrence of f
- pos != std::string::npos; // make sure f was found
- s.replace(pos, f.size(), t), // replace with t
- pos = s.find(f, pos + t.size()) // find next occurrence of f
- );
- }
-
- /// escape tilde and slash
- static std::string escape(std::string s)
- {
- // escape "~"" to "~0" and "/" to "~1"
- replace_substring(s, "~", "~0");
- replace_substring(s, "/", "~1");
- return s;
- }
-
- /// unescape tilde and slash
- static void unescape(std::string& s)
- {
- // first transform any occurrence of the sequence '~1' to '/'
- replace_substring(s, "~1", "/");
- // then transform any occurrence of the sequence '~0' to '~'
- replace_substring(s, "~0", "~");
- }
-
- /*!
- @param[in] reference_string the reference string to the current value
- @param[in] value the value to consider
- @param[in,out] result the result object to insert values to
-
- @note Empty objects or arrays are flattened to `null`.
- */
- static void flatten(const std::string& reference_string,
- const basic_json& value,
- basic_json& result)
- {
- switch (value.m_type)
- {
- case value_t::array:
- {
- if (value.m_value.array->empty())
- {
- // flatten empty array as null
- result[reference_string] = nullptr;
- }
- else
- {
- // iterate array and use index as reference string
- for (size_t i = 0; i < value.m_value.array->size(); ++i)
- {
- flatten(reference_string + "/" + std::to_string(i),
- value.m_value.array->operator[](i), result);
- }
- }
- break;
- }
-
- case value_t::object:
- {
- if (value.m_value.object->empty())
- {
- // flatten empty object as null
- result[reference_string] = nullptr;
- }
- else
- {
- // iterate object and use keys as reference string
- for (const auto& element : *value.m_value.object)
- {
- flatten(reference_string + "/" + escape(element.first),
- element.second, result);
- }
- }
- break;
- }
-
- default:
- {
- // add primitive value with its reference string
- result[reference_string] = value;
- break;
- }
- }
- }
-
- /*!
- @param[in] value flattened JSON
-
- @return unflattened JSON
- */
- static basic_json unflatten(const basic_json& value)
- {
- if (not value.is_object())
- {
- JSON_THROW(std::domain_error("only objects can be unflattened"));
- }
-
- basic_json result;
-
- // iterate the JSON object values
- for (const auto& element : *value.m_value.object)
- {
- if (not element.second.is_primitive())
- {
- JSON_THROW(std::domain_error("values in object must be primitive"));
- }
-
- // assign value to reference pointed to by JSON pointer; Note
- // that if the JSON pointer is "" (i.e., points to the whole
- // value), function get_and_create returns a reference to
- // result itself. An assignment will then create a primitive
- // value.
- json_pointer(element.first).get_and_create(result) = element.second;
- }
-
- return result;
- }
-
- private:
- friend bool operator==(json_pointer const& lhs,
- json_pointer const& rhs) noexcept
- {
- return lhs.reference_tokens == rhs.reference_tokens;
- }
-
- friend bool operator!=(json_pointer const& lhs,
- json_pointer const& rhs) noexcept
- {
- return !(lhs == rhs);
- }
-
- /// the reference tokens
- std::vector<std::string> reference_tokens {};
- };
-
- //////////////////////////
- // JSON Pointer support //
- //////////////////////////
-
- /// @name JSON Pointer functions
- /// @{
-
- /*!
- @brief access specified element via JSON Pointer
-
- Uses a JSON pointer to retrieve a reference to the respective JSON value.
- No bound checking is performed. Similar to @ref operator[](const typename
- object_t::key_type&), `null` values are created in arrays and objects if
- necessary.
-
- In particular:
- - If the JSON pointer points to an object key that does not exist, it
- is created an filled with a `null` value before a reference to it
- is returned.
- - If the JSON pointer points to an array index that does not exist, it
- is created an filled with a `null` value before a reference to it
- is returned. All indices between the current maximum and the given
- index are also filled with `null`.
- - The special value `-` is treated as a synonym for the index past the
- end.
-
- @param[in] ptr a JSON pointer
-
- @return reference to the element pointed to by @a ptr
-
- @complexity Constant.
-
- @throw std::out_of_range if the JSON pointer can not be resolved
- @throw std::domain_error if an array index begins with '0'
- @throw std::invalid_argument if an array index was not a number
-
- @liveexample{The behavior is shown in the example.,operatorjson_pointer}
-
- @since version 2.0.0
- */
- reference operator[](const json_pointer& ptr)
- {
- return ptr.get_unchecked(this);
- }
-
- /*!
- @brief access specified element via JSON Pointer
-
- Uses a JSON pointer to retrieve a reference to the respective JSON value.
- No bound checking is performed. The function does not change the JSON
- value; no `null` values are created. In particular, the the special value
- `-` yields an exception.
-
- @param[in] ptr JSON pointer to the desired element
-
- @return const reference to the element pointed to by @a ptr
-
- @complexity Constant.
-
- @throw std::out_of_range if the JSON pointer can not be resolved
- @throw std::domain_error if an array index begins with '0'
- @throw std::invalid_argument if an array index was not a number
-
- @liveexample{The behavior is shown in the example.,operatorjson_pointer_const}
-
- @since version 2.0.0
- */
- const_reference operator[](const json_pointer& ptr) const
- {
- return ptr.get_unchecked(this);
- }
-
- /*!
- @brief access specified element via JSON Pointer
-
- Returns a reference to the element at with specified JSON pointer @a ptr,
- with bounds checking.
-
- @param[in] ptr JSON pointer to the desired element
-
- @return reference to the element pointed to by @a ptr
-
- @complexity Constant.
-
- @throw std::out_of_range if the JSON pointer can not be resolved
- @throw std::domain_error if an array index begins with '0'
- @throw std::invalid_argument if an array index was not a number
-
- @liveexample{The behavior is shown in the example.,at_json_pointer}
-
- @since version 2.0.0
- */
- reference at(const json_pointer& ptr)
- {
- return ptr.get_checked(this);
- }
-
- /*!
- @brief access specified element via JSON Pointer
-
- Returns a const reference to the element at with specified JSON pointer @a
- ptr, with bounds checking.
-
- @param[in] ptr JSON pointer to the desired element
-
- @return reference to the element pointed to by @a ptr
-
- @complexity Constant.
-
- @throw std::out_of_range if the JSON pointer can not be resolved
- @throw std::domain_error if an array index begins with '0'
- @throw std::invalid_argument if an array index was not a number
-
- @liveexample{The behavior is shown in the example.,at_json_pointer_const}
-
- @since version 2.0.0
- */
- const_reference at(const json_pointer& ptr) const
- {
- return ptr.get_checked(this);
- }
-
- /*!
- @brief return flattened JSON value
-
- The function creates a JSON object whose keys are JSON pointers (see [RFC
- 6901](https://tools.ietf.org/html/rfc6901)) and whose values are all
- primitive. The original JSON value can be restored using the @ref
- unflatten() function.
-
- @return an object that maps JSON pointers to primitive values
-
- @note Empty objects and arrays are flattened to `null` and will not be
- reconstructed correctly by the @ref unflatten() function.
-
- @complexity Linear in the size the JSON value.
-
- @liveexample{The following code shows how a JSON object is flattened to an
- object whose keys consist of JSON pointers.,flatten}
-
- @sa @ref unflatten() for the reverse function
-
- @since version 2.0.0
- */
- basic_json flatten() const
- {
- basic_json result(value_t::object);
- json_pointer::flatten("", *this, result);
- return result;
- }
-
- /*!
- @brief unflatten a previously flattened JSON value
-
- The function restores the arbitrary nesting of a JSON value that has been
- flattened before using the @ref flatten() function. The JSON value must
- meet certain constraints:
- 1. The value must be an object.
- 2. The keys must be JSON pointers (see
- [RFC 6901](https://tools.ietf.org/html/rfc6901))
- 3. The mapped values must be primitive JSON types.
-
- @return the original JSON from a flattened version
-
- @note Empty objects and arrays are flattened by @ref flatten() to `null`
- values and can not unflattened to their original type. Apart from
- this example, for a JSON value `j`, the following is always true:
- `j == j.flatten().unflatten()`.
-
- @complexity Linear in the size the JSON value.
-
- @liveexample{The following code shows how a flattened JSON object is
- unflattened into the original nested JSON object.,unflatten}
-
- @sa @ref flatten() for the reverse function
-
- @since version 2.0.0
- */
- basic_json unflatten() const
- {
- return json_pointer::unflatten(*this);
- }
-
- /// @}
-
- //////////////////////////
- // JSON Patch functions //
- //////////////////////////
-
- /// @name JSON Patch functions
- /// @{
-
- /*!
- @brief applies a JSON patch
-
- [JSON Patch](http://jsonpatch.com) defines a JSON document structure for
- expressing a sequence of operations to apply to a JSON) document. With
- this function, a JSON Patch is applied to the current JSON value by
- executing all operations from the patch.
-
- @param[in] json_patch JSON patch document
- @return patched document
-
- @note The application of a patch is atomic: Either all operations succeed
- and the patched document is returned or an exception is thrown. In
- any case, the original value is not changed: the patch is applied
- to a copy of the value.
-
- @throw std::out_of_range if a JSON pointer inside the patch could not
- be resolved successfully in the current JSON value; example: `"key baz
- not found"`
- @throw invalid_argument if the JSON patch is malformed (e.g., mandatory
- attributes are missing); example: `"operation add must have member path"`
-
- @complexity Linear in the size of the JSON value and the length of the
- JSON patch. As usually only a fraction of the JSON value is affected by
- the patch, the complexity can usually be neglected.
-
- @liveexample{The following code shows how a JSON patch is applied to a
- value.,patch}
-
- @sa @ref diff -- create a JSON patch by comparing two JSON values
-
- @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
- @sa [RFC 6901 (JSON Pointer)](https://tools.ietf.org/html/rfc6901)
-
- @since version 2.0.0
- */
- basic_json patch(const basic_json& json_patch) const
- {
- // make a working copy to apply the patch to
- basic_json result = *this;
-
- // the valid JSON Patch operations
- enum class patch_operations {add, remove, replace, move, copy, test, invalid};
-
- const auto get_op = [](const std::string op)
- {
- if (op == "add")
- {
- return patch_operations::add;
- }
- if (op == "remove")
- {
- return patch_operations::remove;
- }
- if (op == "replace")
- {
- return patch_operations::replace;
- }
- if (op == "move")
- {
- return patch_operations::move;
- }
- if (op == "copy")
- {
- return patch_operations::copy;
- }
- if (op == "test")
- {
- return patch_operations::test;
- }
-
- return patch_operations::invalid;
- };
-
- // wrapper for "add" operation; add value at ptr
- const auto operation_add = [&result](json_pointer & ptr, basic_json val)
- {
- // adding to the root of the target document means replacing it
- if (ptr.is_root())
- {
- result = val;
- }
- else
- {
- // make sure the top element of the pointer exists
- json_pointer top_pointer = ptr.top();
- if (top_pointer != ptr)
- {
- result.at(top_pointer);
- }
-
- // get reference to parent of JSON pointer ptr
- const auto last_path = ptr.pop_back();
- basic_json& parent = result[ptr];
-
- switch (parent.m_type)
- {
- case value_t::null:
- case value_t::object:
- {
- // use operator[] to add value
- parent[last_path] = val;
- break;
- }
-
- case value_t::array:
- {
- if (last_path == "-")
- {
- // special case: append to back
- parent.push_back(val);
- }
- else
- {
- const auto idx = std::stoi(last_path);
- if (static_cast<size_type>(idx) > parent.size())
- {
- // avoid undefined behavior
- JSON_THROW(std::out_of_range("array index " + std::to_string(idx) + " is out of range"));
- }
- else
- {
- // default case: insert add offset
- parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
- }
- }
- break;
- }
-
- default:
- {
- // if there exists a parent it cannot be primitive
- assert(false); // LCOV_EXCL_LINE
- }
- }
- }
- };
-
- // wrapper for "remove" operation; remove value at ptr
- const auto operation_remove = [&result](json_pointer & ptr)
- {
- // get reference to parent of JSON pointer ptr
- const auto last_path = ptr.pop_back();
- basic_json& parent = result.at(ptr);
-
- // remove child
- if (parent.is_object())
- {
- // perform range check
- auto it = parent.find(last_path);
- if (it != parent.end())
- {
- parent.erase(it);
- }
- else
- {
- JSON_THROW(std::out_of_range("key '" + last_path + "' not found"));
- }
- }
- else if (parent.is_array())
- {
- // note erase performs range check
- parent.erase(static_cast<size_type>(std::stoi(last_path)));
- }
- };
-
- // type check
- if (not json_patch.is_array())
- {
- // a JSON patch must be an array of objects
- JSON_THROW(std::invalid_argument("JSON patch must be an array of objects"));
- }
-
- // iterate and apply the operations
- for (const auto& val : json_patch)
- {
- // wrapper to get a value for an operation
- const auto get_value = [&val](const std::string & op,
- const std::string & member,
- bool string_type) -> basic_json&
- {
- // find value
- auto it = val.m_value.object->find(member);
-
- // context-sensitive error message
- const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
-
- // check if desired value is present
- if (it == val.m_value.object->end())
- {
- JSON_THROW(std::invalid_argument(error_msg + " must have member '" + member + "'"));
- }
-
- // check if result is of type string
- if (string_type and not it->second.is_string())
- {
- JSON_THROW(std::invalid_argument(error_msg + " must have string member '" + member + "'"));
- }
-
- // no error: return value
- return it->second;
- };
-
- // type check
- if (not val.is_object())
- {
- JSON_THROW(std::invalid_argument("JSON patch must be an array of objects"));
- }
-
- // collect mandatory members
- const std::string op = get_value("op", "op", true);
- const std::string path = get_value(op, "path", true);
- json_pointer ptr(path);
-
- switch (get_op(op))
- {
- case patch_operations::add:
- {
- operation_add(ptr, get_value("add", "value", false));
- break;
- }
-
- case patch_operations::remove:
- {
- operation_remove(ptr);
- break;
- }
-
- case patch_operations::replace:
- {
- // the "path" location must exist - use at()
- result.at(ptr) = get_value("replace", "value", false);
- break;
- }
-
- case patch_operations::move:
- {
- const std::string from_path = get_value("move", "from", true);
- json_pointer from_ptr(from_path);
-
- // the "from" location must exist - use at()
- basic_json v = result.at(from_ptr);
-
- // The move operation is functionally identical to a
- // "remove" operation on the "from" location, followed
- // immediately by an "add" operation at the target
- // location with the value that was just removed.
- operation_remove(from_ptr);
- operation_add(ptr, v);
- break;
- }
-
- case patch_operations::copy:
- {
- const std::string from_path = get_value("copy", "from", true);;
- const json_pointer from_ptr(from_path);
-
- // the "from" location must exist - use at()
- result[ptr] = result.at(from_ptr);
- break;
- }
-
- case patch_operations::test:
- {
- bool success = false;
- JSON_TRY
- {
- // check if "value" matches the one at "path"
- // the "path" location must exist - use at()
- success = (result.at(ptr) == get_value("test", "value", false));
- }
- JSON_CATCH (std::out_of_range&)
- {
- // ignore out of range errors: success remains false
- }
-
- // throw an exception if test fails
- if (not success)
- {
- JSON_THROW(std::domain_error("unsuccessful: " + val.dump()));
- }
-
- break;
- }
-
- case patch_operations::invalid:
- {
- // op must be "add", "remove", "replace", "move", "copy", or
- // "test"
- JSON_THROW(std::invalid_argument("operation value '" + op + "' is invalid"));
- }
- }
- }
-
- return result;
- }
-
- /*!
- @brief creates a diff as a JSON patch
-
- Creates a [JSON Patch](http://jsonpatch.com) so that value @a source can
- be changed into the value @a target by calling @ref patch function.
-
- @invariant For two JSON values @a source and @a target, the following code
- yields always `true`:
- @code {.cpp}
- source.patch(diff(source, target)) == target;
- @endcode
-
- @note Currently, only `remove`, `add`, and `replace` operations are
- generated.
-
- @param[in] source JSON value to compare from
- @param[in] target JSON value to compare against
- @param[in] path helper value to create JSON pointers
-
- @return a JSON patch to convert the @a source to @a target
-
- @complexity Linear in the lengths of @a source and @a target.
-
- @liveexample{The following code shows how a JSON patch is created as a
- diff for two JSON values.,diff}
-
- @sa @ref patch -- apply a JSON patch
-
- @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
-
- @since version 2.0.0
- */
- static basic_json diff(const basic_json& source,
- const basic_json& target,
- const std::string& path = "")
- {
- // the patch
- basic_json result(value_t::array);
-
- // if the values are the same, return empty patch
- if (source == target)
- {
- return result;
- }
-
- if (source.type() != target.type())
- {
- // different types: replace value
- result.push_back(
- {
- {"op", "replace"},
- {"path", path},
- {"value", target}
- });
- }
- else
- {
- switch (source.type())
- {
- case value_t::array:
- {
- // first pass: traverse common elements
- size_t i = 0;
- while (i < source.size() and i < target.size())
- {
- // recursive call to compare array values at index i
- auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
- result.insert(result.end(), temp_diff.begin(), temp_diff.end());
- ++i;
- }
-
- // i now reached the end of at least one array
- // in a second pass, traverse the remaining elements
-
- // remove my remaining elements
- const auto end_index = static_cast<difference_type>(result.size());
- while (i < source.size())
- {
- // add operations in reverse order to avoid invalid
- // indices
- result.insert(result.begin() + end_index, object(
- {
- {"op", "remove"},
- {"path", path + "/" + std::to_string(i)}
- }));
- ++i;
- }
-
- // add other remaining elements
- while (i < target.size())
- {
- result.push_back(
- {
- {"op", "add"},
- {"path", path + "/" + std::to_string(i)},
- {"value", target[i]}
- });
- ++i;
- }
-
- break;
- }
-
- case value_t::object:
- {
- // first pass: traverse this object's elements
- for (auto it = source.begin(); it != source.end(); ++it)
- {
- // escape the key name to be used in a JSON patch
- const auto key = json_pointer::escape(it.key());
-
- if (target.find(it.key()) != target.end())
- {
- // recursive call to compare object values at key it
- auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);
- result.insert(result.end(), temp_diff.begin(), temp_diff.end());
- }
- else
- {
- // found a key that is not in o -> remove it
- result.push_back(object(
- {
- {"op", "remove"},
- {"path", path + "/" + key}
- }));
- }
- }
-
- // second pass: traverse other object's elements
- for (auto it = target.begin(); it != target.end(); ++it)
- {
- if (source.find(it.key()) == source.end())
- {
- // found a key that is not in this -> add it
- const auto key = json_pointer::escape(it.key());
- result.push_back(
- {
- {"op", "add"},
- {"path", path + "/" + key},
- {"value", it.value()}
- });
- }
- }
-
- break;
- }
-
- default:
- {
- // both primitive type: replace value
- result.push_back(
- {
- {"op", "replace"},
- {"path", path},
- {"value", target}
- });
- break;
- }
- }
- }
-
- return result;
- }
-
- /// @}
-};
-
-/////////////
-// presets //
-/////////////
-
-/*!
-@brief default JSON class
-
-This type is the default specialization of the @ref basic_json class which
-uses the standard template types.
-
-@since version 1.0.0
-*/
-using json = basic_json<>;
-} // namespace nlohmann
-
-
-///////////////////////
-// nonmember support //
-///////////////////////
-
-// specialization of std::swap, and std::hash
-namespace std
-{
-/*!
-@brief exchanges the values of two JSON objects
-
-@since version 1.0.0
-*/
-template<>
-inline void swap(nlohmann::json& j1,
- nlohmann::json& j2) noexcept(
- is_nothrow_move_constructible<nlohmann::json>::value and
- is_nothrow_move_assignable<nlohmann::json>::value
- )
-{
- j1.swap(j2);
-}
-
-/// hash value for JSON objects
-template<>
-struct hash<nlohmann::json>
-{
- /*!
- @brief return a hash value for a JSON object
-
- @since version 1.0.0
- */
- std::size_t operator()(const nlohmann::json& j) const
- {
- // a naive hashing via the string representation
- const auto& h = hash<nlohmann::json::string_t>();
- return h(j.dump());
- }
-};
-} // namespace std
-
-/*!
-@brief user-defined string literal for JSON values
-
-This operator implements a user-defined string literal for JSON objects. It
-can be used by adding `"_json"` to a string literal and returns a JSON object
-if no parse error occurred.
-
-@param[in] s a string representation of a JSON object
-@param[in] n the length of string @a s
-@return a JSON object
-
-@since version 1.0.0
-*/
-inline nlohmann::json operator "" _json(const char* s, std::size_t n)
-{
- return nlohmann::json::parse(s, s + n);
-}
-
-/*!
-@brief user-defined string literal for JSON pointer
-
-This operator implements a user-defined string literal for JSON Pointers. It
-can be used by adding `"_json_pointer"` to a string literal and returns a JSON pointer
-object if no parse error occurred.
-
-@param[in] s a string representation of a JSON Pointer
-@param[in] n the length of string @a s
-@return a JSON pointer object
-
-@since version 2.0.0
-*/
-inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
-{
- return nlohmann::json::json_pointer(std::string(s, n));
-}
-
-// restore GCC/clang diagnostic settings
-#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
- #pragma GCC diagnostic pop
-#endif
-
-// clean up
-#undef JSON_CATCH
-#undef JSON_DEPRECATED
-#undef JSON_THROW
-#undef JSON_TRY
-
-#endif
diff --git a/policy_manager/db/roles.db b/policy_manager/db/roles.db
index 5d31aea..184e602 100644
--- a/policy_manager/db/roles.db
+++ b/policy_manager/db/roles.db
@@ -8,7 +8,7 @@
},
{
"category": "debug",
- "role": "launcher | map | poi | browser | sdl | mixer | radio | hvac | debug | phone | video | music | settings | dashboard | fallback",
+ "role": "launcher | navigation | map | poi | browser | sdl | mixer | radio | hvac | debug | phone | video | music | settings | dashboard | fallback",
"area": "normal.full | split.main | split.sub | fullscreen",
"layer": "apps",
},
diff --git a/policy_manager/db/roles.db.zipc b/policy_manager/db/roles.db.zipc
index facb1d8..13ada24 100644
--- a/policy_manager/db/roles.db.zipc
+++ b/policy_manager/db/roles.db.zipc
@@ -8,7 +8,7 @@
},
{
"category": "map",
- "role": "map",
+ "role": "navigation",
"area": "normal.full | split.main",
"layer": "apps",
},
diff --git a/policy_manager/db/roles.db.zipc.split b/policy_manager/db/roles.db.zipc.split
index 73c80cf..cef2631 100644
--- a/policy_manager/db/roles.db.zipc.split
+++ b/policy_manager/db/roles.db.zipc.split
@@ -8,7 +8,7 @@
},
{
"category": "map",
- "role": "map",
+ "role": "navigation",
"area": "normal.full | split.main",
"layer": "apps",
},
diff --git a/policy_manager/policy_manager.cpp b/policy_manager/policy_manager.cpp
index 4955aa3..ab44b05 100644
--- a/policy_manager/policy_manager.cpp
+++ b/policy_manager/policy_manager.cpp
@@ -690,7 +690,7 @@ int PolicyManager::timerEvent(sd_event_source *source, uint64_t usec, void *data
int PolicyManager::setStateTransitionProcessToSystemd(int event_id, uint64_t delay_ms, std::string role)
{
struct sd_event_source *event_source;
- HMI_DEBUG("wm:pm", "event_id:0x%x delay:%d role:%s", event_id, delay_ms, role.c_str());
+ HMI_DEBUG("wm:pm event_id:0x%x delay:%d role:%s", event_id, delay_ms, role.c_str());
if (0 == delay_ms)
{
@@ -698,7 +698,7 @@ int PolicyManager::setStateTransitionProcessToSystemd(int event_id, uint64_t del
&pm::transitionStateWrapper, new int(event_id));
if (0 > ret)
{
- HMI_ERROR("wm:pm", "Faild to sd_event_add_defer: errno:%d", ret);
+ HMI_ERROR("wm:pm Failed to sd_event_add_defer: errno:%d", ret);
return -1;
}
}
@@ -717,7 +717,7 @@ int PolicyManager::setStateTransitionProcessToSystemd(int event_id, uint64_t del
&pm::timerEventWrapper, new int(event_id));
if (0 > ret)
{
- HMI_ERROR("wm:pm", "Faild to sd_event_add_time: errno:%d", ret);
+ HMI_ERROR("wm:pm Failed to sd_event_add_time: errno:%d", ret);
return -1;
}
}
@@ -730,7 +730,7 @@ int PolicyManager::setStateTransitionProcessToSystemd(int event_id, uint64_t del
int PolicyManager::loadRoleDb()
{
- std::string file_name(get_file_path("roles.db", "wm:pm"));
+ std::string file_name(get_file_path("roles.db"));
// Load roles.db
json_object *json_obj;
@@ -820,7 +820,7 @@ int PolicyManager::loadStateDb()
{
HMI_DEBUG("Call");
- std::string file_name(get_file_path("states.db", "wm:pm"));
+ std::string file_name(get_file_path("states.db"));
// Load states.db
json_object *json_obj;
diff --git a/protocol/ivi-wm.xml b/protocol/ivi-wm.xml
deleted file mode 100644
index da45c7e..0000000
--- a/protocol/ivi-wm.xml
+++ /dev/null
@@ -1,608 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<protocol name="ivi_wm">
-
- <copyright>
- Copyright (C) 2017 Advanced Driver Information Technology Joint Venture GmbH
-
- 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.
- </copyright>
-
- <interface name="ivi_wm_screen" version="1">
- <description summary="controller interface to screen in ivi compositor"/>
-
- <request name="destroy" type="destructor">
- <description summary="destroy ivi_wm_screen">
- Request to destroy the ivi_wm_screen.
- </description>
- </request>
-
- <request name="clear">
- <description summary="remove all layers from screen render order">
- A screen has no content assigned to itself, it is a container for layers.
- This request removes all layers from the screen render order.
- Note: the layers are not destroyed, they are just no longer contained by
- the screen.
- </description>
- </request>
-
- <request name="add_layer">
- <description summary="add a layer to screen render order at nearest z-position">
- A screen has no content assigned to itself, it is a container for layers.
- This request adds a layers to the topmost position of the screen render order.
- The added layer will cover all other layers of the screen.
- </description>
- <arg name="layer_id" type="uint"/>
- </request>
-
- <request name="remove_layer">
- <description summary="remove a layer to screen render order">
- A screen has no content assigned to itself, it is a container for layers.
- This request removes a layer.
- </description>
- <arg name="layer_id" type="uint"/>
- </request>
-
- <request name="screenshot">
- <description summary="take screenshot of screen">
- An ivi_screenshot object is created which will receive the screenshot
- data of the specified output.
- </description>
- <arg name="screenshot" type="new_id" interface="ivi_screenshot"/>
- </request>
-
- <request name="get">
- <description summary="get a parameter of a screen in ivi compositor">
- After this request, compositor sends the requested parameter.
- </description>
- <arg name="param" type="int"/>
- </request>
-
- <event name="screen_id">
- <description summary="advertise server side id of the ivi-screen">
- Sent immediately after creating the ivi_wm_screen object.
- </description>
- <arg name="id" type="uint"/>
- </event>
-
- <event name="layer_added">
- <description summary="update render order of the screen">
- A layer is added to the render order lisf of the screen
- </description>
- <arg name="layer_id" type="uint"/>
- </event>
-
- <event name="connector_name">
- <description summary="advertise connector name of the corresponding output">
- Sent immediately after creating the ivi_wm_screen object.
- </description>
- <arg name="process_name" type="string"/>
- </event>
-
- <enum name="error">
- <entry name="no_layer" value="0"
- summary="the layer with given id does not exist"/>
- <entry name="no_screen" value="1"
- summary="the output is already destroyed"/>
- <entry name="bad_param" value="2"
- summary="the given parameter is not valid"/>
- </enum>
-
- <event name="error">
- <description summary="error event">
- The error event is sent out when an error has occurred.
- </description>
- <arg name="error" type="uint" summary="error code"/>
- <arg name="message" type="string" summary="error description"/>
- </event>
- </interface>
-
- <interface name="ivi_screenshot" version="1">
- <description summary="screenshot of an output or a surface">
- An ivi_screenshot object receives a single "done" or "error" event.
- The server will destroy this resource after the event has been send,
- so the client shall then destroy its proxy too.
- </description>
-
- <event name="done">
- <description summary="screenshot finished">
- This event contains a filedescriptor for a file with raw image data.
- Furthermore size, stride, format and timestamp of screenshot are
- provided.
- </description>
- <arg name="fd" type="fd" summary="fd for file containing image data"/>
- <arg name="width" type="int" summary="image width in pixels"/>
- <arg name="height" type="int" summary="image height in pixels"/>
- <arg name="stride" type="int" summary="number of bytes per pixel row"/>
- <arg name="format" type="uint" summary="image format of type wl_shm.format"/>
- <arg name="timestamp" type="uint" summary="timestamp in milliseconds"/>
- </event>
-
- <enum name="error">
- <entry name="io_error" value="0"
- summary="screenshot file could not be created"/>
- <entry name="not_supported" value="1"
- summary="screenshot can not be read"/>
- <entry name="no_output" value="2"
- summary="output has been destroyed"/>
- <entry name="no_surface" value="3"
- summary="surface has been destroyed"/>
- <entry name="no_content" value="4"
- summary="surface has no content"/>
- </enum>
-
- <event name="error">
- <description summary="error event">
- The error event is sent when the screenshot could not be created.
- </description>
- <arg name="error" type="uint" enum="error" summary="error code"/>
- <arg name="message" type="string" summary="error description"/>
- </event>
- </interface>
-
- <interface name="ivi_wm" version="1">
- <description summary="interface for ivi managers to use ivi compositor features"/>
-
- <request name="commit_changes">
- <description summary="commit all changes requested by client">
- All requests are not applied directly to scene object, so a controller
- can set different properties and apply the changes all at once.
- Note: there's an exception to this. Creation and destruction of
- scene objects is executed immediately.
- </description>
- </request>
-
- <request name="create_screen">
- <description summary="create a screen in ivi-compositor">
- Ask the ivi-wm to create a ivi-screen for given wl_output.
- </description>
- <arg name="output" type="object" interface="wl_output"/>
- <arg name="id" type="new_id" interface="ivi_wm_screen" summary="the new ivi-screen"/>
- </request>
-
- <request name="set_surface_visibility">
- <description summary="set the visibility of a surface in ivi compositor">
- If visibility argument is 0, the surface in the ivi compositor is set to invisible.
- If visibility argument is not 0, the surface in the ivi compositor is set to visible.
- </description>
- <arg name="surface_id" type="uint"/>
- <arg name="visibility" type="uint"/>
- </request>
-
- <request name="set_layer_visibility">
- <description summary="set visibility of layer in ivi compositor">
- If visibility argument is 0, the layer in the ivi compositor is set to invisible.
- If visibility argument is not 0, the layer in the ivi compositor is set to visible.
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="visibility" type="uint"/>
- </request>
-
- <request name="set_surface_opacity">
- <description summary="set the opacity of a surface in ivi compositor">
- The valid range for opacity is 0.0 (fully transparent) to 1.0 (fully opaque).
- </description>
- <arg name="surface_id" type="uint"/>
- <arg name="opacity" type="fixed"/>
- </request>
-
- <request name="set_layer_opacity">
- <description summary="set opacity of layer in ivi compositor">
- The valid range for opacity is 0.0 (fully transparent) to 1.0 (fully opaque).
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="opacity" type="fixed"/>
- </request>
-
- <request name="set_surface_source_rectangle">
- <description summary="set the scanout area of a surface in ivi compositor">
- The source rectangle defines the part of the surface content, that is used for
- compositing the surface. It can be used, if valid content of the surface is smaller
- than the surface. Effectively it can be used to zoom the content of the surface.
- If a parameter is less than 0, that value is not changed.
- x: horizontal start position of scanout area within the surface
- y: vertical start position of scanout area within the surface
- width: width of scanout area within the surface
- height: height of scanout area within the surface
- </description>
- <arg name="surface_id" type="uint"/>
- <arg name="x" type="int"/>
- <arg name="y" type="int"/>
- <arg name="width" type="int"/>
- <arg name="height" type="int"/>
- </request>
-
- <request name="set_layer_source_rectangle">
- <description summary="set the scanout area of a layer in ivi compositor">
- The source rectangle defines the part of the layer content, that is used for
- compositing the screen. It can be used, if valid content of the layer is smaller
- than the layer. Effectively it can be used to zoom the content of the layer.
- If a parameter is less than 0, that value is not changed.
- x: horizontal start position of scanout area within the layer
- y: vertical start position of scanout area within the layer
- width: width of scanout area within the layer
- height: height of scanout area within the layer
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="x" type="int"/>
- <arg name="y" type="int"/>
- <arg name="width" type="int"/>
- <arg name="height" type="int"/>
- </request>
-
- <request name="set_surface_destination_rectangle">
- <description summary="Set the destination area of a surface within a layer">
- The destination rectangle defines the position and size of a surface on a layer.
- The surface will be scaled to this rectangle for rendering.
- If a parameter is less than 0, that value is not changed.
- x: horizontal start position of surface within the layer
- y: vertical start position of surface within the layer
- width : width of surface within the layer
- height: height of surface within the layer
- </description>
- <arg name="surface_id" type="uint"/>
- <arg name="x" type="int"/>
- <arg name="y" type="int"/>
- <arg name="width" type="int"/>
- <arg name="height" type="int"/>
- </request>
-
- <request name="set_layer_destination_rectangle">
- <description summary="Set the destination area of a layer within a screen">
- The destination rectangle defines the position and size of a layer on a screen.
- The layer will be scaled to this rectangle for rendering.
- If a parameter is less than 0, that value is not changed.
- x: horizontal start position of layer within the screen
- y: vertical start position of layer within the screen
- width : width of surface within the screen
- height: height of surface within the screen
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="x" type="int"/>
- <arg name="y" type="int"/>
- <arg name="width" type="int"/>
- <arg name="height" type="int"/>
- </request>
-
- <enum name="sync">
- <description summary="sync request states">
- </description>
- <entry name="add" value="0"/>
- <entry name="remove" value="1"/>
- </enum>
-
- <request name="surface_sync">
- <description summary="request to synchronize of a surface in ivi compositor">
- After this request, compositor sends the properties of the surface.
- If sync_state argument is 0, compositor sends the properties continously.
- If sync_state argument is not 0, compositor stops sending the properties
- continously.
- </description>
- <arg name="surface_id" type="uint"/>
- <arg name="sync_state" type="int"/>
- </request>
-
- <request name="layer_sync">
- <description summary="request to synchronize of a layer in ivi compositor">
- After this request, compositor sends the properties of the layer.
- If sync_state argument is 0, compositor sends the properties continously.
- If sync_state argument is not 0, compositor stops sending the properties
- continously.
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="sync_state" type="int"/>
- </request>
-
- <enum name="param" bitfield="true">
- <description summary="parameter types">
- The HMI controller can request different types of parameters of an
- ivi-object.
- </description>
- <entry name="opacity" value="1"/>
- <entry name="visibility" value="2"/>
- <entry name="size" value="4"/>
- <entry name="render_order" value="8"/>
- </enum>
-
- <request name="surface_get">
- <description summary="get a parameter of an ivi_layout_surface in ivi compositor">
- After this request, compositor sends the requested parameter.
- </description>
- <arg name="surface_id" type="uint"/>
- <arg name="param" type="int"/>
- </request>
-
- <request name="layer_get">
- <description summary="get a parameter of an ivi_layout_layer in ivi compositor">
- After this request, compositor sends the requested parameter.
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="param" type="int"/>
- </request>
-
- <request name="surface_screenshot">
- <description summary="take screenshot of surface">
- An ivi_screenshot object is created which will receive an image of the
- buffer currently attached to the surface with the given id. If there
- is no surface with such name the server will respond with an
- ivi_screenshot.error event.
- </description>
- <arg name="screenshot" type="new_id" interface="ivi_screenshot"/>
- <arg name="surface_id" type="uint"/>
- </request>
-
- <enum name="surface_type">
- <description summary="hint for the compositor">
- If a surface is restricted type, visible contents of the surface is strictly
- controlled by the compositor. Its content is not allowed to be go out of
- its destination region. If the application resizes its buffers or uses
- wp_viewporter protocol to scale its contents, the old destination region
- would causes visible glitches.
- To avoid these issues, the controller process mark a surface as desktop
- compatible. Source and destination regions of a desktop compatible
- surface will be modified accordingly,when application sends a request
- for resizing or scaling its contents. Therefore, applications contents
- will be drawn according to application's wishes.
- On the other hand, source and destination regions will be strictly
- enforced, when the surface's type is restricted. The default type for
- a surface is ivi.
- </description>
- <entry name="restricted" value="0" summary="strictly controlled"/>
- <entry name="desktop" value="1" summary="free to resize and scale"/>
- </enum>
-
- <request name="set_surface_type">
- <description summary="request to set a type for the surface in ivi compositor">
- After this request, compositor changes the type of the surface.
- </description>
- <arg name="surface_id" type="uint"/>
- <arg name="type" type="int"/>
- </request>
-
- <request name="layer_clear">
- <description summary="remove all surfaces from layer render order">
- A layer has no content assigned to itself, it is a container for surfaces.
- This request removes all surfaces from the layer render order.
- </description>
- <arg name="layer_id" type="uint"/>
- </request>
-
- <request name="layer_add_surface">
- <description summary="add a surface to layer render order at nearest z-position">
- A layer has no content assigned to itself, it is a container for surfaces.
- This request adds a surface to the topmost position of the layer render order.
- The added surface will cover all other surfaces of the layer.
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="surface_id" type="uint"/>
- </request>
-
- <request name="layer_remove_surface">
- <description summary="remove a surface from layer render order">
- A layer has no content assigned to itself, it is a container for surfaces.
- This request removes one surfaces from the layer render order.
- Note: the surface is not destroyed, it is just no longer contained by
- the layer.
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="surface_id" type="uint"/>
- </request>
-
- <request name="create_layout_layer">
- <description summary="create an ivi_layout_layer in ivi compositor">
- After this request, compositor creates an ivi_layout_layer
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="width" type="int"/>
- <arg name="height" type="int"/>
- </request>
-
- <request name="destroy_layout_layer">
- <description summary="destroy an ivi_layout_layer in ivi compositor">
- After this request, compositor destroyes an existing ivi_layout_layer.
- </description>
- <arg name="layer_id" type="uint"/>
- </request>
-
- <event name="surface_visibility">
- <description summary="the visibility of the surface in ivi compositor has changed">
- The new visibility state is provided in argument visibility.
- If visibility is 0, the surface has become invisible.
- If visibility is not 0, the surface has become visible.
- </description>
- <arg name="surface_id" type="uint"/>
- <arg name="visibility" type="int"/>
- </event>
-
- <event name="layer_visibility">
- <description summary="the visibility of the layer in ivi compositor has changed">
- The new visibility state is provided in argument visibility.
- If visibility is 0, the layer has become invisible.
- If visibility is not 0, the layer has become visible.
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="visibility" type="int"/>
- </event>
-
- <event name="surface_opacity">
- <description summary="the opacity of surface in ivi compositor has changed">
- The new opacity state is provided in argument opacity.
- The valid range for opactiy is 0.0 (fully transparent) to 1.0 (fully opaque).
- </description>
- <arg name="surface_id" type="uint"/>
- <arg name="opacity" type="fixed"/>
- </event>
-
- <event name="layer_opacity">
- <description summary="the opacity of layer in ivi compositor has changed">
- The new opacity state is provided in argument opacity.
- The valid range for opactiy is 0.0 (fully transparent) to 1.0 (fully opaque).
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="opacity" type="fixed"/>
- </event>
-
- <event name="surface_source_rectangle">
- <description summary="the source rectangle of surface in ivi compositor has changed">
- The scanout region of the surface content has changed.
- The new values for source rectangle are provided by
- x: new horizontal start position of scanout area within the surface
- y: new vertical start position of scanout area within the surface
- width: new width of scanout area within the surface
- height: new height of scanout area within the surface
- </description>
- <arg name="surface_id" type="uint"/>
- <arg name="x" type="int"/>
- <arg name="y" type="int"/>
- <arg name="width" type="int"/>
- <arg name="height" type="int"/>
- </event>
-
- <event name="layer_source_rectangle">
- <description summary="the source rectangle of layer in ivi compositor has changed">
- The scanout region of the layer content has changed.
- The new values for source rectangle are provided by
- x: new horizontal start position of scanout area within the layer
- y: new vertical start position of scanout area within the layer
- width: new width of scanout area within the layer
- height: new height of scanout area within the layer
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="x" type="int"/>
- <arg name="y" type="int"/>
- <arg name="width" type="int"/>
- <arg name="height" type="int"/>
- </event>
-
- <event name="surface_destination_rectangle">
- <description summary="the destination rectangle of surface in ivi compositor has changed">
- The new values for source rectangle are provided by
- x: new horizontal start position of surface within the layer
- y: new vertical start position of surface within the layer
- width : new width of surface within the layer
- height: new height of surface within the layer
- </description>
- <arg name="surface_id" type="uint"/>
- <arg name="x" type="int"/>
- <arg name="y" type="int"/>
- <arg name="width" type="int"/>
- <arg name="height" type="int"/>
- </event>
-
- <event name="layer_destination_rectangle">
- <description summary="the destination rectangle of layer in ivi compositor has changed">
- The new values for source rectangle are provided by
- x: new horizontal start position of layer within the screen
- y: new vertical start position of layer within the screen
- width : new width of layer within the screen
- height: new height of layer within the screen
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="x" type="int"/>
- <arg name="y" type="int"/>
- <arg name="width" type="int"/>
- <arg name="height" type="int"/>
- </event>
-
- <event name="surface_created">
- <description summary="ivi_layout_surface was created"/>
- <arg name="surface_id" type="uint"/>
- </event>
-
- <event name="layer_created">
- <description summary="ivi_layout_layer was created"/>
- <arg name="layer_id" type="uint"/>
- </event>
-
- <event name="surface_destroyed">
- <description summary="ivi_layout_surface was destroyed"/>
- <arg name="surface_id" type="uint"/>
- </event>
-
- <event name="layer_destroyed">
- <description summary="ivi_layout_layer was destroyed"/>
- <arg name="layer_id" type="uint"/>
- </event>
-
- <enum name="surface_error">
- <entry name="no_surface" value="0"
- summary="the surface with given id does not exist"/>
- <entry name="bad_param" value="1"
- summary="the given parameter is not valid"/>
- <entry name="not_supported" value="2"
- summary="the request is not supported"/>
- </enum>
-
- <event name="surface_error">
- <description summary="error event">
- The error event is sent out when an error has occurred.
- </description>
- <arg name="object_id" type="uint" summary="id of a layer or surface"/>
- <arg name="error" type="uint" summary="error code"/>
- <arg name="message" type="string" summary="error description"/>
- </event>
-
- <enum name="layer_error">
- <entry name="no_surface" value="0"
- summary="the surface with given id does not exist"/>
- <entry name="no_layer" value="1"
- summary="the layer with given id does not exist"/>
- <entry name="bad_param" value="2"
- summary="the given parameter is not valid"/>
- </enum>
-
- <event name="layer_error">
- <description summary="error event">
- The error event is sent out when an error has occurred.
- </description>
- <arg name="object_id" type="uint" summary="id of a layer or surface"/>
- <arg name="error" type="uint" summary="error code"/>
- <arg name="message" type="string" summary="error description"/>
- </event>
-
- <event name="surface_size">
- <description summary="the surface size in ivi compositor has changed">
- The client providing content for this surface modified size of the surface.
- The modified surface size is provided by arguments width and height.
- </description>
- <arg name="surface_id" type="uint"/>
- <arg name="width" type="int"/>
- <arg name="height" type="int"/>
- </event>
-
- <event name="surface_stats">
- <description summary="receive updated statistics for surface in ivi compositor">
- The information contained in this event is essential for monitoring, debugging,
- logging and tracing support in IVI systems.
- </description>
- <arg name="surface_id" type="uint"/>
- <arg name="frame_count" type="uint"/>
- <arg name="pid" type="uint"/>
- </event>
-
- <event name="layer_surface_added">
- <description summary="update render order of the layer">
- A surface is added to the render order of the layer
- </description>
- <arg name="layer_id" type="uint"/>
- <arg name="surface_id" type="uint"/>
- </event>
- </interface>
-
-</protocol>
-
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 3c8da4c..5c532e2 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -14,10 +14,9 @@
# limitations under the License.
#
-wlproto(IVI_CON ivi-wm)
-
include(FindPkgConfig)
pkg_check_modules(AFB REQUIRED afb-daemon)
+pkg_check_modules(ILM REQUIRED ilmControl ilmCommon)
pkg_check_modules(SD REQUIRED libsystemd>=222)
# We do not want a prefix for our module
@@ -27,24 +26,22 @@ set(TARGETS_WM windowmanager-service)
add_library(${TARGETS_WM} MODULE
main.cpp
- wayland_ivi_wm.cpp
util.cpp
- layout.cpp
- ${IVI_CON_PROTO}
json_helper.cpp
+ applist.cpp
+ request.cpp
+ pm_wrapper.cpp
window_manager.cpp
- layers.cpp
wm_client.cpp
wm_error.cpp
- applist.cpp
- request.cpp
- pm_wrapper.cpp)
+ wm_layer.cpp
+ wm_layer_control.cpp)
target_include_directories(${TARGETS_WM}
PRIVATE
${AFB_INCLUDE_DIRS}
${SD_INCLUDE_DIRS}
- ../include
+ ${ILM_INCLUDE_DIRS}
../src
../${PLUGIN_PM})
@@ -52,6 +49,7 @@ target_link_libraries(${TARGETS_WM}
PRIVATE
${AFB_LIBRARIES}
${WLC_LIBRARIES}
+ ${ILM_LIBRARIES}
${SD_LIBRARIES}
${PLUGIN_PM})
@@ -71,7 +69,7 @@ endif()
target_compile_options(${TARGETS_WM}
PRIVATE
- -Wall -Wextra -Wno-unused-parameter -Wno-comment)
+ -Wall -Wextra -Wno-unused-parameter -Wno-comment -Wno-missing-field-initializers)
set_target_properties(${TARGETS_WM}
PROPERTIES
@@ -112,9 +110,9 @@ add_custom_command(TARGET ${TARGETS_WM} POST_BUILD
COMMAND mkdir -p ${PROJECT_BINARY_DIR}/package/root/lib
COMMAND cp -rf ${PROJECT_BINARY_DIR}/src/${TARGETS_WM}.so ${PROJECT_BINARY_DIR}/package/root/lib
COMMAND mkdir -p ${PROJECT_BINARY_DIR}/package/root/etc
- COMMAND cp -f ${PROJECT_SOURCE_DIR}/layers.json ${PROJECT_BINARY_DIR}/package/root/etc
- COMMAND cp -f ${PROJECT_SOURCE_DIR}/src/db/old_roles.db ${PROJECT_BINARY_DIR}/package/root/etc
- COMMAND cp -f ${PROJECT_SOURCE_DIR}/src/db/areas.db ${PROJECT_BINARY_DIR}/package/root/etc
+ COMMAND cp -f ${PROJECT_SOURCE_DIR}/conf/old_roles.db ${PROJECT_BINARY_DIR}/package/root/etc
+ COMMAND cp -f ${CMAKE_SOURCE_DIR}/conf/layers.json ${PROJECT_BINARY_DIR}/package/root/etc
+ COMMAND cp -f ${CMAKE_SOURCE_DIR}/conf/areas.json ${PROJECT_BINARY_DIR}/package/root/etc
)
add_custom_target(package DEPENDS ${PROJECT_BINARY_DIR}/package/root
diff --git a/src/applist.cpp b/src/applist.cpp
index f0dade0..67980f1 100644
--- a/src/applist.cpp
+++ b/src/applist.cpp
@@ -65,7 +65,7 @@ AppList::~AppList() {}
* @attention This function should be called once for the app
* Caller should take care not to be called more than once.
*/
-void AppList::addClient(const std::string &appid, unsigned layer, unsigned surface, const std::string &role)
+void AppList::addClient(const string &appid, unsigned layer, unsigned surface, const string &role)
{
std::lock_guard<std::mutex> lock(this->mtx);
shared_ptr<WMClient> client = std::make_shared<WMClient>(appid, layer, surface, role);
@@ -73,6 +73,14 @@ void AppList::addClient(const std::string &appid, unsigned layer, unsigned surfa
this->clientDump();
}
+void AppList::addClient(const string &appid, unsigned layer, const string &role)
+{
+ std::lock_guard<std::mutex> lock(this->mtx);
+ shared_ptr<WMClient> client = std::make_shared<WMClient>(appid, layer, role);
+ this->app2client[appid] = client;
+ this->clientDump();
+}
+
/**
* Remove WMClient from the list
*
@@ -132,7 +140,14 @@ void AppList::removeSurface(unsigned surface){
*/
shared_ptr<WMClient> AppList::lookUpClient(const string &appid)
{
- return this->app2client.at(appid);
+ if(this->app2client.count(appid) != 0)
+ {
+ return this->app2client.at(appid);
+ }
+ else
+ {
+ return nullptr;
+ }
}
/**
@@ -154,17 +169,16 @@ int AppList::countClient() const
* Returns AppID if found.
*
* @param unsigned[in] surfaceID
- * @param string[in] role
* @param bool[in,out] AppID is found or not
* @return AppID
* @attention If AppID is not found, param found will be false.
*/
-string AppList::getAppID(unsigned surface, const string& role, bool* found) const
+string AppList::getAppID(unsigned surface, bool* found) const
{
*found = false;
for (const auto &x : this->app2client)
{
- if(x.second->surfaceID(role) == surface){
+ if(x.second->surfaceID() == surface){
*found = true;
return x.second->appID();
}
@@ -296,6 +310,10 @@ const vector<struct WMAction> &AppList::getActions(unsigned req_num, bool* found
}
}
HMI_SEQ_ERROR(req_num, "Couldn't get action with the request : %d", req_num);
+ {
+ static vector<struct WMAction> empty;
+ return empty;
+ }
}
/**
@@ -351,7 +369,7 @@ WMError AppList::setAction(unsigned req_num, const struct WMAction &action)
* otherwise (visible is false) app should be invisible. Then enddraw_finished param is set to true.
* This function doesn't support actions for focus yet.
*/
-WMError AppList::setAction(unsigned req_num, const string &appid, const string &role, const string &area, TaskVisible visible)
+WMError AppList::setAction(unsigned req_num, shared_ptr<WMClient> client, const string &role, const string &area, TaskVisible visible)
{
std::lock_guard<std::mutex> lock(this->mtx);
WMError result = WMError::FAIL;
@@ -363,7 +381,7 @@ WMError AppList::setAction(unsigned req_num, const string &appid, const string &
}
// If visible task is not invisible, redraw is required -> true
bool edraw_f = (visible != TaskVisible::INVISIBLE) ? false : true;
- WMAction action{appid, role, area, visible, edraw_f};
+ WMAction action{req_num, client, role, area, visible, edraw_f};
x.sync_draw_req.push_back(action);
result = WMError::SUCCESS;
@@ -399,7 +417,7 @@ bool AppList::setEndDrawFinished(unsigned req_num, const string &appid, const st
{
for (auto &y : x.sync_draw_req)
{
- if (y.appid == appid && y.role == role)
+ if (y.client->appID() == appid && y.role == role)
{
HMI_SEQ_INFO(req_num, "Role %s finish redraw", y.role.c_str());
y.end_draw_finished = true;
@@ -514,7 +532,7 @@ void AppList::reqDump()
{
DUMP(
"Action : (APPID :%s, ROLE :%s, AREA :%s, VISIBLE : %s, END_DRAW_FINISHED: %d)",
- y.appid.c_str(),
+ y.client->appID().c_str(),
y.role.c_str(),
y.area.c_str(),
(y.visible == TaskVisible::INVISIBLE) ? "invisible" : "visible",
diff --git a/src/applist.hpp b/src/applist.hpp
index a794b53..085504a 100644
--- a/src/applist.hpp
+++ b/src/applist.hpp
@@ -43,20 +43,21 @@ class AppList
If the WMClient should be more flexible, I think this param should be WMClient class
*/
void addClient(const std::string &appid, unsigned layer,
- unsigned surface,const std::string &role);
+ unsigned surface, const std::string &role);
+ void addClient(const std::string &appid, unsigned layer, const std::string &role);
void removeClient(const std::string &appid);
bool contains(const std::string &appid) const;
int countClient() const;
std::shared_ptr<WMClient> lookUpClient(const std::string &appid);
void removeSurface(unsigned surface);
- std::string getAppID(unsigned surface, const std::string &role, bool *found) const;
+ std::string getAppID(unsigned surface, bool* found) const; // TODO: remove
// Request Interface
unsigned currentRequestNumber() const;
unsigned getRequestNumber(const std::string &appid) const;
unsigned addRequest(WMRequest req);
WMError setAction(unsigned req_num, const struct WMAction &action);
- WMError setAction(unsigned req_num, const std::string &appid,
+ WMError setAction(unsigned req_num, std::shared_ptr<WMClient> client,
const std::string &role, const std::string &area, TaskVisible visible);
bool setEndDrawFinished(unsigned req_num, const std::string &appid, const std::string &role);
bool endDrawFullfilled(unsigned req_num);
diff --git a/src/controller_hooks.hpp b/src/controller_hooks.hpp
deleted file mode 100644
index dd0a3aa..0000000
--- a/src/controller_hooks.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef TMCAGLWM_CONTROLLER_HOOKS_HPP
-#define TMCAGLWM_CONTROLLER_HOOKS_HPP
-
-#include <cstdint>
-
-#include <functional>
-
-namespace wm
-{
-
-class WindowManager;
-
-struct controller_hooks
-{
- WindowManager *wmgr;
-
- void surface_created(uint32_t surface_id);
- void surface_removed(uint32_t surface_id);
- void surface_visibility(uint32_t surface_id, uint32_t v);
- void surface_destination_rectangle(uint32_t surface_id, uint32_t x, uint32_t y, uint32_t w, uint32_t h);
-};
-
-} // namespace wm
-
-#endif // TMCAGLWM_CONTROLLER_HOOKS_HPP
diff --git a/src/json_helper.cpp b/src/json_helper.cpp
index cf13363..72ae36a 100644
--- a/src/json_helper.cpp
+++ b/src/json_helper.cpp
@@ -17,66 +17,6 @@
#include "json_helper.hpp"
#include "util.hpp"
-json_object *to_json(compositor::surface_properties const &s)
-{
- // auto j = json::object({
- auto j = json_object_new_object();
-
- // {"id", s.id},
- json_object_object_add(j, "id", json_object_new_int(s.id));
-
- // {"size", {{"width", s.size.w}, {"height", s.size.h}}},
- auto jsize = json_object_new_object();
- json_object_object_add(jsize, "width", json_object_new_int(s.size.w));
- json_object_object_add(jsize, "height", json_object_new_int(s.size.h));
- json_object_object_add(j, "size", jsize);
-
- // {"dst",
- // {{"width", s.dst_rect.w},
- // {"height", s.dst_rect.h},
- // {"x", s.dst_rect.x},
- // {"y", s.dst_rect.y}}},
- auto jdst = json_object_new_object();
- json_object_object_add(jdst, "width", json_object_new_int(s.dst_rect.w));
- json_object_object_add(jdst, "height", json_object_new_int(s.dst_rect.h));
- json_object_object_add(jdst, "x", json_object_new_int(s.dst_rect.x));
- json_object_object_add(jdst, "y", json_object_new_int(s.dst_rect.y));
- json_object_object_add(j, "dst", jdst);
-
- // {"src",
- // {{"width", s.src_rect.w},
- // {"height", s.src_rect.h},
- // {"x", s.src_rect.x},
- // {"y", s.src_rect.y}}},
- auto jsrc = json_object_new_object();
- json_object_object_add(jsrc, "width", json_object_new_int(s.src_rect.w));
- json_object_object_add(jsrc, "height", json_object_new_int(s.src_rect.h));
- json_object_object_add(jsrc, "x", json_object_new_int(s.src_rect.x));
- json_object_object_add(jsrc, "y", json_object_new_int(s.src_rect.y));
- json_object_object_add(j, "src", jsrc);
-
- // {"visibility", s.visibility},
- json_object_object_add(
- j, "visibility",
- json_object_new_boolean(static_cast<json_bool>(s.visibility == 1)));
-
- // {"opacity", s.opacity},
- json_object_object_add(j, "opacity", json_object_new_double(s.opacity));
-
- // {"orientation", s.orientation},
- json_object_object_add(j, "orientation", json_object_new_int(s.orientation));
-
- // });
- return j;
-}
-
-json_object *to_json(compositor::screen const *s)
-{
- auto o = json_object_new_object();
- json_object_object_add(o, "id", json_object_new_int(s->id));
- return o;
-}
-
template <typename T>
json_object *to_json_(T const &s)
{
@@ -93,11 +33,6 @@ json_object *to_json_(T const &s)
return a;
}
-json_object *to_json(compositor::controller::props_map const &s)
-{
- return to_json_(s);
-}
-
json_object *to_json(std::vector<uint32_t> const &v)
{
auto a = json_object_new_array();
diff --git a/src/json_helper.hpp b/src/json_helper.hpp
index 2321f8b..6ccbcc1 100644
--- a/src/json_helper.hpp
+++ b/src/json_helper.hpp
@@ -19,12 +19,9 @@
#include <json-c/json.h>
#include <vector>
-#include "wayland_ivi_wm.hpp"
struct json_object;
-json_object *to_json(compositor::screen const *s);
-json_object *to_json(compositor::controller::props_map const &s);
json_object *to_json(std::vector<uint32_t> const &v);
namespace jh {
diff --git a/src/layers.cpp b/src/layers.cpp
deleted file mode 100644
index b79d2f6..0000000
--- a/src/layers.cpp
+++ /dev/null
@@ -1,343 +0,0 @@
-/*
- * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
- * Copyright (c) 2018 Konsulko Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <regex>
-
-#include "layers.hpp"
-#include "json_helper.hpp"
-#include "util.hpp"
-
-namespace wm
-{
-
-using json = nlohmann::json;
-
-layer::layer(nlohmann::json const &j)
-{
- this->role = j["role"];
- this->name = j["name"];
- this->layer_id = j["layer_id"];
-
- HMI_DEBUG("layer_id:%d name:%s", this->layer_id, this->name.c_str());
-}
-
-struct result<struct layer_map> to_layer_map(nlohmann::json const &j)
-{
- try
- {
- layer_map stl{};
- auto m = j["mappings"];
-
- std::transform(std::cbegin(m), std::cend(m),
- std::inserter(stl.mapping, stl.mapping.end()),
- [](nlohmann::json const &j) {
- return std::pair<int, struct layer>(
- j.value("layer_id", -1), layer(j));
- });
-
- // TODO: add sanity checks here?
- // * check for double IDs
- // * check for double names/roles
-
- stl.layers.reserve(m.size());
- std::transform(std::cbegin(stl.mapping), std::cend(stl.mapping),
- std::back_inserter(stl.layers),
- [&stl](std::pair<int, struct layer> const &k) {
- stl.roles.emplace_back(
- std::make_pair(k.second.role, k.second.layer_id));
- return unsigned(k.second.layer_id);
- });
-
- std::sort(stl.layers.begin(), stl.layers.end());
-
- for (auto i : stl.mapping)
- {
- if (i.second.name.empty())
- {
- return Err<struct layer_map>("Found mapping w/o name");
- }
- if (i.second.layer_id == -1)
- {
- return Err<struct layer_map>("Found invalid/unset IDs in mapping");
- }
- }
-
- auto msi = j.find("main_surface");
- if (msi != j.end())
- {
- stl.main_surface_name = msi->value("surface_role", "");
- stl.main_surface = -1;
- }
-
- return Ok(stl);
- }
- catch (std::exception &e)
- {
- return Err<struct layer_map>(e.what());
- }
-}
-
-optional<int>
-layer_map::get_layer_id(int surface_id)
-{
- auto i = this->surfaces.find(surface_id);
- if (i != this->surfaces.end())
- {
- return optional<int>(i->second);
- }
- return nullopt;
-}
-
-optional<int> layer_map::get_layer_id(std::string const &role)
-{
- for (auto const &r : this->roles)
- {
- auto re = std::regex(r.first);
- if (std::regex_match(role, re))
- {
- HMI_DEBUG("role %s matches layer %d", role.c_str(), r.second);
- return optional<int>(r.second);
- }
- }
- HMI_DEBUG("role %s does NOT match any layer", role.c_str());
- return nullopt;
-}
-
-json layer::to_json() const
-{
- auto is_full = this->rect == compositor::full_rect;
-
- json r{};
- if (is_full)
- {
- r = {{"type", "full"}};
- }
- else
- {
- r = {{"type", "rect"},
- {"rect",
- {{"x", this->rect.x},
- {"y", this->rect.y},
- {"width", this->rect.w},
- {"height", this->rect.h}}}};
- }
-
- return {
- {"name", this->name},
- {"role", this->role},
- {"layer_id", this->layer_id},
- {"area", r},
- };
-}
-
-json layer_map::to_json() const
-{
- json j{};
- for (auto const &i : this->mapping)
- {
- j.push_back(i.second.to_json());
- }
- return j;
-}
-
-void layer_map::setupArea(double scaling)
-{
- compositor::rect rct;
-
- rct = this->area2size["normal.full"];
- this->area2size["normalfull"] = rct;
- this->area2size["normal"] = rct;
-
- for (auto &i : this->area2size)
- {
- i.second.x = static_cast<int>(scaling * i.second.x + 0.5);
- i.second.y = static_cast<int>(scaling * i.second.y + 0.5);
- i.second.w = static_cast<int>(scaling * i.second.w + 0.5);
- i.second.h = static_cast<int>(scaling * i.second.h + 0.5);
-
- HMI_DEBUG("area:%s size(after) : x:%d y:%d w:%d h:%d",
- i.first.c_str(), i.second.x, i.second.y, i.second.w, i.second.h);
- }
-}
-
-compositor::rect layer_map::getAreaSize(const std::string &area)
-{
- return area2size[area];
-}
-
-int layer_map::loadAreaDb()
-{
- HMI_DEBUG("Call");
-
- std::string file_name(get_file_path("areas.db"));
-
- // Load area.db
- json_object *json_obj;
- int ret = jh::inputJsonFilie(file_name.c_str(), &json_obj);
- if (0 > ret)
- {
- HMI_DEBUG("Could not open area.db, so use default area information");
- json_obj = json_tokener_parse(kDefaultAreaDb);
- }
- HMI_DEBUG("json_obj dump:%s", json_object_get_string(json_obj));
-
- // Perse areas
- HMI_DEBUG("Perse areas");
- json_object *json_cfg;
- if (!json_object_object_get_ex(json_obj, "areas", &json_cfg))
- {
- HMI_ERROR("Parse Error!!");
- return -1;
- }
-
- int len = json_object_array_length(json_cfg);
- HMI_DEBUG("json_cfg len:%d", len);
- HMI_DEBUG("json_cfg dump:%s", json_object_get_string(json_cfg));
-
- const char *area;
- for (int i = 0; i < len; i++)
- {
- json_object *json_tmp = json_object_array_get_idx(json_cfg, i);
- HMI_DEBUG("> json_tmp dump:%s", json_object_get_string(json_tmp));
-
- area = jh::getStringFromJson(json_tmp, "name");
- if (nullptr == area)
- {
- HMI_ERROR("Parse Error!!");
- return -1;
- }
- HMI_DEBUG("> area:%s", area);
-
- json_object *json_rect;
- if (!json_object_object_get_ex(json_tmp, "rect", &json_rect))
- {
- HMI_ERROR("Parse Error!!");
- return -1;
- }
- HMI_DEBUG("> json_rect dump:%s", json_object_get_string(json_rect));
-
- compositor::rect area_size;
- area_size.x = jh::getIntFromJson(json_rect, "x");
- area_size.y = jh::getIntFromJson(json_rect, "y");
- area_size.w = jh::getIntFromJson(json_rect, "w");
- area_size.h = jh::getIntFromJson(json_rect, "h");
-
- this->area2size[area] = area_size;
- }
-
- // Check
- for (auto itr = this->area2size.begin();
- itr != this->area2size.end(); ++itr)
- {
- HMI_DEBUG("area:%s x:%d y:%d w:%d h:%d",
- itr->first.c_str(), itr->second.x, itr->second.y,
- itr->second.w, itr->second.h);
- }
-
- // Release json_object
- json_object_put(json_obj);
-
- return 0;
-}
-
-const char* layer_map::kDefaultAreaDb = "{ \
- \"areas\": [ \
- { \
- \"name\": \"fullscreen\", \
- \"rect\": { \
- \"x\": 0, \
- \"y\": 0, \
- \"w\": 1080, \
- \"h\": 1920 \
- } \
- }, \
- { \
- \"name\": \"normal.full\", \
- \"rect\": { \
- \"x\": 0, \
- \"y\": 218, \
- \"w\": 1080, \
- \"h\": 1488 \
- } \
- }, \
- { \
- \"name\": \"split.main\", \
- \"rect\": { \
- \"x\": 0, \
- \"y\": 218, \
- \"w\": 1080, \
- \"h\": 744 \
- } \
- }, \
- { \
- \"name\": \"split.sub\", \
- \"rect\": { \
- \"x\": 0, \
- \"y\": 962, \
- \"w\": 1080, \
- \"h\": 744 \
- } \
- }, \
- { \
- \"name\": \"software_keyboard\", \
- \"rect\": { \
- \"x\": 0, \
- \"y\": 962, \
- \"w\": 1080, \
- \"h\": 744 \
- } \
- }, \
- { \
- \"name\": \"restriction.normal\", \
- \"rect\": { \
- \"x\": 0, \
- \"y\": 218, \
- \"w\": 1080, \
- \"h\": 1488 \
- } \
- }, \
- { \
- \"name\": \"restriction.split.main\", \
- \"rect\": { \
- \"x\": 0, \
- \"y\": 218, \
- \"w\": 1080, \
- \"h\": 744 \
- } \
- }, \
- { \
- \"name\": \"restriction.split.sub\", \
- \"rect\": { \
- \"x\": 0, \
- \"y\": 962, \
- \"w\": 1080, \
- \"h\": 744 \
- } \
- }, \
- { \
- \"name\": \"on_screen\", \
- \"rect\": { \
- \"x\": 0, \
- \"y\": 218, \
- \"w\": 1080, \
- \"h\": 1488 \
- } \
- } \
- ] \
-}";
-
-} // namespace wm
diff --git a/src/layers.hpp b/src/layers.hpp
deleted file mode 100644
index 3a16985..0000000
--- a/src/layers.hpp
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef TMCAGLWM_LAYERS_H
-#define TMCAGLWM_LAYERS_H
-
-#include <string>
-
-#include "../include/json.hpp"
-#include "layout.hpp"
-#include "result.hpp"
-#include "wayland_ivi_wm.hpp"
-
-namespace wm
-{
-
-struct layer
-{
- using json = nlohmann::json;
-
- // A more or less descriptive name?
- std::string name = "";
- // The actual layer ID
- int layer_id = -1;
- // The rectangular region surfaces are allowed to draw on
- // this layer.
- compositor::rect rect;
- // Specify a role prefix for surfaces that should be
- // put on this layer.
- std::string role;
-
- mutable struct LayoutState state;
-
- explicit layer(nlohmann::json const &j);
-
- json to_json() const;
-};
-
-struct layer_map
-{
- using json = nlohmann::json;
-
- using storage_type = std::map<int, struct layer>;
- using layers_type = std::vector<uint32_t>;
- using role_to_layer_map = std::vector<std::pair<std::string, int>>;
- using addsurf_layer_map = std::map<int, int>;
-
- storage_type mapping; // map surface_id to layer
- layers_type layers; // the actual layer IDs we have
- int main_surface;
- std::string main_surface_name;
- role_to_layer_map roles;
- addsurf_layer_map surfaces; // additional surfaces on layers
-
- optional<int> get_layer_id(int surface_id);
- optional<int> get_layer_id(std::string const &role);
- optional<struct LayoutState *> get_layout_state(int surface_id)
- {
- int layer_id = *this->get_layer_id(surface_id);
- auto i = this->mapping.find(layer_id);
- return i == this->mapping.end()
- ? nullopt
- : optional<struct LayoutState *>(&i->second.state);
- }
- optional<struct layer> get_layer(int layer_id)
- {
- auto i = this->mapping.find(layer_id);
- return i == this->mapping.end() ? nullopt
- : optional<struct layer>(i->second);
- }
-
- layers_type::size_type get_layers_count() const
- {
- return this->layers.size();
- }
-
- void add_surface(int surface_id, int layer_id)
- {
- this->surfaces[surface_id] = layer_id;
- }
-
- void remove_surface(int surface_id)
- {
- this->surfaces.erase(surface_id);
- }
-
- json to_json() const;
- void setupArea(double scaling);
- compositor::rect getAreaSize(const std::string &area);
- int loadAreaDb();
-
- private:
- std::unordered_map<std::string, compositor::rect> area2size;
-
- static const char *kDefaultAreaDb;
-};
-
-struct result<struct layer_map> to_layer_map(nlohmann::json const &j);
-
-static const nlohmann::json default_layers_json = {
- {"main_surface", {
- {"surface_role", "HomeScreen"}
- }},
- {"mappings", {
- {
- {"role", "^HomeScreen$"},
- {"name", "HomeScreen"},
- {"layer_id", 1000},
- {"area", {
- {"type", "full"}
- }}
- },
- {
- {"role", "MediaPlayer|Radio|Phone|Navigation|HVAC|Settings|Dashboard|POI|Mixer"},
- {"name", "apps"},
- {"layer_id", 1001},
- {"area", {
- {"type", "rect"},
- {"rect", {
- {"x", 0},
- {"y", 218},
- {"width", -1},
- {"height", -433}
- }}
- }}
- },
- {
- {"role", "^OnScreen.*"},
- {"name", "popups"},
- {"layer_id", 9999},
- {"area", {
- {"type", "rect"},
- {"rect", {
- {"x", 0},
- {"y", 760},
- {"width", -1},
- {"height", 400}
- }}
- }}
- }
- }}
-};
-} // namespace wm
-
-#endif // TMCAGLWM_LAYERS_H
diff --git a/src/layout.cpp b/src/layout.cpp
deleted file mode 100644
index fbf2baa..0000000
--- a/src/layout.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
- * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "layout.hpp"
diff --git a/src/layout.hpp b/src/layout.hpp
deleted file mode 100644
index 3430ef3..0000000
--- a/src/layout.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef TMCAGLWM_LAYOUT_HPP
-#define TMCAGLWM_LAYOUT_HPP
-
-namespace wm
-{
-
-struct LayoutState
-{
- int main{-1};
- int sub{-1};
-
- bool operator==(const LayoutState &b) const
- {
- return main == b.main && sub == b.sub;
- }
-
- bool operator!=(const LayoutState &b) const
- {
- return !(*this == b);
- }
-};
-
-} // namespace wm
-
-#endif // TMCAGLWM_LAYOUT_HPP
diff --git a/src/main.cpp b/src/main.cpp
index b652918..8808161 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -20,7 +20,6 @@
#include <json.h>
#include "window_manager.hpp"
#include "json_helper.hpp"
-#include "wayland_ivi_wm.hpp"
extern "C"
{
@@ -41,10 +40,10 @@ typedef struct WMClientCtxt
struct afb_instance
{
- std::unique_ptr<wl::display> display;
wm::WindowManager wmgr;
- afb_instance() : display{new wl::display}, wmgr{this->display.get()} {}
+ afb_instance() : wmgr() {}
+ ~afb_instance() = default;
int init();
};
@@ -57,78 +56,11 @@ int afb_instance::init()
return this->wmgr.init();
}
-int display_event_callback(sd_event_source *evs, int /*fd*/, uint32_t events,
- void * /*data*/)
-{
- if ((events & EPOLLHUP) != 0)
- {
- HMI_ERROR("The compositor hung up, dying now.");
- delete g_afb_instance;
- g_afb_instance = nullptr;
- goto error;
- }
-
- if ((events & EPOLLIN) != 0u)
- {
- {
- g_afb_instance->wmgr.display->read_events();
- g_afb_instance->wmgr.set_pending_events();
- }
- {
- // We want do dispatch pending wayland events from within
- // the API context
- afb_service_call("windowmanager", "ping", json_object_new_object(),
- [](void *c, int st, json_object *j) {
- },
- nullptr);
- }
- }
-
- return 0;
-
-error:
- sd_event_source_unref(evs);
- if (getenv("WINMAN_EXIT_ON_HANGUP") != nullptr)
- {
- exit(1);
- }
- return -1;
-}
-
-int _binding_init()
+static int _binding_init()
{
HMI_NOTICE("WinMan ver. %s", WINMAN_VERSION_STRING);
- if (g_afb_instance != nullptr)
- {
- HMI_ERROR("Wayland context already initialized?");
- return 0;
- }
-
- if (getenv("XDG_RUNTIME_DIR") == nullptr)
- {
- HMI_ERROR("Environment variable XDG_RUNTIME_DIR not set");
- goto error;
- }
-
- {
- // wait until wayland compositor starts up.
- int cnt = 0;
- g_afb_instance = new afb_instance;
- while (!g_afb_instance->display->ok())
- {
- cnt++;
- if (20 <= cnt)
- {
- HMI_ERROR("Could not connect to compositor");
- goto error;
- }
- HMI_ERROR("Wait to start weston ...");
- sleep(1);
- delete g_afb_instance;
- g_afb_instance = new afb_instance;
- }
- }
+ g_afb_instance = new afb_instance;
if (g_afb_instance->init() == -1)
{
@@ -136,17 +68,6 @@ int _binding_init()
goto error;
}
- {
- int ret = sd_event_add_io(afb_daemon_get_event_loop(), nullptr,
- g_afb_instance->display->get_fd(), EPOLLIN,
- display_event_callback, g_afb_instance);
- if (ret < 0)
- {
- HMI_ERROR("Could not initialize afb_instance event handler: %d", -ret);
- goto error;
- }
- }
-
atexit([] { delete g_afb_instance; });
return 0;
@@ -181,15 +102,9 @@ static void cbRemoveClientCtxt(void *data)
// Policy Manager does not know this app was killed,
// so notify it by deactivate request.
- g_afb_instance->wmgr.api_deactivate_surface(
+ g_afb_instance->wmgr.api_deactivate_window(
ctxt->name.c_str(), ctxt->role.c_str(),
- [](const char *errmsg) {
- if (errmsg != nullptr)
- {
- HMI_ERROR(errmsg);
- return;
- }
- });
+ [](const char *) {});
g_afb_instance->wmgr.removeClient(ctxt->name);
delete ctxt;
@@ -336,12 +251,12 @@ void windowmanager_activatewindow(afb_req req) noexcept
char* appid = afb_req_get_application_id(req);
if(appid)
{
- g_afb_instance->wmgr.api_activate_surface(
+ g_afb_instance->wmgr.api_activate_window(
appid, a_drawing_name, a_drawing_area,
[&req](const char *errmsg) {
if (errmsg != nullptr)
{
- HMI_ERROR("wm", errmsg);
+ HMI_ERROR(errmsg);
afb_req_fail(req, "failed", errmsg);
return;
}
@@ -379,12 +294,12 @@ void windowmanager_deactivatewindow(afb_req req) noexcept
char* appid = afb_req_get_application_id(req);
if(appid)
{
- g_afb_instance->wmgr.api_deactivate_surface(
+ g_afb_instance->wmgr.api_deactivate_window(
appid, a_drawing_name,
[&req](const char *errmsg) {
if (errmsg != nullptr)
{
- HMI_ERROR("wm", errmsg);
+ HMI_ERROR(errmsg);
afb_req_fail(req, "failed", errmsg);
return;
}
@@ -517,11 +432,10 @@ void windowmanager_wm_subscribe(afb_req req) noexcept
afb_req_fail(req, "failed", "Need char const* argument event");
return;
}
- int event_type = json_object_get_int(j);
- const char *event_name = g_afb_instance->wmgr.kListEventName[event_type];
- struct afb_event event = g_afb_instance->wmgr.map_afb_event[event_name];
- int ret = afb_req_subscribe(req, event);
- if (ret)
+ wm::WindowManager::EventType event_id = (wm::WindowManager::EventType)json_object_get_int(j);
+ bool ret = g_afb_instance->wmgr.api_subscribe(req, event_id);
+
+ if (!ret)
{
afb_req_fail(req, "failed", "Error: afb_req_subscribe()");
return;
@@ -535,132 +449,19 @@ void windowmanager_wm_subscribe(afb_req req) noexcept
}
}
-void windowmanager_list_drawing_names(afb_req req) noexcept
+void windowmanager_ping(afb_req_t req) noexcept
{
std::lock_guard<std::mutex> guard(binding_m);
- if (g_afb_instance == nullptr)
- {
- afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
- return;
- }
-
- try
- {
-
- nlohmann::json j = g_afb_instance->wmgr.id_alloc.name2id;
- auto ret = wm::Ok(json_tokener_parse(j.dump().c_str()));
- if (ret.is_err())
- {
- afb_req_fail(req, "failed", ret.unwrap_err());
- return;
- }
- afb_req_success(req, ret.unwrap(), "success");
- }
- catch (std::exception &e)
- {
- afb_req_fail_f(req, "failed", "Uncaught exception while calling list_drawing_names: %s", e.what());
- return;
- }
-}
-
-void windowmanager_ping(afb_req req) noexcept
-{
- std::lock_guard<std::mutex> guard(binding_m);
if (g_afb_instance == nullptr)
{
afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
return;
}
-
- try
+ else
{
-
- g_afb_instance->wmgr.api_ping();
-
afb_req_success(req, NULL, "success");
}
- catch (std::exception &e)
- {
- afb_req_fail_f(req, "failed", "Uncaught exception while calling ping: %s", e.what());
- return;
- }
-}
-
-void windowmanager_debug_status(afb_req req) noexcept
-{
- std::lock_guard<std::mutex> guard(binding_m);
- if (g_afb_instance == nullptr)
- {
- afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
- return;
- }
-
- try
- {
-
- json_object *jr = json_object_new_object();
- json_object_object_add(jr, "surfaces",
- to_json(g_afb_instance->wmgr.controller->sprops));
- json_object_object_add(jr, "layers", to_json(g_afb_instance->wmgr.controller->lprops));
-
- afb_req_success(req, jr, "success");
- }
- catch (std::exception &e)
- {
- afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_status: %s", e.what());
- return;
- }
-}
-
-void windowmanager_debug_layers(afb_req req) noexcept
-{
- std::lock_guard<std::mutex> guard(binding_m);
- if (g_afb_instance == nullptr)
- {
- afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
- return;
- }
-
- try
- {
- auto ret = wm::Ok(json_tokener_parse(g_afb_instance->wmgr.layers.to_json().dump().c_str()));
-
- afb_req_success(req, ret, "success");
- }
- catch (std::exception &e)
- {
- afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_layers: %s", e.what());
- return;
- }
-}
-
-void windowmanager_debug_surfaces(afb_req req) noexcept
-{
- std::lock_guard<std::mutex> guard(binding_m);
- if (g_afb_instance == nullptr)
- {
- afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
- return;
- }
-
- try
- {
-
- auto ret = wm::Ok(to_json(g_afb_instance->wmgr.controller->sprops));
- if (ret.is_err())
- {
- afb_req_fail(req, "failed", ret.unwrap_err());
- return;
- }
-
- afb_req_success(req, ret.unwrap(), "success");
- }
- catch (std::exception &e)
- {
- afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_surfaces: %s", e.what());
- return;
- }
}
void windowmanager_debug_terminate(afb_req req) noexcept
@@ -691,19 +492,15 @@ void windowmanager_debug_terminate(afb_req req) noexcept
}
const struct afb_verb_v2 windowmanager_verbs[] = {
- {"requestsurface", windowmanager_requestsurface, nullptr, nullptr, AFB_SESSION_NONE},
- {"requestsurfacexdg", windowmanager_requestsurfacexdg, nullptr, nullptr, AFB_SESSION_NONE},
- {"activatewindow", windowmanager_activatewindow, nullptr, nullptr, AFB_SESSION_NONE},
- {"deactivatewindow", windowmanager_deactivatewindow, nullptr, nullptr, AFB_SESSION_NONE},
- {"enddraw", windowmanager_enddraw, nullptr, nullptr, AFB_SESSION_NONE},
- {"getdisplayinfo", windowmanager_getdisplayinfo_thunk, nullptr, nullptr, AFB_SESSION_NONE},
- {"getareainfo", windowmanager_getareainfo_thunk, nullptr, nullptr, AFB_SESSION_NONE},
+ {"requestSurface", windowmanager_requestsurface, nullptr, nullptr, AFB_SESSION_NONE},
+ {"requestSurfaceXDG", windowmanager_requestsurfacexdg, nullptr, nullptr, AFB_SESSION_NONE},
+ {"activateWindow", windowmanager_activatewindow, nullptr, nullptr, AFB_SESSION_NONE},
+ {"deactivateWindow", windowmanager_deactivatewindow, nullptr, nullptr, AFB_SESSION_NONE},
+ {"endDraw", windowmanager_enddraw, nullptr, nullptr, AFB_SESSION_NONE},
+ {"getDisplayInfo", windowmanager_getdisplayinfo_thunk, nullptr, nullptr, AFB_SESSION_NONE},
+ {"getAreaInfo", windowmanager_getareainfo_thunk, nullptr, nullptr, AFB_SESSION_NONE},
{"wm_subscribe", windowmanager_wm_subscribe, nullptr, nullptr, AFB_SESSION_NONE},
- {"list_drawing_names", windowmanager_list_drawing_names, nullptr, nullptr, AFB_SESSION_NONE},
{"ping", windowmanager_ping, nullptr, nullptr, AFB_SESSION_NONE},
- {"debug_status", windowmanager_debug_status, nullptr, nullptr, AFB_SESSION_NONE},
- {"debug_layers", windowmanager_debug_layers, nullptr, nullptr, AFB_SESSION_NONE},
- {"debug_surfaces", windowmanager_debug_surfaces, nullptr, nullptr, AFB_SESSION_NONE},
{"debug_terminate", windowmanager_debug_terminate, nullptr, nullptr, AFB_SESSION_NONE},
{}};
diff --git a/src/pm_wrapper.cpp b/src/pm_wrapper.cpp
index d71e91f..8706128 100644
--- a/src/pm_wrapper.cpp
+++ b/src/pm_wrapper.cpp
@@ -192,7 +192,8 @@ void PMWrapper::createLayoutChangeAction(json_object *json_out, std::vector<WMAc
bool end_draw_finished = false;
WMAction act
{
- "",
+ 0,
+ nullptr,
role_name,
area_name,
TaskVisible::VISIBLE,
@@ -214,7 +215,8 @@ void PMWrapper::createLayoutChangeAction(json_object *json_out, std::vector<WMAc
bool end_draw_finished = false;
WMAction act
{
- "",
+ 0,
+ nullptr,
role_name,
area_name,
TaskVisible::VISIBLE,
@@ -238,7 +240,8 @@ void PMWrapper::createLayoutChangeAction(json_object *json_out, std::vector<WMAc
bool end_draw_finished = true;
WMAction act
{
- "",
+ 0,
+ nullptr,
i_prv.first,
"",
TaskVisible::INVISIBLE,
diff --git a/src/request.hpp b/src/request.hpp
index 6b2bda1..073dd27 100644
--- a/src/request.hpp
+++ b/src/request.hpp
@@ -19,10 +19,13 @@
#include <string>
#include <vector>
+#include <memory>
namespace wm
{
+class WMClient;
+
enum Task
{
TASK_ALLOCATE,
@@ -47,7 +50,8 @@ struct WMTrigger
struct WMAction
{
- std::string appid;
+ unsigned req_num;
+ std::shared_ptr<WMClient> client;
std::string role;
std::string area;
TaskVisible visible;
diff --git a/src/util.cpp b/src/util.cpp
index 26d0ef6..9983561 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -31,7 +31,7 @@ void rectangle::fit(unsigned long to_width, unsigned long to_height)
{
// fit rect within (to_width x to_height)
- if (to_width <= width()) {
+ if (to_width <= (unsigned long)width()) {
// scale to fit with
set_bottom(top() + (static_cast<long>(to_width) * height() / width()) - 1);
set_right(left() + to_width - 1);
diff --git a/src/util.hpp b/src/util.hpp
index d3cab08..bf2e517 100644
--- a/src/util.hpp
+++ b/src/util.hpp
@@ -37,7 +37,7 @@
#define HMI_SEQ_INFO(seq_num, args,...) _HMI_SEQ_LOG(LOG_LEVEL_INFO, __FILENAME__, __FUNCTION__, __LINE__, seq_num, args, ##__VA_ARGS__)
#define HMI_SEQ_DEBUG(seq_num, args,...) _HMI_SEQ_LOG(LOG_LEVEL_DEBUG, __FILENAME__, __FUNCTION__, __LINE__, seq_num, args, ##__VA_ARGS__)
-#define DUMP(args, ...) _DUMP(LOG_LEVEL_DEBUG, args, ##__VA_ARGS__)
+#define DUMP(args, ...) _DUMP(LOG_LEVEL_INFO, args, ##__VA_ARGS__)
enum LOG_LEVEL{
LOG_LEVEL_NONE = 0,
@@ -53,24 +53,15 @@ void _HMI_LOG(enum LOG_LEVEL level, const char* file, const char* func, const in
void _HMI_SEQ_LOG(enum LOG_LEVEL level, const char* file, const char* func, const int line, unsigned seq_num, const char* log, ...);
void _DUMP(enum LOG_LEVEL level, const char *log, ...);
-/**
- * @struct unique_fd
- */
-struct unique_fd
+struct rect
{
- int fd{-1};
- unique_fd() = default;
- explicit unique_fd(int f) : fd{f} {}
- operator int() const { return fd; }
- ~unique_fd();
- unique_fd(unique_fd const &) = delete;
- unique_fd &operator=(unique_fd const &) = delete;
- unique_fd(unique_fd &&o) : fd(o.fd) { o.fd = -1; }
- unique_fd &operator=(unique_fd &&o)
- {
- std::swap(this->fd, o.fd);
- return *this;
- }
+ int32_t w, h;
+ int32_t x, y;
+};
+
+struct size
+{
+ uint32_t w, h;
};
class rectangle
@@ -130,4 +121,4 @@ class rectangle
// Configuration file path helper
std::string get_file_path(const char *file_name, const char *log_category = "wm");
-#endif // !WM_UTIL_HPP
+#endif // WM_UTIL_HPP
diff --git a/src/wayland_ivi_wm.cpp b/src/wayland_ivi_wm.cpp
deleted file mode 100644
index bbf745b..0000000
--- a/src/wayland_ivi_wm.cpp
+++ /dev/null
@@ -1,721 +0,0 @@
-/*
- * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "wayland_ivi_wm.hpp"
-
-/**
- * namespace wl
- */
-namespace wl
-{
-
-/**
- * display
- */
-display::display()
- : d(std::unique_ptr<struct wl_display, void (*)(struct wl_display *)>(
- wl_display_connect(nullptr), &wl_display_disconnect)),
- r(d.get()) {}
-
-bool display::ok() const { return d && wl_display_get_error(d.get()) == 0; }
-
-void display::roundtrip() { wl_display_roundtrip(this->d.get()); }
-
-int display::dispatch() { return wl_display_dispatch(this->d.get()); }
-
-int display::dispatch_pending() { return wl_display_dispatch_pending(this->d.get()); }
-
-int display::read_events()
-{
- while (wl_display_prepare_read(this->d.get()) == -1)
- {
- if (wl_display_dispatch_pending(this->d.get()) == -1)
- {
- return -1;
- }
- }
-
- if (wl_display_flush(this->d.get()) == -1)
- {
- return -1;
- }
-
- if (wl_display_read_events(this->d.get()) == -1)
- {
- wl_display_cancel_read(this->d.get());
- }
-
- return 0;
-}
-
-void display::flush() { wl_display_flush(this->d.get()); }
-
-int display::get_fd() const { return wl_display_get_fd(this->d.get()); }
-
-int display::get_error() { return wl_display_get_error(this->d.get()); }
-
-/**
- * registry
- */
-namespace
-{
-void registry_global_created(void *data, struct wl_registry * /*r*/, uint32_t name,
- char const *iface, uint32_t v)
-{
- static_cast<struct registry *>(data)->global_created(name, iface, v);
-}
-
-void registry_global_removed(void *data, struct wl_registry * /*r*/,
- uint32_t name)
-{
- static_cast<struct registry *>(data)->global_removed(name);
-}
-
-constexpr struct wl_registry_listener registry_listener = {
- registry_global_created, registry_global_removed};
-} // namespace
-
-registry::registry(struct wl_display *d)
- : wayland_proxy(d == nullptr ? nullptr : wl_display_get_registry(d))
-{
- if (this->proxy != nullptr)
- {
- wl_registry_add_listener(this->proxy.get(), &registry_listener, this);
- }
-}
-
-void registry::add_global_handler(char const *iface, binder bind)
-{
- this->bindings[iface] = std::move(bind);
-}
-
-void registry::global_created(uint32_t name, char const *iface, uint32_t v)
-{
- auto b = this->bindings.find(iface);
- if (b != this->bindings.end())
- {
- b->second(this->proxy.get(), name, v);
- }
- HMI_DEBUG("wl::registry @ %p global n %u i %s v %u", this->proxy.get(), name,
- iface, v);
-}
-
-void registry::global_removed(uint32_t /*name*/) {}
-
-/**
- * output
- */
-namespace
-{
-void output_geometry(void *data, struct wl_output * /*wl_output*/, int32_t x,
- int32_t y, int32_t physical_width, int32_t physical_height,
- int32_t subpixel, const char *make, const char *model,
- int32_t transform)
-{
- static_cast<struct output *>(data)->geometry(
- x, y, physical_width, physical_height, subpixel, make, model, transform);
-}
-
-void output_mode(void *data, struct wl_output * /*wl_output*/, uint32_t flags,
- int32_t width, int32_t height, int32_t refresh)
-{
- static_cast<struct output *>(data)->mode(flags, width, height, refresh);
-}
-
-void output_done(void *data, struct wl_output * /*wl_output*/)
-{
- static_cast<struct output *>(data)->done();
-}
-
-void output_scale(void *data, struct wl_output * /*wl_output*/,
- int32_t factor)
-{
- static_cast<struct output *>(data)->scale(factor);
-}
-
-constexpr struct wl_output_listener output_listener = {
- output_geometry, output_mode, output_done, output_scale};
-} // namespace
-
-output::output(struct wl_registry *r, uint32_t name, uint32_t v)
- : wayland_proxy(wl_registry_bind(r, name, &wl_output_interface, v))
-{
- wl_output_add_listener(this->proxy.get(), &output_listener, this);
-}
-
-void output::geometry(int32_t x, int32_t y, int32_t pw, int32_t ph,
- int32_t subpel, char const *make, char const *model,
- int32_t tx)
-{
- HMI_DEBUG("wl::output %s @ %p x %i y %i w %i h %i spel %x make %s model %s tx %i",
- __func__, this->proxy.get(), x, y, pw, ph, subpel, make, model, tx);
- this->physical_width = pw;
- this->physical_height = ph;
- this->transform = tx;
-}
-
-void output::mode(uint32_t flags, int32_t w, int32_t h, int32_t r)
-{
- HMI_DEBUG("wl::output %s @ %p f %x w %i h %i r %i", __func__,
- this->proxy.get(), flags, w, h, r);
- if ((flags & WL_OUTPUT_MODE_CURRENT) != 0u)
- {
- this->width = w;
- this->height = h;
- this->refresh = r;
- }
-}
-
-void output::done()
-{
- HMI_DEBUG("wl::output %s @ %p done", __func__, this->proxy.get());
- // Pivot and flipped
- if (this->transform == WL_OUTPUT_TRANSFORM_90 ||
- this->transform == WL_OUTPUT_TRANSFORM_270 ||
- this->transform == WL_OUTPUT_TRANSFORM_FLIPPED_90 ||
- this->transform == WL_OUTPUT_TRANSFORM_FLIPPED_270)
- {
- std::swap(this->width, this->height);
- std::swap(this->physical_width, this->physical_height);
- }
-}
-
-void output::scale(int32_t factor)
-{
- HMI_DEBUG("wl::output %s @ %p f %i", __func__, this->proxy.get(), factor);
-}
-} // namespace wl
-
-/**
- * namespace compositor
- */
-namespace compositor
-{
-
-namespace
-{
-
-void surface_visibility_changed(
- void *data, struct ivi_wm * /*ivi_wm*/,
- uint32_t surface_id, int32_t visibility)
-{
- auto c = static_cast<struct controller *>(data);
- c->surface_visibility_changed(surface_id, visibility);
-}
-
-void surface_opacity_changed(void *data, struct ivi_wm * /*ivi_wm*/,
- uint32_t surface_id, wl_fixed_t opacity)
-{
- auto c = static_cast<struct controller *>(data);
- c->surface_opacity_changed(surface_id, float(wl_fixed_to_double(opacity)));
-}
-
-void surface_source_rectangle_changed(
- void *data, struct ivi_wm * /*ivi_wm*/, uint32_t surface_id,
- int32_t x, int32_t y, int32_t width, int32_t height)
-{
- auto c = static_cast<struct controller *>(data);
- c->surface_source_rectangle_changed(surface_id, x, y, width, height);
-}
-
-void surface_destination_rectangle_changed(
- void *data, struct ivi_wm * /*ivi_wm*/, uint32_t surface_id,
- int32_t x, int32_t y, int32_t width, int32_t height)
-{
- auto c = static_cast<struct controller *>(data);
- c->surface_destination_rectangle_changed(surface_id, x, y, width, height);
-}
-
-void surface_created(void *data, struct ivi_wm * /*ivi_wm*/,
- uint32_t id_surface)
-{
- static_cast<struct controller *>(data)->surface_created(id_surface);
-}
-
-void surface_destroyed(
- void *data, struct ivi_wm * /*ivi_wm*/, uint32_t surface_id)
-{
- auto c = static_cast<struct controller *>(data);
- c->surface_destroyed(surface_id);
-}
-
-void surface_error_detected(void *data, struct ivi_wm * /*ivi_wm*/, uint32_t object_id,
- uint32_t error_code, const char *error_text)
-{
- static_cast<struct controller *>(data)->surface_error_detected(
- object_id, error_code, error_text);
-}
-
-void surface_size_changed(
- void *data, struct ivi_wm * /*ivi_wm*/, uint32_t surface_id,
- int32_t width, int32_t height)
-{
- auto c = static_cast<struct controller *>(data);
- c->surface_size_changed(surface_id, width, height);
-}
-
-void surface_stats_received(void *data, struct ivi_wm * /*ivi_wm*/,
- uint32_t surface_id, uint32_t frame_count, uint32_t pid)
-{
- auto c = static_cast<struct controller *>(data);
- c->surface_stats_received(surface_id, frame_count, pid);
-}
-
-void surface_added_to_layer(void *data, struct ivi_wm * /*ivi_wm*/,
- uint32_t layer_id, uint32_t surface_id)
-{
- auto c = static_cast<struct controller *>(data);
- c->surface_added_to_layer(layer_id, surface_id);
-}
-
-void layer_visibility_changed(void *data, struct ivi_wm * /*ivi_wm*/,
- uint32_t layer_id, int32_t visibility)
-{
- auto c = static_cast<struct controller *>(data);
- c->layer_visibility_changed(layer_id, visibility);
-}
-
-void layer_opacity_changed(void *data, struct ivi_wm * /*ivi_wm*/,
- uint32_t layer_id, wl_fixed_t opacity)
-{
- auto c = static_cast<struct controller *>(data);
- c->layer_opacity_changed(layer_id, float(wl_fixed_to_double(opacity)));
-}
-
-void layer_source_rectangle_changed(
- void *data, struct ivi_wm * /*ivi_wm*/, uint32_t layer_id,
- int32_t x, int32_t y, int32_t width, int32_t height)
-{
- auto c = static_cast<struct controller *>(data);
- c->layer_source_rectangle_changed(layer_id, x, y, width, height);
-}
-
-void layer_destination_rectangle_changed(
- void *data, struct ivi_wm * /*ivi_wm*/, uint32_t layer_id,
- int32_t x, int32_t y, int32_t width, int32_t height)
-{
- auto c = static_cast<struct controller *>(data);
- c->layer_destination_rectangle_changed(layer_id, x, y, width, height);
-}
-
-void layer_created(void *data, struct ivi_wm * /*ivi_wm*/,
- uint32_t id_layer)
-{
- static_cast<struct controller *>(data)->layer_created(id_layer);
-}
-
-void layer_destroyed(void *data, struct ivi_wm * /*ivi_wm*/, uint32_t layer_id)
-{
- auto c = static_cast<struct controller *>(data);
- c->layer_destroyed(layer_id);
-}
-
-void layer_error_detected(void *data, struct ivi_wm * /*ivi_wm*/, uint32_t object_id,
- uint32_t error_code, const char *error_text)
-{
- static_cast<struct controller *>(data)->layer_error_detected(
- object_id, error_code, error_text);
-}
-
-constexpr struct ivi_wm_listener listener = {
- surface_visibility_changed,
- layer_visibility_changed,
- surface_opacity_changed,
- layer_opacity_changed,
- surface_source_rectangle_changed,
- layer_source_rectangle_changed,
- surface_destination_rectangle_changed,
- layer_destination_rectangle_changed,
- surface_created,
- layer_created,
- surface_destroyed,
- layer_destroyed,
- surface_error_detected,
- layer_error_detected,
- surface_size_changed,
- surface_stats_received,
- surface_added_to_layer,
-};
-
-void screen_created(void *data, struct ivi_wm_screen *ivi_wm_screen, uint32_t id)
-{
- static_cast<struct screen *>(data)->screen_created((struct screen *)data, id);
-}
-
-void layer_added(void *data,
- struct ivi_wm_screen *ivi_wm_screen,
- uint32_t layer_id)
-{
- HMI_DEBUG("added layer_id:%d", layer_id);
-}
-
-void connector_name(void *data,
- struct ivi_wm_screen *ivi_wm_screen,
- const char *process_name)
-{
- HMI_DEBUG("process_name:%s", process_name);
-}
-
-void screen_error(void *data,
- struct ivi_wm_screen *ivi_wm_screen,
- uint32_t error,
- const char *message)
-{
- HMI_DEBUG("screen error:%d message:%s", error, message);
-}
-
-constexpr struct ivi_wm_screen_listener screen_listener = {
- screen_created,
- layer_added,
- connector_name,
- screen_error,
-};
-} // namespace
-
-/**
- * surface
- */
-surface::surface(uint32_t i, struct controller *c)
- : controller_child(c, i)
-{
- this->parent->add_proxy_to_sid_mapping(this->parent->proxy.get(), i);
-}
-
-void surface::set_visibility(uint32_t visibility)
-{
- HMI_DEBUG("compositor::surface id:%d v:%d", this->id, visibility);
- ivi_wm_set_surface_visibility(this->parent->proxy.get(), this->id, visibility);
-}
-
-void surface::set_source_rectangle(int32_t x, int32_t y,
- int32_t width, int32_t height)
-{
- ivi_wm_set_surface_source_rectangle(this->parent->proxy.get(), this->id,
- x, y, width, height);
-}
-
-void surface::set_destination_rectangle(int32_t x, int32_t y,
- int32_t width, int32_t height)
-{
- ivi_wm_set_surface_destination_rectangle(this->parent->proxy.get(), this->id,
- x, y, width, height);
-}
-
-/**
- * layer
- */
-layer::layer(uint32_t i, struct controller *c) : layer(i, 0, 0, c) {}
-
-layer::layer(uint32_t i, int32_t w, int32_t h, struct controller *c)
- : controller_child(c, i)
-{
- this->parent->add_proxy_to_lid_mapping(this->parent->proxy.get(), i);
- ivi_wm_create_layout_layer(c->proxy.get(), i, w, h);
-}
-
-void layer::set_visibility(uint32_t visibility)
-{
- ivi_wm_set_layer_visibility(this->parent->proxy.get(), this->id, visibility);
-}
-
-void layer::set_destination_rectangle(int32_t x, int32_t y,
- int32_t width, int32_t height)
-{
- ivi_wm_set_layer_destination_rectangle(this->parent->proxy.get(), this->id,
- x, y, width, height);
-}
-
-void layer::add_surface(uint32_t surface_id)
-{
- ivi_wm_layer_add_surface(this->parent->proxy.get(), this->id, surface_id);
-}
-
-void layer::remove_surface(uint32_t surface_id)
-{
- ivi_wm_layer_remove_surface(this->parent->proxy.get(), this->id, surface_id);
-}
-
-/**
- * screen
- */
-screen::screen(uint32_t i, struct controller *c, struct wl_output *o)
- : wayland_proxy(ivi_wm_create_screen(c->proxy.get(), o)),
- controller_child(c, i)
-{
- HMI_DEBUG("compositor::screen @ %p id %u o %p", this->proxy.get(), i, o);
-
- // Add listener for screen
- ivi_wm_screen_add_listener(this->proxy.get(), &screen_listener, this);
-}
-
-void screen::clear() { ivi_wm_screen_clear(this->proxy.get()); }
-
-void screen::screen_created(struct screen *screen, uint32_t id)
-{
- HMI_DEBUG("compositor::screen @ %p screen %u (%x) @ %p", this->proxy.get(),
- id, id, screen);
- this->id = id;
- this->parent->screens[id] = screen;
-}
-
-void screen::set_render_order(std::vector<uint32_t> const &ro)
-{
- std::size_t i;
-
- // Remove all layers from the screen render order
- ivi_wm_screen_clear(this->proxy.get());
-
- for (i = 0; i < ro.size(); i++)
- {
- HMI_DEBUG("compositor::screen @ %p add layer %u", this->proxy.get(), ro[i]);
- // Add the layer to screen render order at nearest z-position
- ivi_wm_screen_add_layer(this->proxy.get(), ro[i]);
- }
-}
-
-/**
- * controller
- */
-controller::controller(struct wl_registry *r, uint32_t name, uint32_t version)
- : wayland_proxy(
- wl_registry_bind(r, name, &ivi_wm_interface, version)),
- output_size{}
-{
- ivi_wm_add_listener(this->proxy.get(), &listener, this);
-}
-
-void controller::layer_create(uint32_t id, int32_t w, int32_t h)
-{
- this->layers[id] = std::make_unique<struct layer>(id, w, h, this);
-}
-
-void controller::surface_create(uint32_t id)
-{
- this->surfaces[id] = std::make_unique<struct surface>(id, this);
-
- // TODO: If Clipping is necessary, this process should be modified.
- {
- // Set surface type:IVI_WM_SURFACE_TYPE_DESKTOP)
- // for resizing wayland surface when switching from split to full surface.
- ivi_wm_set_surface_type(this->proxy.get(), id, IVI_WM_SURFACE_TYPE_DESKTOP);
-
- // Set source reactangle even if we should not need to set it
- // for enable setting for destination region.
- this->surfaces[id]->set_source_rectangle(0, 0, this->output_size.w, this->output_size.h);
-
- // Flush display
- this->display->flush();
- }
-}
-
-void controller::create_screen(struct wl_output *output)
-{
- // TODO: screen id is 0 (WM manages one screen for now)
- this->screen = std::make_unique<struct screen>(0, this, output);
-}
-
-void controller::get_surface_properties(uint32_t surface_id, int param)
-{
- ivi_wm_surface_get(this->proxy.get(), surface_id, param);
-}
-
-void controller::layer_created(uint32_t id)
-{
- HMI_DEBUG("compositor::controller @ %p layer %u (%x)", this->proxy.get(), id, id);
- if (this->layers.find(id) != this->layers.end())
- {
- HMI_DEBUG("WindowManager has created layer %u (%x) already", id, id);
- }
- else
- {
- this->layers[id] = std::make_unique<struct layer>(id, this);
- }
-}
-
-void controller::layer_error_detected(uint32_t object_id,
- uint32_t error_code, const char *error_text)
-{
- HMI_DEBUG("compositor::controller @ %p error o %d c %d text %s",
- this->proxy.get(), object_id, error_code, error_text);
-}
-
-void controller::surface_visibility_changed(uint32_t id, int32_t visibility)
-{
- HMI_DEBUG("compositor::surface %s @ %d v %i", __func__, id,
- visibility);
- this->sprops[id].visibility = visibility;
- this->chooks->surface_visibility(id, visibility);
-}
-
-void controller::surface_opacity_changed(uint32_t id, float opacity)
-{
- HMI_DEBUG("compositor::surface %s @ %d o %f",
- __func__, id, opacity);
- this->sprops[id].opacity = opacity;
-}
-
-void controller::surface_source_rectangle_changed(uint32_t id, int32_t x,
- int32_t y, int32_t width,
- int32_t height)
-{
- HMI_DEBUG("compositor::surface %s @ %d x %i y %i w %i h %i", __func__,
- id, x, y, width, height);
- this->sprops[id].src_rect = rect{width, height, x, y};
-}
-
-void controller::surface_destination_rectangle_changed(uint32_t id, int32_t x,
- int32_t y, int32_t width,
- int32_t height)
-{
- HMI_DEBUG("compositor::surface %s @ %d x %i y %i w %i h %i", __func__,
- id, x, y, width, height);
- this->sprops[id].dst_rect = rect{width, height, x, y};
- this->chooks->surface_destination_rectangle(id, x, y, width, height);
-}
-
-void controller::surface_size_changed(uint32_t id, int32_t width,
- int32_t height)
-{
- HMI_DEBUG("compositor::surface %s @ %d w %i h %i", __func__, id,
- width, height);
- this->sprops[id].size = size{uint32_t(width), uint32_t(height)};
- this->surfaces[id]->set_source_rectangle(0, 0, width, height);
-}
-
-void controller::surface_added_to_layer(uint32_t layer_id, uint32_t surface_id)
-{
- HMI_DEBUG("compositor::surface %s @ %d l %u",
- __func__, layer_id, surface_id);
-}
-
-void controller::surface_stats_received(uint32_t surface_id,
- uint32_t frame_count, uint32_t pid)
-{
- HMI_DEBUG("compositor::surface %s @ %d f %u pid %u",
- __func__, surface_id, frame_count, pid);
-}
-
-void controller::surface_created(uint32_t id)
-{
- HMI_DEBUG("compositor::controller @ %p surface %u (%x)", this->proxy.get(), id,
- id);
- if (this->surfaces.find(id) == this->surfaces.end())
- {
- this->surfaces[id] = std::make_unique<struct surface>(id, this);
- this->chooks->surface_created(id);
-
- // Set surface type:IVI_WM_SURFACE_TYPE_DESKTOP)
- // for resizing wayland surface when switching from split to full surface.
- ivi_wm_set_surface_type(this->proxy.get(), id, IVI_WM_SURFACE_TYPE_DESKTOP);
-
- // Flush display
- this->display->flush();
- }
-}
-
-void controller::surface_destroyed(uint32_t surface_id)
-{
- HMI_DEBUG("compositor::surface %s @ %d", __func__, surface_id);
- this->chooks->surface_removed(surface_id);
- this->sprops.erase(surface_id);
- this->surfaces.erase(surface_id);
-}
-
-void controller::surface_error_detected(uint32_t object_id,
- uint32_t error_code, const char *error_text)
-{
- HMI_DEBUG("compositor::controller @ %p error o %d c %d text %s",
- this->proxy.get(), object_id, error_code, error_text);
-}
-
-void controller::layer_visibility_changed(uint32_t layer_id, int32_t visibility)
-{
- HMI_DEBUG("compositor::layer %s @ %d v %i", __func__, layer_id, visibility);
- this->lprops[layer_id].visibility = visibility;
-}
-
-void controller::layer_opacity_changed(uint32_t layer_id, float opacity)
-{
- HMI_DEBUG("compositor::layer %s @ %d o %f", __func__, layer_id, opacity);
- this->lprops[layer_id].opacity = opacity;
-}
-
-void controller::layer_source_rectangle_changed(uint32_t layer_id,
- int32_t x, int32_t y,
- int32_t width, int32_t height)
-{
- HMI_DEBUG("compositor::layer %s @ %d x %i y %i w %i h %i",
- __func__, layer_id, x, y, width, height);
- this->lprops[layer_id].src_rect = rect{width, height, x, y};
-}
-
-void controller::layer_destination_rectangle_changed(uint32_t layer_id,
- int32_t x, int32_t y,
- int32_t width, int32_t height)
-{
- HMI_DEBUG("compositor::layer %s @ %d x %i y %i w %i h %i",
- __func__, layer_id, x, y, width, height);
- this->lprops[layer_id].dst_rect = rect{width, height, x, y};
-}
-
-void controller::layer_destroyed(uint32_t layer_id)
-{
- HMI_DEBUG("compositor::layer %s @ %d", __func__, layer_id);
- this->lprops.erase(layer_id);
- this->layers.erase(layer_id);
-}
-
-void controller::add_proxy_to_sid_mapping(struct ivi_wm *p,
- uint32_t id)
-{
- HMI_DEBUG("Add surface proxy mapping for %p (%u)", p, id);
- this->surface_proxy_to_id[uintptr_t(p)] = id;
- this->sprops[id].id = id;
-}
-
-void controller::remove_proxy_to_sid_mapping(struct ivi_wm *p)
-{
- HMI_DEBUG("Remove surface proxy mapping for %p", p);
- this->surface_proxy_to_id.erase(uintptr_t(p));
-}
-
-void controller::add_proxy_to_lid_mapping(struct ivi_wm *p,
- uint32_t id)
-{
- HMI_DEBUG("Add layer proxy mapping for %p (%u)", p, id);
- this->layer_proxy_to_id[uintptr_t(p)] = id;
- this->lprops[id].id = id;
-}
-
-void controller::remove_proxy_to_lid_mapping(struct ivi_wm *p)
-{
- HMI_DEBUG("Remove layer proxy mapping for %p", p);
- this->layer_proxy_to_id.erase(uintptr_t(p));
-}
-
-void controller::add_proxy_to_id_mapping(struct wl_output *p, uint32_t id)
-{
- HMI_DEBUG("Add screen proxy mapping for %p (%u)", p, id);
- this->screen_proxy_to_id[uintptr_t(p)] = id;
-}
-
-void controller::remove_proxy_to_id_mapping(struct wl_output *p)
-{
- HMI_DEBUG("Remove screen proxy mapping for %p", p);
- this->screen_proxy_to_id.erase(uintptr_t(p));
-}
-
-} // namespace compositor
diff --git a/src/wayland_ivi_wm.hpp b/src/wayland_ivi_wm.hpp
deleted file mode 100644
index b515a06..0000000
--- a/src/wayland_ivi_wm.hpp
+++ /dev/null
@@ -1,326 +0,0 @@
-/*
- * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef WM_WAYLAND_HPP
-#define WM_WAYLAND_HPP
-
-#include "controller_hooks.hpp"
-#include "ivi-wm-client-protocol.h"
-#include "util.hpp"
-
-#include <functional>
-#include <memory>
-#include <unordered_map>
-#include <vector>
-
-/**
- * @struct wayland_proxy
- */
-template <typename ProxyT>
-struct wayland_proxy
-{
- std::unique_ptr<ProxyT, std::function<void(ProxyT *)>> proxy;
- wayland_proxy(wayland_proxy const &) = delete;
- wayland_proxy &operator=(wayland_proxy const &) = delete;
- wayland_proxy(void *p)
- : wayland_proxy(p,
- reinterpret_cast<void (*)(ProxyT *)>(wl_proxy_destroy)) {}
- wayland_proxy(void *p, std::function<void(ProxyT *)> &&p_del)
- : proxy(std::unique_ptr<ProxyT, std::function<void(ProxyT *)>>(
- static_cast<ProxyT *>(p), p_del)) {}
-};
-
-/**
- * namespace wl
- */
-namespace wl
-{
-
-/**
- * @struct registry
- */
-struct registry : public wayland_proxy<struct wl_registry>
-{
- typedef std::function<void(struct wl_registry *, uint32_t, uint32_t)> binder;
- std::unordered_map<std::string, binder> bindings;
-
- registry(registry const &) = delete;
- registry &operator=(registry const &) = delete;
- registry(struct wl_display *d);
-
- void add_global_handler(char const *iface, binder bind);
-
- // Events
- void global_created(uint32_t name, char const *iface, uint32_t v);
- void global_removed(uint32_t name);
-};
-
-/**
- * @struct display
- */
-struct display
-{
- std::unique_ptr<struct wl_display, void (*)(struct wl_display *)> d;
- struct registry r;
-
- display(display const &) = delete;
- display &operator=(display const &) = delete;
- display();
- bool ok() const;
- void roundtrip();
- int dispatch();
- int dispatch_pending();
- int read_events();
- void flush();
- int get_fd() const;
- int get_error();
-
- // Lets just proxy this for the registry
- inline void add_global_handler(char const *iface, registry::binder bind)
- {
- this->r.add_global_handler(iface, bind);
- }
-};
-
-/**
- * @struct output
- */
-struct output : public wayland_proxy<struct wl_output>
-{
- int width{};
- int height{};
- int physical_width{};
- int physical_height{};
- int refresh{};
- int transform{};
-
- output(output const &) = delete;
- output &operator=(output const &) = delete;
- output(struct wl_registry *r, uint32_t name, uint32_t v);
-
- // Events
- void geometry(int32_t x, int32_t y, int32_t pw, int32_t ph, int32_t subpel,
- char const *make, char const *model, int32_t tx);
- void mode(uint32_t flags, int32_t w, int32_t h, int32_t r);
- void done();
- void scale(int32_t factor);
-};
-} // namespace wl
-
-/**
- * namespace compositor
- */
-namespace compositor
-{
-
-struct size
-{
- uint32_t w, h;
-};
-
-struct rect
-{
- int32_t w, h;
- int32_t x, y;
-};
-
-static const constexpr rect full_rect = rect{-1, -1, 0, 0};
-
-inline bool operator==(struct rect a, struct rect b)
-{
- return a.w == b.w && a.h == b.h && a.x == b.x && a.y == b.y;
-}
-
-struct controller;
-
-struct controller_child
-{
- struct controller *parent;
- uint32_t id;
-
- controller_child(controller_child const &) = delete;
- controller_child &operator=(controller_child const &) = delete;
- controller_child(struct controller *c, uint32_t i) : parent(c), id(i) {}
- virtual ~controller_child() {}
-};
-
-struct surface_properties
-{
- uint32_t id; // let's just save an ID here too
- struct rect dst_rect;
- struct rect src_rect;
- struct size size;
- int32_t orientation;
- int32_t visibility;
- float opacity;
-};
-
-/**
- * @struct surface
- */
-struct surface : public controller_child
-{
- surface(surface const &) = delete;
- surface &operator=(surface const &) = delete;
- surface(uint32_t i, struct controller *c);
-
- // Requests
- void set_visibility(uint32_t visibility);
- void set_source_rectangle(int32_t x, int32_t y,
- int32_t width, int32_t height);
- void set_destination_rectangle(int32_t x, int32_t y,
- int32_t width, int32_t height);
-};
-
-/**
- * @struct layer
- */
-struct layer : public controller_child
-{
- layer(layer const &) = delete;
- layer &operator=(layer const &) = delete;
- layer(uint32_t i, struct controller *c);
- layer(uint32_t i, int32_t w, int32_t h, struct controller *c);
-
- // Requests
- void set_visibility(uint32_t visibility);
- void set_destination_rectangle(int32_t x, int32_t y,
- int32_t width, int32_t height);
- void add_surface(uint32_t surface_id);
- void remove_surface(uint32_t surface_id);
-};
-
-/**
- * @struct screen
- */
-struct screen : public wayland_proxy<struct ivi_wm_screen>,
- public controller_child
-{
- screen(screen const &) = delete;
- screen &operator=(screen const &) = delete;
- screen(uint32_t i, struct controller *c, struct wl_output *o);
-
- void clear();
- void screen_created(struct screen *screen, uint32_t id);
- void set_render_order(std::vector<uint32_t> const &ro);
-};
-
-/**
- * @struct controller
- */
-struct controller : public wayland_proxy<struct ivi_wm>
-{
- // This controller is still missing ivi-input
-
- typedef std::unordered_map<uintptr_t, uint32_t> proxy_to_id_map_type;
- typedef std::unordered_map<uint32_t, std::unique_ptr<struct surface>>
- surface_map_type;
- typedef std::unordered_map<uint32_t, std::unique_ptr<struct layer>>
- layer_map_type;
- typedef std::unordered_map<uint32_t, struct screen *> screen_map_type;
- typedef std::unordered_map<uint32_t, struct surface_properties> props_map;
-
- // HACK:
- // The order of these member is mandatory, as when objects are destroyed
- // they will call their parent (that's us right here!) and remove their
- // proxy-to-id mapping. I.e. the *_proxy_to_id members need to be valid
- // when the surfaces/layers/screens maps are destroyed. This sucks, but
- // I cannot see a better solution w/o globals or some other horrible
- // call-our-parent construct.
- proxy_to_id_map_type surface_proxy_to_id;
- proxy_to_id_map_type layer_proxy_to_id;
- proxy_to_id_map_type screen_proxy_to_id;
-
- props_map sprops;
- props_map lprops;
-
- surface_map_type surfaces;
- layer_map_type layers;
- screen_map_type screens;
-
- std::unique_ptr<struct screen> screen;
-
- size output_size; // Display size[pixel]
- size physical_size; // Display size[mm]
-
- // Scale for conversion CSS PX -> DP(Device Pixel)
- double scale;
-
- wm::controller_hooks *chooks;
-
- struct wl::display *display;
-
- void add_proxy_to_sid_mapping(struct ivi_wm *p, uint32_t id);
- void remove_proxy_to_sid_mapping(struct ivi_wm *p);
-
- void add_proxy_to_lid_mapping(struct ivi_wm *p, uint32_t id);
- void remove_proxy_to_lid_mapping(struct ivi_wm *p);
-
- void add_proxy_to_id_mapping(struct wl_output *p, uint32_t id);
- void remove_proxy_to_id_mapping(struct wl_output *p);
-
- bool surface_exists(uint32_t id) const
- {
- return this->surfaces.find(id) != this->surfaces.end();
- }
-
- bool layer_exists(uint32_t id) const
- {
- return this->layers.find(id) != this->layers.end();
- }
-
- controller(struct wl_registry *r, uint32_t name, uint32_t version);
-
- // Requests
- void commit_changes() const
- {
- ivi_wm_commit_changes(this->proxy.get());
- }
- void layer_create(uint32_t id, int32_t w, int32_t h);
- void surface_create(uint32_t id);
- void create_screen(struct wl_output *output);
- void get_surface_properties(uint32_t surface_id, int param = 0);
-
- // Events
- void surface_visibility_changed(uint32_t id, int32_t visibility);
- void surface_opacity_changed(uint32_t id, float opacity);
- void surface_source_rectangle_changed(uint32_t id, int32_t x, int32_t y,
- int32_t width, int32_t height);
- void surface_destination_rectangle_changed(uint32_t id, int32_t x, int32_t y,
- int32_t width, int32_t height);
- void surface_created(uint32_t id);
- void surface_destroyed(uint32_t surface_id);
- void surface_error_detected(uint32_t object_id,
- uint32_t error_code, char const *error_text);
- void surface_size_changed(uint32_t id, int32_t width, int32_t height);
- void surface_stats_received(uint32_t surface_id,
- uint32_t frame_count, uint32_t pid);
- void surface_added_to_layer(uint32_t layer_id, uint32_t surface_id);
-
- void layer_visibility_changed(uint32_t layer_id, int32_t visibility);
- void layer_opacity_changed(uint32_t layer_id, float opacity);
- void layer_source_rectangle_changed(uint32_t layer_id, int32_t x, int32_t y,
- int32_t width, int32_t height);
- void layer_destination_rectangle_changed(uint32_t layer_id, int32_t x, int32_t y,
- int32_t width, int32_t height);
- void layer_created(uint32_t id);
- void layer_destroyed(uint32_t layer_id);
- void layer_error_detected(uint32_t object_id,
- uint32_t error_code, char const *error_text);
-};
-} // namespace compositor
-
-#endif // !WM_WAYLAND_HPP
diff --git a/src/window_manager.cpp b/src/window_manager.cpp
index c70e820..965c60d 100644
--- a/src/window_manager.cpp
+++ b/src/window_manager.cpp
@@ -20,7 +20,6 @@
#include "window_manager.hpp"
#include "json_helper.hpp"
-#include "util.hpp"
#include "applist.hpp"
extern "C"
@@ -28,6 +27,10 @@ extern "C"
#include <systemd/sd-event.h>
}
+using std::string;
+using std::vector;
+using std::unordered_map;
+
namespace wm
{
@@ -55,6 +58,16 @@ const char kKeyHeightMm[] = "height_mm";
const char kKeyScale[] = "scale";
const char kKeyIds[] = "ids";
+static const vector<string> kListEventName{
+ "active",
+ "inactive",
+ "visible",
+ "invisible",
+ "syncDraw",
+ "flushDraw",
+ "screenUpdated",
+ "error"};
+
static sd_event_source *g_timer_ev_src = nullptr;
static AppList g_app_list;
static WindowManager *g_context;
@@ -62,39 +75,6 @@ static WindowManager *g_context;
namespace
{
-using nlohmann::json;
-
-result<json> file_to_json(char const *filename)
-{
- json j;
- std::ifstream i(filename);
- if (i.fail())
- {
- HMI_DEBUG("Could not open config file, so use default layer information");
- j = default_layers_json;
- }
- else
- {
- i >> j;
- }
-
- return Ok(j);
-}
-
-struct result<layer_map> load_layer_map(char const *filename)
-{
- HMI_DEBUG("loading IDs from %s", filename);
-
- auto j = file_to_json(filename);
- if (j.is_err())
- {
- return Err<layer_map>(j.unwrap_err());
- }
- json jids = j.unwrap();
-
- return to_layer_map(jids);
-}
-
static int processTimerHandler(sd_event_source *s, uint64_t usec, void *userdata)
{
HMI_NOTICE("Time out occurs because the client replys endDraw slow, so revert the request");
@@ -102,7 +82,7 @@ static int processTimerHandler(sd_event_source *s, uint64_t usec, void *userdata
return 0;
}
-static void onStateTransitioned(std::vector<WMAction> actions)
+static void onStateTransitioned(vector<WMAction> actions)
{
g_context->startTransitionWrapper(actions);
}
@@ -116,47 +96,33 @@ static void onError()
/**
* WindowManager Impl
*/
-WindowManager::WindowManager(wl::display *d)
- : chooks{this},
- display{d},
- controller{},
- outputs(),
- layers(),
- id_alloc{},
- pending_events(false)
+WindowManager::WindowManager()
+ : id_alloc{}
{
- std::string path(get_file_path("layers.json"));
-
- try
+ const char *path = getenv("AFM_APP_INSTALL_DIR");
+ if (!path)
{
- {
- auto l = load_layer_map(path.c_str());
- if (l.is_ok())
- {
- this->layers = l.unwrap();
- }
- else
- {
- HMI_ERROR("%s", l.err().value());
- }
- }
- }
- catch (std::exception &e)
- {
- HMI_ERROR("Loading of configuration failed: %s", e.what());
+ HMI_ERROR("AFM_APP_INSTALL_DIR is not defined");
}
+ string root = path;
+
+ this->lc = std::make_shared<LayerControl>(root);
+
+ HMI_DEBUG("Layer Controller initialized");
}
int WindowManager::init()
{
- if (!this->display->ok())
- {
- return -1;
- }
+ LayerControlCallbacks lmcb;
+ lmcb.surfaceCreated = [&](unsigned pid, unsigned surface){
+ this->surface_created(surface);
+ };
+ lmcb.surfaceDestroyed = [&](unsigned surface){
+ this->surface_removed(surface);
+ };
- if (this->layers.mapping.empty())
+ if(this->lc->init(lmcb) != WMError::SUCCESS)
{
- HMI_ERROR("No surface -> layer mapping loaded");
return -1;
}
@@ -174,107 +140,66 @@ int WindowManager::init()
// Register callback to PolicyManager
this->pmw.registerCallback(onStateTransitioned, onError);
- // Make afb event
- for (int i = Event_Val_Min; i <= Event_Val_Max; i++)
+ // Make afb event for subscriber
+ for (int i = Event_ScreenUpdated; i < Event_Error; i++)
{
- map_afb_event[kListEventName[i]] = afb_daemon_make_event(kListEventName[i]);
+ map_afb_event[kListEventName[i]] = afb_daemon_make_event(kListEventName[i].c_str());
}
- this->display->add_global_handler(
- "wl_output", [this](wl_registry *r, uint32_t name, uint32_t v) {
- this->outputs.emplace_back(std::make_unique<wl::output>(r, name, v));
- });
-
- this->display->add_global_handler(
- "ivi_wm", [this](wl_registry *r, uint32_t name, uint32_t v) {
- this->controller =
- std::make_unique<struct compositor::controller>(r, name, v);
-
- // Init controller hooks
- this->controller->chooks = &this->chooks;
-
- // This protocol needs the output, so lets just add our mapping here...
- if(!this->outputs.empty()) {
- // FIXME : Work around to avoid signal 11. Window Manager can't handle hotplug.
- this->controller->add_proxy_to_id_mapping(
- this->outputs.front()->proxy.get(),
- wl_proxy_get_id(reinterpret_cast<struct wl_proxy *>(
- this->outputs.front()->proxy.get())));
-
- // Create screen
- this->controller->create_screen(this->outputs.front()->proxy.get());
- }
- else {
- HMI_WARNING("wm", "No output object. Window Manager can't handle screen");
- }
-
- // Set display to controller
- this->controller->display = this->display;
- });
+ const struct rect css_bg = this->lc->getAreaSize("fullscreen");
+ Screen screen = this->lc->getScreenInfo();
+ rectangle dp_bg(screen.width(), screen.height());
- // First level objects
- this->display->roundtrip();
- // Second level objects
- this->display->roundtrip();
- // Third level objects
- this->display->roundtrip();
-
- return init_layers();
-}
+ dp_bg.set_aspect(static_cast<double>(css_bg.w) / css_bg.h);
+ dp_bg.fit(screen.width(), screen.height());
+ dp_bg.center(screen.width(), screen.height());
+ HMI_DEBUG("SCALING: CSS BG(%dx%d) -> DDP %dx%d,(%dx%d)",
+ css_bg.w, css_bg.h, dp_bg.left(), dp_bg.top(), dp_bg.width(), dp_bg.height());
-int WindowManager::dispatch_pending_events()
-{
- if (this->pop_pending_events())
- {
- this->display->dispatch_pending();
- return 0;
- }
- return -1;
-}
+ double scale = static_cast<double>(dp_bg.height()) / css_bg.h;
+ this->lc->setupArea(dp_bg, scale);
-void WindowManager::set_pending_events()
-{
- this->pending_events.store(true, std::memory_order_release);
+ return 0;
}
result<int> WindowManager::api_request_surface(char const *appid, char const *drawing_name)
{
// TODO: application requests by old role,
// so convert role old to new
- const char *role = this->convertRoleOldToNew(drawing_name);
+ const char *new_role = this->convertRoleOldToNew(drawing_name);
- auto lid = this->layers.get_layer_id(std::string(role));
- if (!lid)
+ string str_id = appid;
+ string role = new_role;
+ unsigned lid = 0;
+
+ if(!g_app_list.contains(str_id))
{
- /**
- * register drawing_name as fallback and make it displayed.
- */
- lid = this->layers.get_layer_id(std::string("fallback"));
- HMI_DEBUG("%s is not registered in layers.json, then fallback as normal app", role);
- if (!lid)
+ lid = this->lc->getNewLayerID(role);
+ if (lid == 0)
{
- return Err<int>("Drawing name does not match any role, fallback is disabled");
+ // register drawing_name as fallback and make it displayed.
+ lid = this->lc->getNewLayerID(string("fallback"));
+ HMI_DEBUG("%s is not registered in layers.json, then fallback as normal app", role.c_str());
+ if (lid == 0)
+ {
+ return Err<int>("Designated role does not match any role, fallback is disabled");
+ }
}
+ this->lc->createNewLayer(lid);
+ // add client into the db
+ g_app_list.addClient(str_id, lid, drawing_name);
}
- auto rname = this->lookup_id(role);
+ // generate surface ID for ivi-shell application
+ auto rname = this->id_alloc.lookup(role);
if (!rname)
{
// name does not exist yet, allocate surface id...
auto id = int(this->id_alloc.generate_id(role));
- this->layers.add_surface(id, *lid);
+ this->tmp_surface2app[id] = {str_id, lid};
- // set the main_surface[_name] here and now
- if (!this->layers.main_surface_name.empty() &&
- this->layers.main_surface_name == drawing_name)
- {
- this->layers.main_surface = id;
- HMI_DEBUG("Set main_surface id to %u", id);
- }
-
- // add client into the db
- std::string appid_str(appid);
- g_app_list.addClient(appid_str, *lid, id, std::string(role));
+ auto client = g_app_list.lookUpClient(str_id);
+ client->registerSurface(id);
// Set role map of (new, old)
this->rolenew2old[role] = std::string(drawing_name);
@@ -291,25 +216,45 @@ char const *WindowManager::api_request_surface(char const *appid, char const *dr
{
// TODO: application requests by old role,
// so convert role old to new
- const char *role = this->convertRoleOldToNew(drawing_name);
+ const char *new_role = this->convertRoleOldToNew(drawing_name);
+
+ string str_id = appid;
+ string role = new_role;
- auto lid = this->layers.get_layer_id(std::string(role));
unsigned sid = std::stol(ivi_id);
+ HMI_DEBUG("This API(requestSurfaceXDG) is for XDG Application using runXDG");
+ /*
+ * IVI-shell doesn't send surface_size event via ivi-wm protocol
+ * if the application is using XDG surface.
+ * So WM has to set surface size with original size here
+ */
+ WMError ret = this->lc->setXDGSurfaceOriginSize(sid);
+ if(ret != SUCCESS)
+ {
+ HMI_ERROR("%s", errorDescription(ret));
+ HMI_WARNING("The main user of this API is runXDG");
+ return "fail";
+ }
- if (!lid)
+ if(!g_app_list.contains(str_id))
{
- /**
- * register drawing_name as fallback and make it displayed.
- */
- lid = this->layers.get_layer_id(std::string("fallback"));
- HMI_DEBUG("%s is not registered in layers.json, then fallback as normal app", role);
- if (!lid)
+ unsigned l_id = this->lc->getNewLayerID(role);
+ if (l_id == 0)
{
- return "Drawing name does not match any role, fallback is disabled";
+ // register drawing_name as fallback and make it displayed.
+ l_id = this->lc->getNewLayerID("fallback");
+ HMI_DEBUG("%s is not registered in layers.json, then fallback as normal app", role.c_str());
+ if (l_id == 0)
+ {
+ return "Designated role does not match any role, fallback is disabled";
+ }
}
+ this->lc->createNewLayer(l_id);
+ // add client into the db
+ g_app_list.addClient(str_id, l_id, drawing_name);
}
- auto rname = this->lookup_id(role);
+ auto rname = this->id_alloc.lookup(role);
if (rname)
{
@@ -318,17 +263,9 @@ char const *WindowManager::api_request_surface(char const *appid, char const *dr
// register pair drawing_name and ivi_id
this->id_alloc.register_name_id(role, sid);
- this->layers.add_surface(sid, *lid);
-
- // this surface is already created
- HMI_DEBUG("surface_id is %u, layer_id is %u", sid, *lid);
-
- this->controller->layers[*lid]->add_surface(sid);
- this->layout_commit();
- // add client into the db
- std::string appid_str(appid);
- g_app_list.addClient(appid_str, *lid, sid, std::string(role));
+ auto client = g_app_list.lookUpClient(str_id);
+ client->addSurface(sid);
// Set role map of (new, old)
this->rolenew2old[role] = std::string(drawing_name);
@@ -336,16 +273,24 @@ char const *WindowManager::api_request_surface(char const *appid, char const *dr
return nullptr;
}
-void WindowManager::api_activate_surface(char const *appid, char const *drawing_name,
+void WindowManager::api_activate_window(char const *appid, char const *drawing_name,
char const *drawing_area, const reply_func &reply)
{
// TODO: application requests by old role,
// so convert role old to new
const char *c_role = this->convertRoleOldToNew(drawing_name);
- std::string id = appid;
- std::string role = c_role;
- std::string area = drawing_area;
+ string id = appid;
+ string role = c_role;
+ string area = drawing_area;
+
+ if(!g_app_list.contains(id))
+ {
+ reply("app doesn't request 'requestSurface' or 'setRole' yet");
+ return;
+ }
+ auto client = g_app_list.lookUpClient(id);
+
Task task = Task::TASK_ALLOCATE;
unsigned req_num = 0;
WMError ret = WMError::UNKNOWN;
@@ -367,10 +312,8 @@ void WindowManager::api_activate_surface(char const *appid, char const *drawing_
return;
}
- /*
- * Do allocate tasks
- */
- ret = this->doTransition(req_num);
+ // Do allocate tasks
+ ret = this->checkPolicy(req_num);
if (ret != WMError::SUCCESS)
{
@@ -381,19 +324,16 @@ void WindowManager::api_activate_surface(char const *appid, char const *drawing_
}
}
-void WindowManager::api_deactivate_surface(char const *appid, char const *drawing_name,
+void WindowManager::api_deactivate_window(char const *appid, char const *drawing_name,
const reply_func &reply)
{
// TODO: application requests by old role,
// so convert role old to new
const char *c_role = this->convertRoleOldToNew(drawing_name);
-
- /*
- * Check Phase
- */
- std::string id = appid;
- std::string role = c_role;
- std::string area = ""; //drawing_area;
+ // Check Phase
+ string id = appid;
+ string role = c_role;
+ string area = ""; //drawing_area;
Task task = Task::TASK_RELEASE;
unsigned req_num = 0;
WMError ret = WMError::UNKNOWN;
@@ -415,10 +355,8 @@ void WindowManager::api_deactivate_surface(char const *appid, char const *drawin
return;
}
- /*
- * Do allocate tasks
- */
- ret = this->doTransition(req_num);
+ // Do allocate tasks
+ ret = this->checkPolicy(req_num);
if (ret != WMError::SUCCESS)
{
@@ -435,8 +373,8 @@ void WindowManager::api_enddraw(char const *appid, char const *drawing_name)
// so convert role old to new
const char *c_role = this->convertRoleOldToNew(drawing_name);
- std::string id = appid;
- std::string role = c_role;
+ string id = appid;
+ string role = c_role;
unsigned current_req = g_app_list.currentRequestNumber();
bool result = g_app_list.setEndDrawFinished(current_req, id, role);
@@ -458,6 +396,7 @@ void WindowManager::api_enddraw(char const *appid, char const *drawing_name)
// Undo state of PolicyManager
this->pmw.undoState();
+ this->lc->undoUpdate();
}
this->emitScreenUpdated(current_req);
HMI_SEQ_INFO(current_req, "Finish request status: %s", errorDescription(ret));
@@ -473,23 +412,50 @@ void WindowManager::api_enddraw(char const *appid, char const *drawing_name)
}
}
-result<json_object *> WindowManager::api_get_display_info()
+bool WindowManager::api_subscribe(afb_req_t req, EventType event_id)
{
- if (!this->display->ok())
+ bool ret = false;
+ char* appid = afb_req_get_application_id(req);
+ if(event_id < Event_Val_Min || event_id > Event_Val_Max)
{
- return Err<json_object *>("Wayland compositor is not available");
+ HMI_ERROR("not defined in Window Manager", event_id);
+ return ret;
}
+ HMI_INFO("%s subscribe %s : %d", appid, kListEventName[event_id].c_str(), event_id);
+ if(event_id == Event_ScreenUpdated)
+ {
+ // Event_ScreenUpdated should be emitted to subscriber
+ afb_event_t event = this->map_afb_event[kListEventName[event_id]];
+ int rc = afb_req_subscribe(req, event);
+ if(rc == 0)
+ {
+ ret = true;
+ }
+ }
+ else if(appid)
+ {
+ string id = appid;
+ free(appid);
+ auto client = g_app_list.lookUpClient(id);
+ if(client != nullptr)
+ {
+ ret = client->subscribe(req, kListEventName[event_id]);
+ }
+ }
+ return ret;
+}
- // Set display info
- compositor::size o_size = this->controller->output_size;
- compositor::size p_size = this->controller->physical_size;
+result<json_object *> WindowManager::api_get_display_info()
+{
+ Screen screen = this->lc->getScreenInfo();
json_object *object = json_object_new_object();
- json_object_object_add(object, kKeyWidthPixel, json_object_new_int(o_size.w));
- json_object_object_add(object, kKeyHeightPixel, json_object_new_int(o_size.h));
- json_object_object_add(object, kKeyWidthMm, json_object_new_int(p_size.w));
- json_object_object_add(object, kKeyHeightMm, json_object_new_int(p_size.h));
- json_object_object_add(object, kKeyScale, json_object_new_double(this->controller->scale));
+ json_object_object_add(object, kKeyWidthPixel, json_object_new_int(screen.width()));
+ json_object_object_add(object, kKeyHeightPixel, json_object_new_int(screen.height()));
+ // TODO: set size
+ json_object_object_add(object, kKeyWidthMm, json_object_new_int(0));
+ json_object_object_add(object, kKeyHeightMm, json_object_new_int(0));
+ json_object_object_add(object, kKeyScale, json_object_new_double(this->lc->scale()));
return Ok<json_object *>(object);
}
@@ -500,28 +466,18 @@ result<json_object *> WindowManager::api_get_area_info(char const *drawing_name)
// TODO: application requests by old role,
// so convert role old to new
- const char *role = this->convertRoleOldToNew(drawing_name);
+ const char *c_role = this->convertRoleOldToNew(drawing_name);
+ string role = c_role;
// Check drawing name, surface/layer id
- auto const &surface_id = this->lookup_id(role);
+ auto const &surface_id = this->id_alloc.lookup(role);
if (!surface_id)
{
return Err<json_object *>("Surface does not exist");
}
- if (!this->controller->surface_exists(*surface_id))
- {
- return Err<json_object *>("Surface does not exist in controller!");
- }
-
- auto layer_id = this->layers.get_layer_id(*surface_id);
- if (!layer_id)
- {
- return Err<json_object *>("Surface is not on any layer!");
- }
-
// Set area rectangle
- compositor::rect area_info = this->area_info[*surface_id];
+ struct rect area_info = this->area_info[*surface_id];
json_object *object = json_object_new_object();
json_object_object_add(object, kKeyX, json_object_new_int(area_info.x));
json_object_object_add(object, kKeyY, json_object_new_int(area_info.y));
@@ -531,78 +487,41 @@ result<json_object *> WindowManager::api_get_area_info(char const *drawing_name)
return Ok<json_object *>(object);
}
-void WindowManager::api_ping() { this->dispatch_pending_events(); }
-
-void WindowManager::send_event(char const *evname, char const *label)
-{
- HMI_DEBUG("%s: %s(%s)", __func__, evname, label);
-
- json_object *j = json_object_new_object();
- json_object_object_add(j, kKeyDrawingName, json_object_new_string(label));
-
- int ret = afb_event_push(this->map_afb_event[evname], j);
- if (ret != 0)
- {
- HMI_DEBUG("afb_event_push failed: %m");
- }
-}
-
-void WindowManager::send_event(char const *evname, char const *label, char const *area,
- int x, int y, int w, int h)
-{
- HMI_DEBUG("%s: %s(%s, %s) x:%d y:%d w:%d h:%d",
- __func__, evname, label, area, x, y, w, h);
-
- json_object *j_rect = json_object_new_object();
- json_object_object_add(j_rect, kKeyX, json_object_new_int(x));
- json_object_object_add(j_rect, kKeyY, json_object_new_int(y));
- json_object_object_add(j_rect, kKeyWidth, json_object_new_int(w));
- json_object_object_add(j_rect, kKeyHeight, json_object_new_int(h));
-
- json_object *j = json_object_new_object();
- json_object_object_add(j, kKeyDrawingName, json_object_new_string(label));
- json_object_object_add(j, kKeyDrawingArea, json_object_new_string(area));
- json_object_object_add(j, kKeyDrawingRect, j_rect);
-
- int ret = afb_event_push(this->map_afb_event[evname], j);
- if (ret != 0)
- {
- HMI_DEBUG("afb_event_push failed: %m");
- }
-}
-
/**
* proxied events
*/
-void WindowManager::surface_created(uint32_t surface_id)
+void WindowManager::surface_created(unsigned surface_id)
{
- this->controller->get_surface_properties(surface_id, IVI_WM_PARAM_SIZE);
-
- auto layer_id = this->layers.get_layer_id(surface_id);
- if (!layer_id)
+ // requestSurface
+ if(this->tmp_surface2app.count(surface_id) != 0)
{
- HMI_DEBUG("Newly created surfce %d is not associated with any layer!",
- surface_id);
- return;
+ string appid = this->tmp_surface2app[surface_id].appid;
+ auto client = g_app_list.lookUpClient(appid);
+ if(client != nullptr)
+ {
+ WMError ret = client->addSurface(surface_id);
+ HMI_INFO("Add surface %d to \"%s\"", surface_id, appid.c_str());
+ if(ret != WMError::SUCCESS)
+ {
+ HMI_ERROR("Failed to add surface to client %s", client->appID().c_str());
+ }
+ }
+ this->tmp_surface2app.erase(surface_id);
}
-
- HMI_DEBUG("surface_id is %u, layer_id is %u", surface_id, *layer_id);
-
- this->controller->layers[*layer_id]->add_surface(surface_id);
- this->layout_commit();
}
-void WindowManager::surface_removed(uint32_t surface_id)
+void WindowManager::surface_removed(unsigned surface_id)
{
HMI_DEBUG("Delete surface_id %u", surface_id);
this->id_alloc.remove_id(surface_id);
- this->layers.remove_surface(surface_id);
g_app_list.removeSurface(surface_id);
}
-void WindowManager::removeClient(const std::string &appid)
+void WindowManager::removeClient(const string &appid)
{
HMI_DEBUG("Remove clinet %s from list", appid.c_str());
+ auto client = g_app_list.lookUpClient(appid);
+ this->lc->appTerminated(client);
g_app_list.removeClient(appid);
}
@@ -624,7 +543,7 @@ void WindowManager::timerHandler()
this->processNextRequest();
}
-void WindowManager::startTransitionWrapper(std::vector<WMAction> &actions)
+void WindowManager::startTransitionWrapper(vector<WMAction> &actions)
{
WMError ret;
unsigned req_num = g_app_list.currentRequestNumber();
@@ -648,12 +567,12 @@ void WindowManager::startTransitionWrapper(std::vector<WMAction> &actions)
if ("" != act.role)
{
bool found;
- auto const &surface_id = this->lookup_id(act.role.c_str());
+ auto const &surface_id = this->id_alloc.lookup(act.role);
if(surface_id == nullopt)
{
goto proc_remove_request;
}
- std::string appid = g_app_list.getAppID(*surface_id, act.role, &found);
+ string appid = g_app_list.getAppID(*surface_id, &found);
if (!found)
{
if (TaskVisible::INVISIBLE == act.visible)
@@ -668,7 +587,9 @@ void WindowManager::startTransitionWrapper(std::vector<WMAction> &actions)
goto error;
}
}
- act.appid = appid;
+ auto client = g_app_list.lookUpClient(appid);
+ act.req_num = req_num;
+ act.client = client;
}
ret = g_app_list.setAction(req_num, act);
@@ -716,287 +637,7 @@ void WindowManager::processError(WMError error)
this->processNextRequest();
}
-/*
- ******* Private Functions *******
- */
-
-bool WindowManager::pop_pending_events()
-{
- bool x{true};
- return this->pending_events.compare_exchange_strong(
- x, false, std::memory_order_consume);
-}
-
-optional<int> WindowManager::lookup_id(char const *name)
-{
- return this->id_alloc.lookup(std::string(name));
-}
-optional<std::string> WindowManager::lookup_name(int id)
-{
- return this->id_alloc.lookup(id);
-}
-
-/**
- * init_layers()
- */
-int WindowManager::init_layers()
-{
- if (!this->controller)
- {
- HMI_ERROR("ivi_controller global not available");
- return -1;
- }
-
- if (this->outputs.empty())
- {
- HMI_ERROR("no output was set up!");
- return -1;
- }
-
- auto &c = this->controller;
-
- auto &o = this->outputs.front();
- auto &s = c->screens.begin()->second;
- auto &layers = c->layers;
-
- // Write output dimensions to ivi controller...
- c->output_size = compositor::size{uint32_t(o->width), uint32_t(o->height)};
- c->physical_size = compositor::size{uint32_t(o->physical_width),
- uint32_t(o->physical_height)};
-
-
- HMI_DEBUG("SCALING: screen (%dx%d), physical (%dx%d)",
- o->width, o->height, o->physical_width, o->physical_height);
-
- this->layers.loadAreaDb();
-
- const compositor::rect css_bg = this->layers.getAreaSize("fullscreen");
- rectangle dp_bg(o->width, o->height);
-
- dp_bg.set_aspect(static_cast<double>(css_bg.w) / css_bg.h);
- dp_bg.fit(o->width, o->height);
- dp_bg.center(o->width, o->height);
- HMI_DEBUG("SCALING: CSS BG(%dx%d) -> DDP %dx%d,(%dx%d)",
- css_bg.w, css_bg.h, dp_bg.left(), dp_bg.top(), dp_bg.width(), dp_bg.height());
-
- // Clear scene
- layers.clear();
-
- // Clear screen
- s->clear();
-
- // Quick and dirty setup of layers
- for (auto const &i : this->layers.mapping)
- {
- c->layer_create(i.second.layer_id, dp_bg.width(), dp_bg.height());
- auto &l = layers[i.second.layer_id];
- l->set_destination_rectangle(dp_bg.left(), dp_bg.top(), dp_bg.width(), dp_bg.height());
- l->set_visibility(1);
- HMI_DEBUG("Setting up layer %s (%d) for surface role match \"%s\"",
- i.second.name.c_str(), i.second.layer_id, i.second.role.c_str());
- }
-
- // Add layers to screen
- s->set_render_order(this->layers.layers);
-
- this->layout_commit();
-
- c->scale = static_cast<double>(dp_bg.height()) / css_bg.h;
- this->layers.setupArea(c->scale);
-
- return 0;
-}
-
-void WindowManager::surface_set_layout(int surface_id, const std::string& area)
-{
- if (!this->controller->surface_exists(surface_id))
- {
- HMI_ERROR("Surface %d does not exist", surface_id);
- return;
- }
-
- auto o_layer_id = this->layers.get_layer_id(surface_id);
-
- if (!o_layer_id)
- {
- HMI_ERROR("Surface %d is not associated with any layer!", surface_id);
- return;
- }
-
- uint32_t layer_id = *o_layer_id;
-
- auto const &layer = this->layers.get_layer(layer_id);
- auto rect = this->layers.getAreaSize(area);
- HMI_SEQ_DEBUG(g_app_list.currentRequestNumber(), "%s : x:%d y:%d w:%d h:%d", area.c_str(),
- rect.x, rect.y, rect.w, rect.h);
- auto &s = this->controller->surfaces[surface_id];
-
- int x = rect.x;
- int y = rect.y;
- int w = rect.w;
- int h = rect.h;
-
- HMI_DEBUG("surface_set_layout for surface %u on layer %u", surface_id,
- layer_id);
-
- // set destination to the display rectangle
- s->set_destination_rectangle(x, y, w, h);
-
- // update area information
- this->area_info[surface_id].x = x;
- this->area_info[surface_id].y = y;
- this->area_info[surface_id].w = w;
- this->area_info[surface_id].h = h;
-
- HMI_DEBUG("Surface %u now on layer %u with rect { %d, %d, %d, %d }",
- surface_id, layer_id, x, y, w, h);
-}
-
-void WindowManager::layout_commit()
-{
- this->controller->commit_changes();
- this->display->flush();
-}
-
-void WindowManager::emit_activated(char const *label)
-{
- this->send_event(kListEventName[Event_Active], label);
-}
-
-void WindowManager::emit_deactivated(char const *label)
-{
- this->send_event(kListEventName[Event_Inactive], label);
-}
-
-void WindowManager::emit_syncdraw(char const *label, char const *area, int x, int y, int w, int h)
-{
- this->send_event(kListEventName[Event_SyncDraw], label, area, x, y, w, h);
-}
-
-void WindowManager::emit_syncdraw(const std::string &role, const std::string &area)
-{
- compositor::rect rect = this->layers.getAreaSize(area);
- this->send_event(kListEventName[Event_SyncDraw],
- role.c_str(), area.c_str(), rect.x, rect.y, rect.w, rect.h);
-}
-
-void WindowManager::emit_flushdraw(char const *label)
-{
- this->send_event(kListEventName[Event_FlushDraw], label);
-}
-
-void WindowManager::emit_visible(char const *label, bool is_visible)
-{
- this->send_event(is_visible ? kListEventName[Event_Visible] : kListEventName[Event_Invisible], label);
-}
-
-void WindowManager::emit_invisible(char const *label)
-{
- return emit_visible(label, false);
-}
-
-void WindowManager::emit_visible(char const *label) { return emit_visible(label, true); }
-
-void WindowManager::activate(int id)
-{
- auto ip = this->controller->sprops.find(id);
- if (ip != this->controller->sprops.end())
- {
- this->controller->surfaces[id]->set_visibility(1);
- char const *label =
- this->lookup_name(id).value_or("unknown-name").c_str();
-
- // FOR CES DEMO >>>
- if ((0 == strcmp(label, "radio")) ||
- (0 == strcmp(label, "music")) ||
- (0 == strcmp(label, "video")) ||
- (0 == strcmp(label, "map")))
- {
- for (auto i = surface_bg.begin(); i != surface_bg.end(); ++i)
- {
- if (id == *i)
- {
- // Remove id
- this->surface_bg.erase(i);
-
- // Remove from BG layer (999)
- HMI_DEBUG("Remove %s(%d) from BG layer", label, id);
- this->controller->layers[999]->remove_surface(id);
-
- // Add to FG layer (1001)
- HMI_DEBUG("Add %s(%d) to FG layer", label, id);
- this->controller->layers[1001]->add_surface(id);
-
- for (int j : this->surface_bg)
- {
- HMI_DEBUG("Stored id:%d", j);
- }
- break;
- }
- }
- }
- // <<< FOR CES DEMO
-
- this->layout_commit();
-
- // TODO: application requests by old role,
- // so convert role new to old for emitting event
- const char* old_role = this->rolenew2old[label].c_str();
-
- this->emit_visible(old_role);
- this->emit_activated(old_role);
- }
-}
-
-void WindowManager::deactivate(int id)
-{
- auto ip = this->controller->sprops.find(id);
- if (ip != this->controller->sprops.end())
- {
- char const *label =
- this->lookup_name(id).value_or("unknown-name").c_str();
-
- // FOR CES DEMO >>>
- if ((0 == strcmp(label, "radio")) ||
- (0 == strcmp(label, "music")) ||
- (0 == strcmp(label, "video")) ||
- (0 == strcmp(label, "map")))
- {
-
- // Store id
- this->surface_bg.push_back(id);
-
- // Remove from FG layer (1001)
- HMI_DEBUG("Remove %s(%d) from FG layer", label, id);
- this->controller->layers[1001]->remove_surface(id);
-
- // Add to BG layer (999)
- HMI_DEBUG("Add %s(%d) to BG layer", label, id);
- this->controller->layers[999]->add_surface(id);
-
- for (int j : surface_bg)
- {
- HMI_DEBUG("Stored id:%d", j);
- }
- }
- else
- {
- this->controller->surfaces[id]->set_visibility(0);
- }
- // <<< FOR CES DEMO
-
- this->layout_commit();
-
- // TODO: application requests by old role,
- // so convert role new to old for emitting event
- const char* old_role = this->rolenew2old[label].c_str();
-
- this->emit_deactivated(old_role);
- this->emit_invisible(old_role);
- }
-}
-
-WMError WindowManager::setRequest(const std::string& appid, const std::string &role, const std::string &area,
+WMError WindowManager::setRequest(const string& appid, const string &role, const string &area,
Task task, unsigned* req_num)
{
if (!g_app_list.contains(appid))
@@ -1028,13 +669,6 @@ WMError WindowManager::setRequest(const std::string& appid, const std::string &r
return WMError::SUCCESS;
}
-WMError WindowManager::doTransition(unsigned req_num)
-{
- HMI_SEQ_DEBUG(req_num, "check policy");
- WMError ret = this->checkPolicy(req_num);
- return ret;
-}
-
WMError WindowManager::checkPolicy(unsigned req_num)
{
/*
@@ -1049,18 +683,7 @@ WMError WindowManager::checkPolicy(unsigned req_num)
ret = WMError::NO_ENTRY;
return ret;
}
- std::string req_area = trigger.area;
-
- if (trigger.task == Task::TASK_ALLOCATE)
- {
- const char *msg = this->check_surface_exist(trigger.role.c_str());
-
- if (msg)
- {
- HMI_SEQ_ERROR(req_num, msg);
- return ret;
- }
- }
+ string req_area = trigger.area;
// Input event data to PolicyManager
if (0 > this->pmw.setInputEventData(trigger.task, trigger.role, trigger.area))
@@ -1097,20 +720,14 @@ WMError WindowManager::startTransition(unsigned req_num)
return ret;
}
+ g_app_list.reqDump();
for (const auto &action : actions)
{
if (action.visible == TaskVisible::VISIBLE)
{
sync_draw_happen = true;
-
- // TODO: application requests by old role,
- // so convert role new to old for emitting event
- std::string old_role = this->rolenew2old[action.role];
-
- this->emit_syncdraw(old_role, action.area);
- /* TODO: emit event for app not subscriber
- if(g_app_list.contains(y.appid))
- g_app_list.lookUpClient(y.appid)->emit_syncdraw(y.role, y.area); */
+ struct rect r = this->lc->getAreaSize(action.area);
+ action.client->emitSyncDraw(action.area, r);
}
}
@@ -1124,12 +741,11 @@ WMError WindowManager::startTransition(unsigned req_num)
// Make it deactivate here
for (const auto &x : actions)
{
- if (g_app_list.contains(x.appid))
- {
- auto client = g_app_list.lookUpClient(x.appid);
- this->deactivate(client->surfaceID(x.role));
- }
+ this->lc->visibilityChange(x);
+ x.client->emitActive(false);
+ x.client->emitVisible(false);
}
+ this->lc->renderLayers();
ret = WMError::NO_LAYOUT_CHANGE;
}
return ret;
@@ -1155,17 +771,18 @@ WMError WindowManager::doEndDraw(unsigned req_num)
if(act.visible != TaskVisible::NO_CHANGE)
{
// layout change
- if(!g_app_list.contains(act.appid)){
- ret = WMError::NOT_REGISTERED;
- }
- ret = this->layoutChange(act);
+ ret = this->lc->layoutChange(act);
if(ret != WMError::SUCCESS)
{
HMI_SEQ_WARNING(req_num,
"Failed to manipulate surfaces while state change : %s", errorDescription(ret));
return ret;
}
- ret = this->visibilityChange(act);
+ ret = this->lc->visibilityChange(act);
+
+ act.client->emitActive((act.visible == VISIBLE));
+ act.client->emitVisible((act.visible == VISIBLE));
+
if (ret != WMError::SUCCESS)
{
HMI_SEQ_WARNING(req_num,
@@ -1173,10 +790,9 @@ WMError WindowManager::doEndDraw(unsigned req_num)
return ret;
}
HMI_SEQ_DEBUG(req_num, "visible %s", act.role.c_str());
- //this->lm_enddraw(act.role.c_str());
}
}
- this->layout_commit();
+ this->lc->renderLayers();
HMI_SEQ_INFO(req_num, "emit flushDraw");
@@ -1184,76 +800,26 @@ WMError WindowManager::doEndDraw(unsigned req_num)
{
if(act_flush.visible == TaskVisible::VISIBLE)
{
- // TODO: application requests by old role,
- // so convert role new to old for emitting event
- std::string old_role = this->rolenew2old[act_flush.role];
-
- this->emit_flushdraw(old_role.c_str());
+ act_flush.client->emitFlushDraw();
}
}
return ret;
}
-WMError WindowManager::layoutChange(const WMAction &action)
-{
- if (action.visible == TaskVisible::INVISIBLE)
- {
- // Visibility is not change -> no redraw is required
- return WMError::SUCCESS;
- }
- auto client = g_app_list.lookUpClient(action.appid);
- unsigned surface = client->surfaceID(action.role);
- if (surface == 0)
- {
- HMI_SEQ_ERROR(g_app_list.currentRequestNumber(),
- "client doesn't have surface with role(%s)", action.role.c_str());
- return WMError::NOT_REGISTERED;
- }
- // Layout Manager
- WMError ret = this->setSurfaceSize(surface, action.area);
- return ret;
-}
-
-WMError WindowManager::visibilityChange(const WMAction &action)
-{
- HMI_SEQ_DEBUG(g_app_list.currentRequestNumber(), "Change visibility");
- if(!g_app_list.contains(action.appid)){
- return WMError::NOT_REGISTERED;
- }
- auto client = g_app_list.lookUpClient(action.appid);
- unsigned surface = client->surfaceID(action.role);
- if(surface == 0)
- {
- HMI_SEQ_ERROR(g_app_list.currentRequestNumber(),
- "client doesn't have surface with role(%s)", action.role.c_str());
- return WMError::NOT_REGISTERED;
- }
-
- if (action.visible != TaskVisible::INVISIBLE)
- {
- this->activate(surface); // Layout Manager task
- }
- else
- {
- this->deactivate(surface); // Layout Manager task
- }
- return WMError::SUCCESS;
-}
-
-WMError WindowManager::setSurfaceSize(unsigned surface, const std::string &area)
-{
- this->surface_set_layout(surface, area);
-
- return WMError::SUCCESS;
-}
-
void WindowManager::emitScreenUpdated(unsigned req_num)
{
// Get visible apps
HMI_SEQ_DEBUG(req_num, "emit screen updated");
bool found = false;
auto actions = g_app_list.getActions(req_num, &found);
+ if (!found)
+ {
+ HMI_SEQ_ERROR(req_num,
+ "Window Manager bug :%s : Action is not set",
+ errorDescription(WMError::NO_ENTRY));
+ return;
+ }
// create json object
json_object *j = json_object_new_object();
@@ -1263,7 +829,7 @@ void WindowManager::emitScreenUpdated(unsigned req_num)
{
if(action.visible != TaskVisible::INVISIBLE)
{
- json_object_array_add(jarray, json_object_new_string(action.appid.c_str()));
+ json_object_array_add(jarray, json_object_new_string(action.client->appID().c_str()));
}
}
json_object_object_add(j, kKeyIds, jarray);
@@ -1271,7 +837,7 @@ void WindowManager::emitScreenUpdated(unsigned req_num)
int ret = afb_event_push(
this->map_afb_event[kListEventName[Event_ScreenUpdated]], j);
- if (ret != 0)
+ if (ret < 0)
{
HMI_DEBUG("afb_event_push failed: %m");
}
@@ -1323,7 +889,7 @@ void WindowManager::processNextRequest()
if (g_app_list.haveRequest())
{
HMI_SEQ_DEBUG(req_num, "Process next request");
- WMError rc = doTransition(req_num);
+ WMError rc = checkPolicy(req_num);
if (rc != WMError::SUCCESS)
{
HMI_SEQ_ERROR(req_num, errorDescription(rc));
@@ -1422,30 +988,6 @@ int WindowManager::loadOldRoleDb()
return 0;
}
-const char *WindowManager::check_surface_exist(const char *drawing_name)
-{
- auto const &surface_id = this->lookup_id(drawing_name);
- if (!surface_id)
- {
- return "Surface does not exist";
- }
-
- if (!this->controller->surface_exists(*surface_id))
- {
- return "Surface does not exist in controller!";
- }
-
- auto layer_id = this->layers.get_layer_id(*surface_id);
-
- if (!layer_id)
- {
- return "Surface is not on any layer!";
- }
-
- HMI_DEBUG("surface %d is detected", *surface_id);
- return nullptr;
-}
-
const char* WindowManager::kDefaultOldRoleDb = "{ \
\"old_roles\": [ \
{ \
@@ -1515,26 +1057,4 @@ const char* WindowManager::kDefaultOldRoleDb = "{ \
] \
}";
-/**
- * controller_hooks
- */
-void controller_hooks::surface_created(uint32_t surface_id)
-{
- this->wmgr->surface_created(surface_id);
-}
-
-void controller_hooks::surface_removed(uint32_t surface_id)
-{
- this->wmgr->surface_removed(surface_id);
-}
-
-void controller_hooks::surface_visibility(uint32_t /*surface_id*/,
- uint32_t /*v*/) {}
-
-void controller_hooks::surface_destination_rectangle(uint32_t /*surface_id*/,
- uint32_t /*x*/,
- uint32_t /*y*/,
- uint32_t /*w*/,
- uint32_t /*h*/) {}
-
} // namespace wm
diff --git a/src/window_manager.hpp b/src/window_manager.hpp
index 72c875a..ccec302 100644
--- a/src/window_manager.hpp
+++ b/src/window_manager.hpp
@@ -22,14 +22,12 @@
#include <memory>
#include <unordered_map>
#include <experimental/optional>
-#include "util.hpp"
-#include "controller_hooks.hpp"
-#include "layers.hpp"
-#include "layout.hpp"
-#include "wayland_ivi_wm.hpp"
+#include "result.hpp"
#include "pm_wrapper.hpp"
+#include "util.hpp"
#include "request.hpp"
#include "wm_error.hpp"
+#include "wm_layer_control.hpp"
extern "C"
{
#include <afb/afb-binding.h>
@@ -37,16 +35,6 @@ extern "C"
struct json_object;
-namespace wl
-{
-struct display;
-}
-
-namespace compositor
-{
-struct controller;
-}
-
namespace wm
{
@@ -77,7 +65,6 @@ extern const char kKeyIds[];
struct id_allocator
{
unsigned next = 1;
-
// Surfaces that where requested but not yet created
std::unordered_map<unsigned, std::string> id2name;
std::unordered_map<std::string, unsigned> name2id;
@@ -142,10 +129,17 @@ struct id_allocator
}
};
+struct TmpClient
+{
+ std::string appid;
+ unsigned layer;
+};
+
+
class WindowManager
{
public:
- typedef std::unordered_map<uint32_t, struct compositor::rect> rect_map;
+ typedef std::unordered_map<uint32_t, struct rect> rect_map;
typedef std::function<void(const char *err_msg)> reply_func;
enum EventType
@@ -168,42 +162,7 @@ class WindowManager
Event_Val_Max = Event_Error,
};
- const std::vector<const char *> kListEventName{
- "active",
- "inactive",
- "visible",
- "invisible",
- "syncDraw",
- "flushDraw",
- "screenUpdated",
- "error"};
-
- struct controller_hooks chooks;
-
- // This is the one thing, we do not own.
- struct wl::display *display;
-
- std::unique_ptr<struct compositor::controller> controller;
- std::vector<std::unique_ptr<struct wl::output>> outputs;
-
- // track current layouts separately
- layer_map layers;
-
- // ID allocation and proxy methods for lookup
- struct id_allocator id_alloc;
-
- // Set by AFB API when wayland events need to be dispatched
- std::atomic<bool> pending_events;
-
- std::map<const char *, struct afb_event> map_afb_event;
-
- // Surface are info (x, y, w, h)
- rect_map area_info;
-
- // FOR CES DEMO
- std::vector<int> surface_bg;
-
- explicit WindowManager(wl::display *d);
+ explicit WindowManager();
~WindowManager() = default;
WindowManager(WindowManager const &) = delete;
@@ -212,23 +171,19 @@ class WindowManager
WindowManager &operator=(WindowManager &&) = delete;
int init();
- int dispatch_pending_events();
- void set_pending_events();
result<int> api_request_surface(char const *appid, char const *role);
char const *api_request_surface(char const *appid, char const *role, char const *ivi_id);
- void api_activate_surface(char const *appid, char const *role, char const *drawing_area, const reply_func &reply);
- void api_deactivate_surface(char const *appid, char const *role, const reply_func &reply);
+ void api_activate_window(char const *appid, char const *role, char const *drawing_area, const reply_func &reply);
+ void api_deactivate_window(char const *appid, char const *role, const reply_func &reply);
void api_enddraw(char const *appid, char const *role);
+ bool api_subscribe(afb_req_t req, EventType event_id);
result<json_object *> api_get_display_info();
result<json_object *> api_get_area_info(char const *role);
- void api_ping();
- void send_event(char const *evname, char const *label);
- void send_event(char const *evname, char const *label, char const *area, int x, int y, int w, int h);
// Events from the compositor we are interested in
- void surface_created(uint32_t surface_id);
- void surface_removed(uint32_t surface_id);
+ void surface_created(unsigned surface_id);
+ void surface_removed(unsigned surface_id);
void removeClient(const std::string &appid);
void exceptionProcessForTransition();
@@ -240,52 +195,32 @@ class WindowManager
void processError(WMError error);
private:
- bool pop_pending_events();
- optional<int> lookup_id(char const *name);
- optional<std::string> lookup_name(int id);
- int init_layers();
- void surface_set_layout(int surface_id, const std::string& area = "");
- void layout_commit();
-
- // WM Events to clients
- void emit_activated(char const *label);
- void emit_deactivated(char const *label);
- void emit_syncdraw(char const *label, char const *area, int x, int y, int w, int h);
- void emit_syncdraw(const std::string &role, const std::string &area);
- void emit_flushdraw(char const *label);
- void emit_visible(char const *label, bool is_visible);
- void emit_invisible(char const *label);
- void emit_visible(char const *label);
-
- void activate(int id);
- void deactivate(int id);
WMError setRequest(const std::string &appid, const std::string &role, const std::string &area,
Task task, unsigned *req_num);
- WMError doTransition(unsigned sequence_number);
WMError checkPolicy(unsigned req_num);
WMError startTransition(unsigned req_num);
WMError doEndDraw(unsigned req_num);
- WMError layoutChange(const WMAction &action);
- WMError visibilityChange(const WMAction &action);
- WMError setSurfaceSize(unsigned surface, const std::string& area);
void emitScreenUpdated(unsigned req_num);
void setTimer();
void stopTimer();
void processNextRequest();
- int loadOldRoleDb();
-
- const char *check_surface_exist(const char *role);
-
private:
- std::unordered_map<std::string, struct compositor::rect> area2size;
+ std::map<std::string, afb_event_t> map_afb_event;
+ std::unordered_map<std::string, struct rect> area2size;
+ std::shared_ptr<LayerControl> lc;
std::unordered_map<std::string, std::string> roleold2new;
std::unordered_map<std::string, std::string> rolenew2old;
PMWrapper pmw;
+ rect_map area_info;
+ struct id_allocator id_alloc;
+ // ID allocation and proxy methods for lookup
+ std::unordered_map<unsigned, struct TmpClient> tmp_surface2app;
+ int loadOldRoleDb();
static const char* kDefaultOldRoleDb;
};
diff --git a/src/wm_client.cpp b/src/wm_client.cpp
index 2e12a69..da7e626 100644
--- a/src/wm_client.cpp
+++ b/src/wm_client.cpp
@@ -16,7 +16,7 @@
#include <json-c/json.h>
#include "wm_client.hpp"
-#include "util.hpp"
+#include <ilm/ilm_control.h>
#define INVALID_SURFACE_ID 0
@@ -26,19 +26,34 @@ using std::vector;
namespace wm
{
-static const vector<string> kWMEvents = {
- // Private event for applications
- "syncDraw", "flushDraw", "visible", "invisible", "active", "inactive", "error"};
-static const vector<string> kErrorDescription = {
- "unknown-error"};
-
+static const char kActive[] = "active";
+static const char kInactive[] = "inactive";
+static const char kVisible[] = "visible";
+static const char kInvisible[] = "invisible";
+static const char kSyncDraw[] = "syncDraw";
+static const char kFlushDraw[] = "flushDraw";
static const char kKeyDrawingName[] = "drawing_name";
+static const char kKeyDrawingArea[] = "drawing_area";
+static const char kKeyRole[] = "role";
+static const char kKeyArea[] = "area";
static const char kKeyrole[] = "role";
static const char kKeyError[] = "error";
-static const char kKeyErrorDesc[] = "kErrorDescription";
+static const char kKeyErrorDesc[] = "errorDescription";
+static const char kKeyX[] = "x";
+static const char kKeyY[] = "y";
+static const char kKeyWidth[] = "width";
+static const char kKeyHeight[] = "height";
+static const char kKeyDrawingRect[] = "drawing-rect";
+
+static const vector<string> kWMEvents = {
+ // Private event for applications
+ kActive, kInactive,
+ kVisible, kInvisible,
+ kSyncDraw, kFlushDraw,
+ kKeyError};
WMClient::WMClient(const string &appid, unsigned layer, unsigned surface, const string &role)
- : id(appid), layer(layer),
+ : id(appid), layer(layer), is_source_set(false),
role2surface(0)
{
role2surface[role] = surface;
@@ -47,17 +62,18 @@ WMClient::WMClient(const string &appid, unsigned layer, unsigned surface, const
#if GTEST_ENABLED
string ev = x;
#else
- afb_event ev = afb_daemon_make_event(x.c_str());
+ afb_event_t ev = afb_daemon_make_event(x.c_str());
#endif
- event2list[x] = ev;
+ evname2afb_event[x] = ev;
}
}
WMClient::WMClient(const string &appid, const string &role)
: id(appid),
layer(0),
+ is_source_set(false),
role2surface(0),
- event2list(0)
+ evname2afb_event(0)
{
role2surface[role] = INVALID_SURFACE_ID;
for (auto x : kWMEvents)
@@ -65,14 +81,29 @@ WMClient::WMClient(const string &appid, const string &role)
#if GTEST_ENABLED
string ev = x;
#else
- afb_event ev = afb_daemon_make_event(x.c_str());
+ afb_event_t ev = afb_daemon_make_event(x.c_str());
#endif
- event2list[x] = ev;
+ evname2afb_event[x] = ev;
}
}
-WMClient::~WMClient()
+WMClient::WMClient(const string &appid, unsigned layer, const string &role)
+ : id(appid),
+ layer(layer),
+ main_role(role),
+ role2surface(0),
+ evname2afb_event(0)
{
+ role2surface[role] = INVALID_SURFACE_ID;
+ for (auto x : kWMEvents)
+ {
+#if GTEST_ENABLED
+ string ev = x;
+#else
+ afb_event_t ev = afb_daemon_make_event(x.c_str());
+#endif
+ evname2afb_event[x] = ev;
+ }
}
string WMClient::appID() const
@@ -80,108 +111,70 @@ string WMClient::appID() const
return this->id;
}
-unsigned WMClient::surfaceID(const string &role) const
+string WMClient::role() const
{
- if (0 == this->role2surface.count(role))
- {
- return INVALID_SURFACE_ID;
- }
- return this->role2surface.at(role);
+ return this->main_role;
}
-std::string WMClient::role(unsigned surface) const
+unsigned WMClient::layerID() const
{
- for(const auto& x : this->role2surface)
- {
- if(x.second == surface)
- {
- return x.first;
- }
- }
- return std::string("");
+ return this->layer;
}
-unsigned WMClient::layerID() const
+unsigned WMClient::surfaceID() const
{
- return this->layer;
+ return this->surface;
}
-/**
- * Set layerID the client belongs to
- *
- * This function set layerID the client belongs to.
- * But this function may not used because the layer should be fixed at constructor.
- * So this function will be used to change layer by some reasons.
- *
- * @param unsigned[in] layerID
- * @return None
- * @attention WMClient can't have multiple layer
- */
-void WMClient::registerLayer(unsigned layer)
+void WMClient::registerSurface(unsigned surface)
{
- this->layer = layer;
+ this->surface = surface;
}
/**
- * Add the pair of role and surface to the client
+ * Add surface to the client
*
- * This function set the pair of role and surface to the client.
- * This function is used for the client which has multi surfaces.
- * If the model and relationship for role and surface(layer)
- * is changed, this function will be changed
- * Current Window Manager doesn't use this function.
+ * This function add main surface to the client(ivi_layer).
*
* @param string[in] role
- * @param unsigned[in] surface
- * @return true
+ * @return WMError
*/
-bool WMClient::addSurface(const string &role, unsigned surface)
+WMError WMClient::addSurface(unsigned surface)
{
- HMI_DEBUG("Add role %s with surface %d", role.c_str(), surface);
- if (0 != this->role2surface.count(role))
+ this->surface = surface;
+ ilmErrorTypes err = ilm_layerAddSurface(this->layer, surface);
+
+ if(err == ILM_SUCCESS)
{
- HMI_NOTICE("override surfaceID %d with %d", this->role2surface[role], surface);
+ err = ilm_commitChanges();
}
- this->role2surface[role] = surface;
- return true;
+ return (err == ILM_SUCCESS) ? WMError::SUCCESS : WMError::FAIL;
}
-bool WMClient::removeSurfaceIfExist(unsigned surface)
+void WMClient::setSurfaceSizeCorrectly()
{
- bool ret = false;
- for (auto &x : this->role2surface)
- {
- if (surface == x.second)
- {
- HMI_INFO("Remove surface from client %s: role %s, surface: %d",
- this->id.c_str(), x.first.c_str(), x.second);
- this->role2surface.erase(x.first);
- ret = true;
- break;
- }
- }
- return ret;
+ this->is_source_set = true;
+}
+
+bool WMClient::isSourceSizeSet()
+{
+ return this->is_source_set;
}
-bool WMClient::removeRole(const string &role)
+bool WMClient::removeSurfaceIfExist(unsigned surface)
{
bool ret = false;
- if (this->role2surface.count(role) != 0)
+ if(surface == this->surface)
{
- this->role2surface.erase(role);
+ this->surface = INVALID_SURFACE_ID;
ret = true;
}
return ret;
}
-#if GTEST_ENABLED
-bool WMClient::subscribe(afb_req req, const string &evname)
+bool WMClient::subscribe(afb_req_t req, const string &evname)
{
- if(evname != kKeyError){
- HMI_DEBUG("error is only enabeled for now");
- return false;
- }
- int ret = afb_req_subscribe(req, this->event2list[evname]);
+ int ret = afb_req_subscribe(req, this->evname2afb_event[evname]);
if (ret)
{
HMI_DEBUG("Failed to subscribe %s", evname.c_str());
@@ -190,24 +183,129 @@ bool WMClient::subscribe(afb_req req, const string &evname)
return true;
}
-void WMClient::emitError(WM_CLIENT_ERROR_EVENT ev)
+void WMClient::emitVisible(bool visible)
+{
+ // error check
+ bool allow_send = false;
+ if(visible)
+ {
+ allow_send = afb_event_is_valid(this->evname2afb_event[kVisible]);
+ }
+ else
+ {
+ allow_send = afb_event_is_valid(this->evname2afb_event[kInvisible]);
+ }
+ if(allow_send)
+ {
+ json_object* j = json_object_new_object();
+ json_object_object_add(j, kKeyRole, json_object_new_string(this->role().c_str()));
+ json_object_object_add(j, kKeyDrawingName, json_object_new_string(this->role().c_str()));
+
+ if(visible)
+ {
+ afb_event_push(this->evname2afb_event[kVisible], j);
+ }
+ else
+ {
+ afb_event_push(this->evname2afb_event[kInvisible], j);
+ }
+ }
+ else
+ {
+ HMI_ERROR("Failed to send %s", __func__);
+ }
+}
+
+void WMClient::emitActive(bool active)
+{
+ // error check
+ bool allow_send = false;
+ if(active)
+ {
+ allow_send = afb_event_is_valid(this->evname2afb_event[kActive]);
+ }
+ else
+ {
+ allow_send = afb_event_is_valid(this->evname2afb_event[kInactive]);
+ }
+ if(allow_send)
+ {
+ json_object* j = json_object_new_object();
+ json_object_object_add(j, kKeyRole, json_object_new_string(this->role().c_str()));
+ json_object_object_add(j, kKeyDrawingName, json_object_new_string(this->role().c_str()));
+
+ if(active)
+ {
+ afb_event_push(this->evname2afb_event[kActive], j);
+ }
+ else
+ {
+ afb_event_push(this->evname2afb_event[kInactive], j);
+ }
+ }
+ else
+ {
+ HMI_ERROR("Failed to send %s", __func__);
+ }
+}
+
+void WMClient::emitSyncDraw(const string& area, struct rect& r)
+{
+ HMI_NOTICE("trace");
+ if(afb_event_is_valid(this->evname2afb_event[kSyncDraw]))
+ {
+ json_object *j_rect = json_object_new_object();
+ json_object_object_add(j_rect, kKeyX, json_object_new_int(r.x));
+ json_object_object_add(j_rect, kKeyY, json_object_new_int(r.y));
+ json_object_object_add(j_rect, kKeyWidth, json_object_new_int(r.w));
+ json_object_object_add(j_rect, kKeyHeight, json_object_new_int(r.h));
+
+ json_object* j = json_object_new_object();
+ json_object_object_add(j, kKeyRole, json_object_new_string(this->role().c_str()));
+ json_object_object_add(j, kKeyDrawingName, json_object_new_string(this->role().c_str()));
+ json_object_object_add(j, kKeyDrawingArea, json_object_new_string(area.c_str()));
+ json_object_object_add(j, kKeyArea, json_object_new_string(this->role().c_str()));
+
+ json_object_object_add(j, kKeyDrawingRect, j_rect);
+ afb_event_push(this->evname2afb_event[kSyncDraw], j);
+ }
+ else
+ {
+ HMI_ERROR("Failed to send %s", __func__);
+ }
+}
+
+void WMClient::emitFlushDraw()
+{
+ if(afb_event_is_valid(this->evname2afb_event[kFlushDraw]))
+ {
+ json_object* j = json_object_new_object();
+ json_object_object_add(j, kKeyRole, json_object_new_string(this->role().c_str()));
+ json_object_object_add(j, kKeyDrawingName, json_object_new_string(this->role().c_str()));
+ afb_event_push(this->evname2afb_event[kFlushDraw], nullptr);
+ }
+ else
+ {
+ HMI_ERROR("Failed to send %s", __func__);
+ }
+}
+
+void WMClient::emitError(WMError error)
{
- if (!afb_event_is_valid(this->event2list[kKeyError])){
+ if (!afb_event_is_valid(this->evname2afb_event[kKeyError])){
HMI_ERROR("event err is not valid");
return;
}
json_object *j = json_object_new_object();
- json_object_object_add(j, kKeyError, json_object_new_int(ev));
- json_object_object_add(j, kKeyErrorDesc, json_object_new_string(kErrorDescription[ev].c_str()));
- HMI_DEBUG("error: %d, description:%s", ev, kErrorDescription[ev].c_str());
-
- int ret = afb_event_push(this->event2list[kKeyError], j);
+ json_object_object_add(j, kKeyError, json_object_new_int(error));
+ json_object_object_add(j, kKeyErrorDesc, json_object_new_string(errorDescription(error)));
+ HMI_DEBUG("error: %d, description:%s", error, errorDescription(error));
+ int ret = afb_event_push(this->evname2afb_event[kKeyError], j);
if (ret != 0)
{
HMI_DEBUG("afb_event_push failed: %m");
}
}
-#endif
void WMClient::dumpInfo()
{
diff --git a/src/wm_client.hpp b/src/wm_client.hpp
index 259d504..3ffa786 100644
--- a/src/wm_client.hpp
+++ b/src/wm_client.hpp
@@ -20,21 +20,17 @@
#include <vector>
#include <string>
#include <unordered_map>
+#include "util.hpp"
+#include "wm_error.hpp"
extern "C"
{
-#define AFB_BINDING_VERSION 2
#include <afb/afb-binding.h>
}
namespace wm
{
-enum WM_CLIENT_ERROR_EVENT
-{
- UNKNOWN_ERROR
-};
-
class WMClient
{
public:
@@ -42,35 +38,48 @@ class WMClient
WMClient(const std::string &appid, unsigned layer,
unsigned surface, const std::string &role);
WMClient(const std::string &appid, const std::string &role);
- virtual ~WMClient();
+ WMClient(const std::string &appid, unsigned layer, const std::string &role);
+ WMClient(const std::string &appid, unsigned layer,
+ const std::string& layer_name, unsigned surface, const std::string &role);
+ ~WMClient() = default;
std::string appID() const;
- unsigned surfaceID(const std::string &role) const;
+ std::string role() const;
unsigned layerID() const;
- std::string role(unsigned surface) const;
- void registerLayer(unsigned layer);
- bool addSurface(const std::string& role, unsigned surface);
+ unsigned surfaceID() const;
+ void registerSurface(unsigned surface);
+ std::string area() const {return this->app_area;};
+ void setArea(const std::string area) {this->app_area = area;}
+ WMError addSurface(unsigned surface);
+ bool isSourceSizeSet();
+ void setSurfaceSizeCorrectly();
bool removeSurfaceIfExist(unsigned surface);
- bool removeRole(const std::string& role);
-#if GTEST_ENABLED
- bool subscribe(afb_req req, const std::string &event_name);
- void emitError(WM_CLIENT_ERROR_EVENT ev);
-#endif
+ bool subscribe(afb_req_t req, const std::string &event_name);
+ void emitActive(bool active);
+ void emitVisible(bool visible);
+ void emitSyncDraw(const std::string& area, struct rect& r);
+ void emitFlushDraw();
+ void emitError(WMError error);
void dumpInfo();
private:
std::string id;
unsigned layer;
+ bool is_source_set;
+ std::string main_role;
+ std::string app_area;
+ unsigned surface; // currently, main application has only one surface.
+ //std::vector<std::string> role_list;
std::unordered_map<std::string, unsigned> role2surface;
#if GTEST_ENABLED
// This is for unit test. afb_make_event occurs sig11 if call not in afb-binding
- std::unordered_map<std::string, std::string> event2list;
+ std::unordered_map<std::string, std::string> evname2afb_event;
#else
- std::unordered_map<std::string, struct afb_event> event2list;
+ std::unordered_map<std::string, afb_event_t> evname2afb_event;
#endif
};
} // namespace wm
-#endif \ No newline at end of file
+#endif
diff --git a/src/wm_layer.cpp b/src/wm_layer.cpp
new file mode 100644
index 0000000..66fb0a2
--- /dev/null
+++ b/src/wm_layer.cpp
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <regex>
+#include <ilm/ilm_control.h>
+#include <stdlib.h>
+#include "wm_client.hpp"
+#include "wm_layer.hpp"
+#include "json_helper.hpp"
+#include "util.hpp"
+
+using std::string;
+using std::vector;
+using std::unordered_map;
+
+#define BG_LAYER_NAME "BackGroundLayer"
+
+namespace wm
+{
+
+LayerState::LayerState()
+ : render_order(),
+ area2appid()
+{}
+
+const unordered_map<string, string> LayerState::getCurrentState()
+{
+ return this->area2appid;
+}
+
+const vector<unsigned> LayerState::getIviIdList()
+{
+ return this->render_order;
+}
+
+void LayerState::addLayer(unsigned layer)
+{
+ auto result = std::find(this->render_order.begin(), this->render_order.end(), layer);
+ if(result == this->render_order.end())
+ this->render_order.push_back(layer);
+}
+
+void LayerState::removeLayer(unsigned layer)
+{
+ auto fwd_itr = std::remove_if(
+ this->render_order.begin(), this->render_order.end(),
+ [layer](unsigned elm) {
+ if(elm == layer)
+ HMI_DEBUG("remove layer %d", elm);
+ return elm == layer;
+ }
+ );
+ this->render_order.erase(fwd_itr, this->render_order.end());
+}
+
+void LayerState::attachAppToArea(const string& app, const string& area)
+{
+ this->area2appid[area] = app;
+}
+
+void LayerState::dump()
+{
+ std::string ids, apps;
+ for(const auto& ro : this->render_order)
+ {
+ ids += std::to_string(ro);
+ ids += ",";
+ }
+ for(const auto& area : this->area2appid)
+ {
+ apps += area.first;
+ apps += ":";
+ apps += area.second;
+ apps += ",";
+ }
+ DUMP(" render order : %s", ids.c_str());
+ DUMP(" area, app : %s", apps.c_str());
+}
+
+WMLayer::WMLayer(json_object* j, unsigned wm_layer_id) : tmp_state(), state(), wm_layer_id(wm_layer_id)
+{
+ this->name = jh::getStringFromJson(j, "name");
+ this->role_list = jh::getStringFromJson(j, "role");
+ this->id_begin = static_cast<unsigned>(jh::getIntFromJson(j, "id_range_begin"));
+ this->id_end = static_cast<unsigned>(jh::getIntFromJson(j, "id_range_end"));
+
+ if (name.empty())
+ {
+ HMI_ERROR("Parse Error!!");
+ exit(1);
+ }
+ if(this->id_begin > this->id_end)
+ {
+ HMI_ERROR("INVALID");
+ exit(1);
+ }
+}
+
+unsigned WMLayer::getNewLayerID(const string& role)
+{
+ unsigned ret = 0;
+ if(this->name == BG_LAYER_NAME)
+ return ret;
+
+ // generate new layer id;
+ if(this->hasRole(role))
+ {
+ if(this->id_list.size() == 0)
+ {
+ ret = this->idBegin();
+ this->id_list.push_back(ret);
+ }
+ else
+ {
+ ret = this->id_list.back() + 1;
+ }
+ HMI_INFO("Generate new id: %d", ret);
+ }
+ else
+ {
+ return ret;
+ }
+
+ size_t count = std::count(id_list.begin(), id_list.end(), ret);
+ if( (ret > this->idEnd()) || (count > 1))
+ {
+ HMI_NOTICE("id %d is not available then generate new id", ret);
+ ret = 0; // reset
+ for(unsigned i = this->idBegin(); i < this->idEnd(); i++)
+ {
+ auto ret_found = std::find(id_list.begin(), id_list.end(), i);
+ if(ret_found == id_list.cend())
+ {
+ HMI_INFO("set new id: %d", i);
+ ret = i;
+ break;
+ }
+ }
+ }
+
+ if(ret != 0)
+ {
+ id_list.push_back(ret);
+ }
+ else
+ {
+ HMI_ERROR("failed to get New ID");
+ }
+ return ret;
+}
+
+const string& WMLayer::layerName()
+{
+ return this->name;
+}
+
+WMError WMLayer::setLayerState(const LayerState& l)
+{
+ this->tmp_state = l;
+ return WMError::SUCCESS;
+}
+
+void WMLayer::addLayerToState(unsigned layer)
+{
+ this->tmp_state.addLayer(layer);
+}
+
+void WMLayer::removeLayerFromState(unsigned layer)
+{
+ this->tmp_state.removeLayer(layer);
+}
+
+void WMLayer::attachAppToArea(const string& app, const string& area)
+{
+ this->tmp_state.attachAppToArea(app, area);
+}
+
+string WMLayer::attachedApp(const string& area)
+{
+ string ret;
+ auto list = this->state.getCurrentState();
+ auto app = list.find(area);
+ if(app != list.end())
+ {
+ ret = app->second;
+ }
+ return ret;
+}
+
+void WMLayer::appendArea(const string& area)
+{
+ this->area_list.push_back(area);
+}
+
+void WMLayer::appTerminated(unsigned id)
+{
+ auto fwd_itr = std::remove_if(this->id_list.begin(), this->id_list.end(),
+ [id](unsigned elm) {
+ return elm == id;
+ });
+ this->id_list.erase(fwd_itr, this->id_list.end());
+ this->tmp_state.removeLayer(id);
+ this->state.removeLayer(id);
+ ilm_layerRemove(id);
+}
+
+bool WMLayer::hasLayerID(unsigned id)
+{
+ bool ret = (id >= this->idBegin() && id <= this->idEnd());
+ if(!ret)
+ return ret;
+ auto itr = std::find(this->id_list.begin(), this->id_list.end(), id);
+ return (itr != this->id_list.end()) ? true : false;
+}
+
+bool WMLayer::hasRole(const string& role)
+{
+ auto re = std::regex(this->role_list);
+ if (std::regex_match(role, re))
+ {
+ HMI_DEBUG("role %s matches layer %s", role.c_str(), this->name.c_str());
+ return true;
+ }
+ return false;
+}
+
+void WMLayer::update()
+{
+ this->state = this->tmp_state;
+}
+
+void WMLayer::undo()
+{
+ this->tmp_state = this->state;
+}
+
+void WMLayer::dump()
+{
+ DUMP("===== wm layer status =====");
+ DUMP("Layer :%s", this->name.c_str());
+ this->tmp_state.dump();
+ this->state.dump();
+ DUMP("===== wm layer status end =====");
+
+}
+
+} // namespace wm
diff --git a/src/wm_layer.hpp b/src/wm_layer.hpp
new file mode 100644
index 0000000..97cf8a8
--- /dev/null
+++ b/src/wm_layer.hpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WM_LAYER_HPP
+#define WM_LAYER_HPP
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <memory>
+#include "wm_error.hpp"
+
+struct json_object;
+
+namespace wm
+{
+
+class WMClient;
+class LayerState
+{
+ public:
+ LayerState();
+ ~LayerState() = default;
+ const std::unordered_map<std::string, std::string> getCurrentState();
+ const std::vector<unsigned> getIviIdList();
+ void addLayer(unsigned layer);
+ void removeLayer(unsigned layer);
+ void attachAppToArea(const std::string& app, const std::string& area);
+
+ // Debug
+ void dump();
+
+ private:
+ std::vector<unsigned> render_order;
+ std::unordered_map<std::string, std::string> area2appid;
+};
+
+class WMLayer
+{
+ public:
+ explicit WMLayer(json_object* j, unsigned wm_layer_id);
+ ~WMLayer() = default;
+
+ // Status & Setting API
+ unsigned getNewLayerID(const std::string& role);
+ unsigned idBegin() { return this->id_begin; }
+ unsigned idEnd() { return this->id_end; }
+ unsigned getWMLayerID() { return this->wm_layer_id; }
+ const std::string& layerName();
+ void appendArea(const std::string& area);
+ LayerState& getLayerState() { return tmp_state; }
+ WMError setLayerState(const LayerState& l);
+ bool hasLayerID(unsigned id);
+ bool hasRole(const std::string& role);
+
+ // Manipulation
+ void addLayerToState(unsigned layer);
+ void removeLayerFromState(unsigned layer);
+ void attachAppToArea(const std::string& app, const std::string& area);
+ std::string attachedApp(const std::string& area);
+ void update();
+ void undo();
+
+ // Event
+ void appTerminated(unsigned layer);
+
+ // Debug
+ void dump();
+
+ private:
+ LayerState tmp_state;
+ LayerState state;
+ unsigned wm_layer_id;
+ std::string name = ""; // Layer name
+ std::string role_list;
+ std::vector<std::string> area_list;
+ std::vector<unsigned> id_list;
+ unsigned id_begin;
+ unsigned id_end;
+};
+
+} // namespace wm
+
+#endif // WM_LAYER_HPP
diff --git a/src/wm_layer_control.cpp b/src/wm_layer_control.cpp
new file mode 100644
index 0000000..65d8c30
--- /dev/null
+++ b/src/wm_layer_control.cpp
@@ -0,0 +1,645 @@
+/*
+ * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
+ * Copyright (c) 2018 Konsulko Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <assert.h>
+#include <unistd.h>
+#include "wm_layer_control.hpp"
+#include "wm_layer.hpp"
+#include "wm_client.hpp"
+#include "request.hpp"
+#include "json_helper.hpp"
+
+#define LC_AREA_FILE "areas.json"
+#define LC_LAYER_SETTING_FILE "layers.json"
+#define LC_DEFAULT_AREA "fullscreen"
+#define BACK_GROUND_LAYER "BackGroundLayer"
+
+using std::string;
+using std::vector;
+using std::shared_ptr;
+
+namespace wm {
+
+LayerControl* g_lc_ctxt;
+
+static void createCallback_static(ilmObjectType object,
+ t_ilm_uint id,
+ t_ilm_bool created,
+ void* data)
+{
+ static_cast<LayerControl*>(data)->dispatchCreateEvent(object, id, created);
+}
+
+static void surfaceCallback_static(t_ilm_surface surface,
+ struct ilmSurfaceProperties* surface_prop,
+ t_ilm_notification_mask mask)
+{
+ g_lc_ctxt->dispatchSurfacePropChangeEvent(surface, surface_prop, mask);
+}
+
+static void layerCallback_static(t_ilm_layer layer,
+ struct ilmLayerProperties* layer_prop,
+ t_ilm_notification_mask mask)
+{
+ g_lc_ctxt->dispatchLayerPropChangeEvent(layer, layer_prop, mask);
+}
+
+LayerControl::LayerControl(const std::string& root)
+{
+ string area_path(get_file_path(LC_AREA_FILE, root.c_str()));
+ string layer_path(get_file_path(LC_LAYER_SETTING_FILE, root.c_str()));
+ // load layers.setting.json
+ WMError ret = this->loadLayerSetting(layer_path);
+ assert(ret == WMError::SUCCESS);
+ // load areas.json
+ ret = this->loadAreaDb(area_path);
+ assert(ret == WMError::SUCCESS);
+}
+
+WMError LayerControl::init(const LayerControlCallbacks& cb)
+{
+ HMI_DEBUG("Initialize of ilm library and display");
+ t_ilm_uint num = 0;
+ t_ilm_uint *ids;
+ int cnt = 0;
+ ilmErrorTypes rc = ilm_init();
+
+ while (rc != ILM_SUCCESS)
+ {
+ cnt++;
+ if (20 <= cnt)
+ {
+ HMI_ERROR("Could not connect to compositor");
+ goto lc_init_error;
+ }
+ HMI_ERROR("Wait to start weston ...");
+ sleep(1);
+ rc = ilm_init();
+ }
+ if(rc != ILM_SUCCESS) goto lc_init_error;
+
+ // Get current screen setting
+ rc = ilm_getScreenIDs(&num, &ids);
+
+ if(rc != ILM_SUCCESS) goto lc_init_error;
+
+ for(unsigned i = 0; i < num; i++)
+ {
+ HMI_INFO("get screen: %d", ids[i]);
+ }
+ // Currently, 0 is only available
+ this->screenID = ids[0];
+
+ rc = ilm_getPropertiesOfScreen(this->screenID, &this->screen_prop);
+
+ if(rc != ILM_SUCCESS) goto lc_init_error;
+
+ // Register Callback to Window Manager and from ILM
+ this->cb = cb;
+ ilm_registerNotification(createCallback_static, this);
+
+ return WMError::SUCCESS;
+
+lc_init_error:
+ HMI_ERROR("Failed to initialize. Terminate WM");
+
+ return WMError::FAIL;
+}
+
+void LayerControl::createNewLayer(unsigned id)
+{
+ HMI_INFO("create new ID :%d", id);
+ struct rect rct = this->area2size[LC_DEFAULT_AREA];
+ ilm_layerCreateWithDimension(&id, rct.w, rct.h);
+ //ilm_layerSetSourceRectangle(id, rct.x, rct.y, rct.w, rct.h);
+ ilm_layerSetDestinationRectangle(id, this->offset_x, this->offset_y, rct.w, rct.h);
+ ilm_layerSetOpacity(id, 1.0);
+ ilm_layerSetVisibility(id, ILM_FALSE);
+ ilm_commitChanges();
+ auto wm_layer = getWMLayer(id);
+ wm_layer->addLayerToState(id);
+ this->renderLayers();
+}
+
+unsigned LayerControl::getNewLayerID(const string& role)
+{
+ unsigned ret = 0;
+ for(const auto& l: this->wm_layers)
+ {
+ ret = l->getNewLayerID(role);
+ if(ret != 0)
+ {
+ unsigned wmlid = l->getWMLayerID();
+ this->lid2wmlid[ret] = wmlid;
+ break;
+ }
+ }
+ return ret;
+}
+
+shared_ptr<WMLayer> LayerControl::getWMLayer(unsigned layer)
+{
+ unsigned wm_lid = this->lid2wmlid[layer];
+ return this->wm_layers[wm_lid];
+}
+
+std::shared_ptr<WMLayer> LayerControl::getWMLayer(std::string layer_name)
+{
+ for(auto &l : this->wm_layers)
+ {
+ if(l->layerName() == layer_name)
+ {
+ return l;
+ }
+ }
+ return nullptr;
+}
+
+struct rect LayerControl::getAreaSize(const std::string& area)
+{
+ return area2size[area];
+}
+
+void LayerControl::setupArea(const rectangle& base_rct, double scaling)
+{
+ this->scaling = scaling;
+ this->offset_x = base_rct.left();
+ this->offset_y = base_rct.top();
+
+ for (auto &i : this->area2size)
+ {
+ i.second.x = static_cast<int>(scaling * i.second.x + 0.5);
+ i.second.y = static_cast<int>(scaling * i.second.y + 0.5);
+ i.second.w = static_cast<int>(scaling * i.second.w + 0.5);
+ i.second.h = static_cast<int>(scaling * i.second.h + 0.5);
+
+ HMI_DEBUG("area:%s size(after) : x:%d y:%d w:%d h:%d",
+ i.first.c_str(), i.second.x, i.second.y, i.second.w, i.second.h);
+ }
+}
+
+Screen LayerControl::getScreenInfo()
+{
+ return Screen(this->screen_prop.screenWidth, this->screen_prop.screenHeight);
+}
+
+double LayerControl::scale()
+{
+ return this->scaling;
+}
+
+WMError LayerControl::renderLayers()
+{
+ HMI_INFO("Commit change");
+ WMError rc = WMError::SUCCESS;
+
+ // Check the number of layers
+ vector<unsigned> ivi_l_ids;
+ for(auto& l : this->wm_layers)
+ {
+ auto state = l->getLayerState();
+ HMI_DEBUG("layer %s", l->layerName().c_str());
+ for(const auto& id : state.getIviIdList())
+ {
+ HMI_DEBUG("Add %d", id);
+ ivi_l_ids.push_back(id);
+ }
+ }
+
+ // Create render order
+ t_ilm_layer* id_array = new t_ilm_layer[ivi_l_ids.size()];
+ if(id_array == nullptr)
+ {
+ HMI_WARNING("short memory");
+ this->undoUpdate();
+ return WMError::FAIL;
+ }
+ int count = 0;
+ for(const auto& i : ivi_l_ids)
+ {
+ id_array[count] = i;
+ ++count;
+ }
+
+ // Display
+ ilmErrorTypes ret = ilm_displaySetRenderOrder(this->screenID, id_array, ivi_l_ids.size());
+ if(ret != ILM_SUCCESS)
+ {
+ this->undoUpdate();
+ rc = WMError::FAIL;
+ }
+ else
+ {
+ for(auto& l : this->wm_layers)
+ {
+ l->update();
+ }
+ }
+ ilm_commitChanges();
+ delete id_array;
+ return rc;
+}
+
+WMError LayerControl::setXDGSurfaceOriginSize(unsigned surface)
+{
+ WMError ret = WMError::NOT_REGISTERED;
+ ilmSurfaceProperties prop;
+ ilmErrorTypes rc = ilm_getPropertiesOfSurface(surface, &prop);
+ if(rc == ILM_SUCCESS)
+ {
+ HMI_INFO("xdg surface info %d, %d", prop.origSourceWidth, prop.origSourceHeight);
+ ilm_surfaceSetSourceRectangle(surface, 0, 0, prop.origSourceWidth, prop.origSourceHeight);
+ ret = WMError::SUCCESS;
+ }
+ return ret;
+}
+
+
+void LayerControl::undoUpdate()
+{
+ for(auto& l : this->wm_layers)
+ {
+ l->undo();
+ }
+}
+
+WMError LayerControl::loadLayerSetting(const string &path)
+{
+ HMI_DEBUG("loading WMLayer(Application Containers) Setting from %s", path.c_str());
+
+ json_object *json_obj, *json_cfg;
+ int ret = jh::inputJsonFilie(path.c_str(), &json_obj);
+ if (0 > ret)
+ {
+ HMI_ERROR("Could not open %s", path.c_str());
+ return WMError::FAIL;
+ }
+ HMI_INFO("json_obj dump:%s", json_object_get_string(json_obj));
+
+ if (!json_object_object_get_ex(json_obj, "mappings", &json_cfg))
+ {
+ HMI_ERROR("Parse Error!!");
+ return WMError::FAIL;
+ }
+
+ int len = json_object_array_length(json_cfg);
+ HMI_DEBUG("json_cfg len:%d", len);
+
+ for (int i = 0; i < len; i++)
+ {
+ json_object *json_tmp = json_object_array_get_idx(json_cfg, i);
+ HMI_DEBUG("> json_tmp dump:%s", json_object_get_string(json_tmp));
+
+ this->wm_layers.emplace_back(std::make_shared<WMLayer>(json_tmp, i));
+ }
+ json_object_put(json_obj);
+
+ return WMError::SUCCESS;
+}
+
+WMError LayerControl::loadAreaDb(const std::string& path)
+{
+ // Load area.db
+ json_object *json_obj;
+ int ret = jh::inputJsonFilie(path.c_str(), &json_obj);
+ if (0 > ret)
+ {
+ HMI_ERROR("Could not open %s", path.c_str());
+ return WMError::FAIL;
+ }
+ HMI_INFO("json_obj dump:%s", json_object_get_string(json_obj));
+
+ // Perse areas
+ json_object *json_cfg;
+ if (!json_object_object_get_ex(json_obj, "areas", &json_cfg))
+ {
+ HMI_ERROR("Parse Error!!");
+ return WMError::FAIL;
+ }
+
+ int len = json_object_array_length(json_cfg);
+ HMI_DEBUG("json_cfg len:%d", len);
+
+ const char *area;
+ for (int i = 0; i < len; i++)
+ {
+ json_object *json_tmp = json_object_array_get_idx(json_cfg, i);
+ HMI_DEBUG("> json_tmp dump:%s", json_object_get_string(json_tmp));
+
+ area = jh::getStringFromJson(json_tmp, "name");
+ if (nullptr == area)
+ {
+ HMI_ERROR("Parse Error!!");
+ return WMError::FAIL;
+ }
+ HMI_DEBUG("> area:%s", area);
+
+ json_object *json_rect;
+ if (!json_object_object_get_ex(json_tmp, "rect", &json_rect))
+ {
+ HMI_ERROR("Parse Error!!");
+ return WMError::FAIL;
+ }
+ HMI_DEBUG("> json_rect dump:%s", json_object_get_string(json_rect));
+
+ struct rect area_size;
+ area_size.x = jh::getIntFromJson(json_rect, "x");
+ area_size.y = jh::getIntFromJson(json_rect, "y");
+ area_size.w = jh::getIntFromJson(json_rect, "w");
+ area_size.h = jh::getIntFromJson(json_rect, "h");
+
+ this->area2size[area] = area_size;
+ }
+
+ // Check
+ for (const auto& itr : this->area2size)
+ {
+ HMI_DEBUG("area:%s x:%d y:%d w:%d h:%d",
+ itr.first.c_str(), itr.second.x, itr.second.y,
+ itr.second.w, itr.second.h);
+ }
+
+ // Release json_object
+ json_object_put(json_obj);
+
+ return WMError::SUCCESS;
+}
+
+WMError LayerControl::layoutChange(const WMAction& action)
+{
+ if (action.visible == TaskVisible::INVISIBLE)
+ {
+ // Visibility is not change -> no redraw is required
+ return WMError::SUCCESS;
+ }
+ if(action.client == nullptr)
+ {
+ HMI_SEQ_ERROR(action.req_num, "client may vanish");
+ return WMError::NOT_REGISTERED;
+ }
+ unsigned layer = action.client->layerID();
+ unsigned surface = action.client->surfaceID();
+
+ auto rect = this->getAreaSize(action.area);
+ HMI_SEQ_INFO(action.req_num, "Set layout %d, %d, %d, %d",rect.x, rect.y, rect.w, rect.h);
+
+ // Sometimes, ivi_wm_surface_size signal doesn't reach window manager,
+ // then, Window Manager set set source size = 0.
+ if(!action.client->isSourceSizeSet())
+ {
+ ilmSurfaceProperties sp;
+ ilm_getPropertiesOfSurface(surface, &sp);
+ if((sp.origSourceHeight != sp.sourceHeight) || (sp.origSourceWidth != sp.sourceWidth))
+ {
+ HMI_SEQ_NOTICE(action.req_num, "set source size w:%d h%d", sp.origSourceWidth, sp.origSourceHeight);
+ ilm_surfaceSetSourceRectangle(surface, 0, 0, sp.origSourceWidth, sp.origSourceHeight);
+ ilm_commitChanges();
+ action.client->setSurfaceSizeCorrectly();
+ }
+ }
+
+ ilm_surfaceSetDestinationRectangle(surface, rect.x, rect.y, rect.w, rect.h);
+ ilm_commitChanges();
+ action.client->setArea(action.area);
+ for(auto &wm_layer: this->wm_layers)
+ {
+ // Store the state who is assigned to the area
+ if(wm_layer->hasLayerID(layer))
+ {
+ wm_layer->attachAppToArea(action.client->appID(), action.area);
+ /* TODO: manipulate state directly
+ LayerState ls = wm_layer->getLayerState();
+ ls.seattachAppToAreatArea(action.client->appID(), action.area);
+ wm_layer->dump(); */
+ }
+ }
+
+ return WMError::SUCCESS;
+}
+
+WMError LayerControl::visibilityChange(const WMAction& action)
+{
+ WMError ret = WMError::FAIL;
+ if(action.client == nullptr)
+ {
+ HMI_SEQ_ERROR(action.req_num, "client may vanish");
+ return WMError::NOT_REGISTERED;
+ }
+
+ if (action.visible == TaskVisible::VISIBLE)
+ {
+ ret = this->makeVisible(action.client);
+ }
+ else if (action.visible == TaskVisible::INVISIBLE)
+ {
+ ret = this->makeInvisible(action.client);
+ }
+ ilm_commitChanges();
+ return ret;
+}
+
+void LayerControl::appTerminated(const shared_ptr<WMClient> client)
+{
+ for(auto& l : this->wm_layers)
+ {
+ if(l->hasLayerID(client->layerID()))
+ {
+ l->appTerminated(client->layerID());
+ }
+ }
+}
+
+void LayerControl::dispatchCreateEvent(ilmObjectType object, unsigned id, bool created)
+{
+ if (ILM_SURFACE == object)
+ {
+ if (created)
+ {
+ ilmSurfaceProperties sp;
+ ilmErrorTypes rc;
+ rc = ilm_getPropertiesOfSurface(id, &sp);
+ if(rc != ILM_SUCCESS)
+ {
+ HMI_ERROR("Failed to get surface %d property due to %d", id, ilm_getError());
+ return;
+ }
+ this->cb.surfaceCreated(sp.creatorPid, id);
+ ilm_surfaceAddNotification(id, surfaceCallback_static);
+ ilm_surfaceSetVisibility(id, ILM_TRUE);
+ ilm_surfaceSetType(id, ILM_SURFACETYPE_DESKTOP);
+ }
+ else
+ {
+ this->cb.surfaceDestroyed(id);
+ }
+ }
+ if (ILM_LAYER == object)
+ {
+ if(created)
+ {
+ ilm_layerAddNotification(id, layerCallback_static);
+ }
+ else
+ {
+ // Ignore here. Nothing to do currently.
+ // Process of application dead is handled by Window Manager
+ // from binder notification
+ }
+ }
+}
+
+void LayerControl::dispatchSurfacePropChangeEvent(unsigned id,
+ struct ilmSurfaceProperties* sprop,
+ t_ilm_notification_mask mask)
+{
+ /*
+ ILM_NOTIFICATION_CONTENT_AVAILABLE & ILM_NOTIFICATION_CONTENT_REMOVED
+ are not handled here, handled in create/destroy event
+ */
+ if (ILM_NOTIFICATION_VISIBILITY & mask)
+ {
+ HMI_DEBUG("surface %d turns visibility %d", id, sprop->visibility);
+ }
+ if (ILM_NOTIFICATION_OPACITY & mask)
+ {
+ HMI_DEBUG("surface %d turns opacity %f", id, sprop->opacity);
+ }
+ if (ILM_NOTIFICATION_SOURCE_RECT & mask)
+ {
+ HMI_DEBUG("surface %d source rect changes", id);
+ }
+ if (ILM_NOTIFICATION_DEST_RECT & mask)
+ {
+ HMI_DEBUG("surface %d dest rect changes", id);
+ }
+ if (ILM_NOTIFICATION_CONFIGURED & mask)
+ {
+ HMI_DEBUG("surface %d size %d, %d, %d, %d", id,
+ sprop->sourceX, sprop->sourceY, sprop->origSourceWidth, sprop->origSourceHeight);
+ ilm_surfaceSetSourceRectangle(id, 0, 0, sprop->origSourceWidth, sprop->origSourceHeight);
+ }
+}
+
+void LayerControl::dispatchLayerPropChangeEvent(unsigned id,
+ struct ilmLayerProperties* lprop,
+ t_ilm_notification_mask mask)
+{
+ if (ILM_NOTIFICATION_VISIBILITY & mask)
+ {
+ HMI_DEBUG("layer %d turns visibility %d", id, lprop->visibility);
+ }
+ if (ILM_NOTIFICATION_OPACITY & mask)
+ {
+ HMI_DEBUG("layer %d turns opacity %f", id, lprop->opacity);
+ }
+ if (ILM_NOTIFICATION_SOURCE_RECT & mask)
+ {
+ HMI_DEBUG("layer %d source rect changes", id);
+ }
+ if (ILM_NOTIFICATION_DEST_RECT & mask)
+ {
+ HMI_DEBUG("layer %d dest rect changes", id);
+ }
+}
+
+WMError LayerControl::makeVisible(const shared_ptr<WMClient> client)
+{
+ WMError ret = WMError::SUCCESS;
+ // Don't check here wheher client is nullptr or not
+ unsigned layer = client->layerID();
+
+ this->moveForeGround(client);
+
+ ilm_layerSetVisibility(layer, ILM_TRUE);
+
+ return ret;
+}
+
+WMError LayerControl::makeInvisible(const shared_ptr<WMClient> client)
+{
+ WMError ret = WMError::SUCCESS;
+ // Don't check here the client is not nullptr
+ unsigned layer = client->layerID();
+
+ bool mv_ok = this->moveBackGround(client);
+
+ if(!mv_ok)
+ {
+ HMI_INFO("make invisible client %s", client->appID().c_str());
+ ilm_layerSetVisibility(layer, ILM_FALSE);
+ }
+
+ return ret;
+}
+
+bool LayerControl::moveBackGround(const shared_ptr<WMClient> client)
+{
+ bool ret = false;
+
+ // Move background from foreground layer
+ auto bg = this->getWMLayer(BACK_GROUND_LAYER);
+ if(bg != nullptr)
+ {
+ HMI_DEBUG("client %s role %s", client->appID().c_str(), client->role().c_str());
+ unsigned layer = client->layerID();
+ if(bg->hasRole(client->role()))
+ {
+ HMI_INFO("%s go to background", client->appID().c_str());
+ bg->addLayerToState(layer);
+ auto wm_layer = this->getWMLayer(layer);
+ wm_layer->removeLayerFromState(layer);
+ /* TODO: manipulate state directly
+ LayerState bg_ls = bg->getLayerState();
+ bg_ls.addLayer(layer);
+ LayerState ls = wm_layer->getLayerState();
+ ls.removeLayer(layer); */
+ bg->dump();
+ wm_layer->dump();
+ ret = true;
+ }
+ }
+ return ret;
+}
+
+bool LayerControl::moveForeGround(const shared_ptr<WMClient> client)
+{
+ bool ret = false;
+
+ // Move foreground from foreground layer
+ auto bg = this->getWMLayer(BACK_GROUND_LAYER);
+ if(bg != nullptr)
+ {
+ if(bg->hasRole(client->role()))
+ {
+ unsigned layer = client->layerID();
+ HMI_INFO("%s go to foreground", client->appID().c_str());
+ bg->removeLayerFromState(layer);
+ auto wm_layer = this->getWMLayer(layer);
+ wm_layer->addLayerToState(layer);
+ /* TODO: manipulate state directly
+ LayerState bg_ls = bg->getLayerState();
+ bg_ls.removeLayer(layer);
+ LayerState ls = wm_layer->getLayerState();
+ ls.addLayer(layer); */
+ bg->dump();
+ wm_layer->dump();
+ ret = true;
+ }
+ }
+ return ret;
+}
+
+} // namespace wm
diff --git a/src/wm_layer_control.hpp b/src/wm_layer_control.hpp
new file mode 100644
index 0000000..25d71fd
--- /dev/null
+++ b/src/wm_layer_control.hpp
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string>
+#include <memory>
+#include <vector>
+#include <unordered_map>
+#include <functional>
+#include <ilm/ilm_control.h>
+#include "wm_error.hpp"
+#include "util.hpp"
+
+namespace wm {
+
+class Screen {
+ public:
+ Screen(unsigned w, unsigned h) : _width(w), _height(h){}
+ unsigned width() { return _width; }
+ unsigned height() { return _height; }
+ private:
+ unsigned _width;
+ unsigned _height;
+ unsigned _pysical_width = 0;
+ unsigned _pysical_height = 0;
+};
+
+class LayerControlCallbacks {
+ public:
+ LayerControlCallbacks() {};
+ ~LayerControlCallbacks() = default;
+ LayerControlCallbacks(const LayerControlCallbacks &obj) = default;
+
+ // callback functions
+ std::function<void(unsigned, unsigned)> surfaceCreated;
+ std::function<void(unsigned)> surfaceDestroyed;
+ /*
+ std::function<void(unsigned)> layerCreated;
+ std::function<void(unsigned)> layerDestroyed;
+ */
+};
+
+class WMLayer;
+class LayerState;
+class WMAction;
+class WMClient;
+
+class LayerControl
+{
+ public:
+ explicit LayerControl(const std::string& root);
+ ~LayerControl() = default;
+ WMError init(const LayerControlCallbacks& cb);
+ void createNewLayer(unsigned id);
+ unsigned getNewLayerID(const std::string& role);
+ std::shared_ptr<WMLayer> getWMLayer(unsigned layer);
+ std::shared_ptr<WMLayer> getWMLayer(std::string layer_name);
+ struct rect getAreaSize(const std::string& area);
+ void setupArea(const rectangle& base_rct, double scaling);
+ Screen getScreenInfo();
+ double scale();
+ WMError renderLayers();
+ WMError setXDGSurfaceOriginSize(unsigned surface);
+ void undoUpdate();
+ WMError layoutChange(const WMAction& action);
+ WMError visibilityChange(const WMAction &action);
+ void appTerminated(const std::shared_ptr<WMClient> client);
+
+ // Don't use this function.
+ void dispatchCreateEvent(ilmObjectType object, unsigned id, bool created);
+ void dispatchSurfacePropChangeEvent(unsigned id, struct ilmSurfaceProperties*, t_ilm_notification_mask);
+ void dispatchLayerPropChangeEvent(unsigned id, struct ilmLayerProperties*, t_ilm_notification_mask);
+
+ private:
+ WMError makeVisible(const std::shared_ptr<WMClient> client);
+ WMError makeInvisible(const std::shared_ptr<WMClient> client);
+ bool moveForeGround(const std::shared_ptr<WMClient> client);
+ bool moveBackGround(const std::shared_ptr<WMClient> client);
+ WMError loadLayerSetting(const std::string& path);
+ WMError loadAreaDb(const std::string& path);
+
+ std::vector<std::shared_ptr<WMLayer>> wm_layers;
+ std::unordered_map<unsigned, unsigned> lid2wmlid;
+ std::unordered_map<std::string, struct rect> area2size;
+ unsigned screenID;
+ struct ilmScreenProperties screen_prop;
+ double scaling;
+ int offset_x;
+ int offset_y;
+ LayerControlCallbacks cb;
+};
+
+} // namespace wm \ No newline at end of file