From 8b2dc08ec3b3e326fc20eb54a5deda20149ab545 Mon Sep 17 00:00:00 2001 From: Martin Felis Date: Mon, 19 Mar 2018 23:00:51 +0100 Subject: [PATCH] added tinygltf --- 3rdparty/tinygltf/.clang-format | 7 + 3rdparty/tinygltf/.gitignore | 70 + 3rdparty/tinygltf/.travis-before-install.sh | 10 + 3rdparty/tinygltf/.travis.yml | 47 + 3rdparty/tinygltf/LICENSE | 21 + 3rdparty/tinygltf/README.md | 140 + 3rdparty/tinygltf/appveyor.yml | 18 + 3rdparty/tinygltf/deps/cpplint.py | 6323 +++++++ 3rdparty/tinygltf/examples.bat | 3 + 3rdparty/tinygltf/examples/glview/README.md | 34 + 3rdparty/tinygltf/examples/glview/glview.cc | 861 + .../tinygltf/examples/glview/premake5.lua | 43 + 3rdparty/tinygltf/examples/glview/shader.frag | 16 + 3rdparty/tinygltf/examples/glview/shader.vert | 16 + .../tinygltf/examples/glview/trackball.cc | 292 + 3rdparty/tinygltf/examples/glview/trackball.h | 75 + 3rdparty/tinygltf/examples/raytrace/README.md | 130 + .../tinygltf/examples/raytrace/config.json | 23 + .../tinygltf/examples/raytrace/gltf-loader.cc | 491 + .../tinygltf/examples/raytrace/gltf-loader.h | 166 + .../examples/raytrace/images/nanosg-demo.png | Bin 0 -> 124517 bytes 3rdparty/tinygltf/examples/raytrace/main.cc | 1073 ++ .../tinygltf/examples/raytrace/material.h | 75 + 3rdparty/tinygltf/examples/raytrace/matrix.cc | 216 + 3rdparty/tinygltf/examples/raytrace/mesh.h | 188 + 3rdparty/tinygltf/examples/raytrace/nanort.cc | 1 + 3rdparty/tinygltf/examples/raytrace/nanort.h | 2313 +++ 3rdparty/tinygltf/examples/raytrace/nanosg.h | 882 + .../tinygltf/examples/raytrace/obj-loader.cc | 458 + .../tinygltf/examples/raytrace/obj-loader.h | 19 + .../tinygltf/examples/raytrace/premake5.lua | 115 + .../examples/raytrace/render-config.cc | 122 + .../examples/raytrace/render-config.h | 43 + 3rdparty/tinygltf/examples/raytrace/render.cc | 560 + 3rdparty/tinygltf/examples/raytrace/render.h | 45 + .../tinygltf/examples/raytrace/stbi-impl.cc | 3 + .../tinygltf/examples/raytrace/viwewer.make | 357 + 3rdparty/tinygltf/examples/saver/Makefile.dev | 2 + 3rdparty/tinygltf/examples/saver/README.md | 1 + 3rdparty/tinygltf/examples/saver/main.cc | 33 + .../examples/validator/CMakeLists.txt | 47 + .../LICENSE.json-schema-validator.MIT | 22 + .../examples/validator/LICENSE.jsonhpp.MIT | 21 + .../tinygltf/examples/validator/README.md | 32 + .../validator/app/tinygltf-validate.cc | 140 + .../validator/src/json-schema-draft4.json.cpp | 160 + .../examples/validator/src/json-schema.hpp | 201 + .../examples/validator/src/json-uri.cpp | 190 + .../examples/validator/src/json-validator.cpp | 738 + .../tinygltf/examples/validator/src/json.hpp | 13003 ++++++++++++++ 3rdparty/tinygltf/json.hpp | 14722 ++++++++++++++++ 3rdparty/tinygltf/loader_example.cc | 570 + 3rdparty/tinygltf/models/Cube/Cube.bin | Bin 0 -> 1800 bytes 3rdparty/tinygltf/models/Cube/Cube.gltf | 193 + .../tinygltf/models/Cube/Cube_BaseColor.png | Bin 0 -> 891995 bytes .../models/Cube/Cube_MetallicRoughness.png | Bin 0 -> 319 bytes 3rdparty/tinygltf/models/Cube/README.md | 4 + 3rdparty/tinygltf/premake5.lua | 30 + 3rdparty/tinygltf/stb_image.h | 6509 +++++++ 3rdparty/tinygltf/test_runner.py | 65 + 3rdparty/tinygltf/tests/catch.hpp | 10445 +++++++++++ 3rdparty/tinygltf/tests/tester.cc | 26 + 3rdparty/tinygltf/tiny_gltf.h | 3883 ++++ 3rdparty/tinygltf/vcsetup.bat | 1 + 64 files changed, 66294 insertions(+) create mode 100644 3rdparty/tinygltf/.clang-format create mode 100644 3rdparty/tinygltf/.gitignore create mode 100755 3rdparty/tinygltf/.travis-before-install.sh create mode 100644 3rdparty/tinygltf/.travis.yml create mode 100644 3rdparty/tinygltf/LICENSE create mode 100644 3rdparty/tinygltf/README.md create mode 100644 3rdparty/tinygltf/appveyor.yml create mode 100755 3rdparty/tinygltf/deps/cpplint.py create mode 100644 3rdparty/tinygltf/examples.bat create mode 100644 3rdparty/tinygltf/examples/glview/README.md create mode 100644 3rdparty/tinygltf/examples/glview/glview.cc create mode 100644 3rdparty/tinygltf/examples/glview/premake5.lua create mode 100644 3rdparty/tinygltf/examples/glview/shader.frag create mode 100644 3rdparty/tinygltf/examples/glview/shader.vert create mode 100644 3rdparty/tinygltf/examples/glview/trackball.cc create mode 100644 3rdparty/tinygltf/examples/glview/trackball.h create mode 100644 3rdparty/tinygltf/examples/raytrace/README.md create mode 100644 3rdparty/tinygltf/examples/raytrace/config.json create mode 100644 3rdparty/tinygltf/examples/raytrace/gltf-loader.cc create mode 100644 3rdparty/tinygltf/examples/raytrace/gltf-loader.h create mode 100644 3rdparty/tinygltf/examples/raytrace/images/nanosg-demo.png create mode 100644 3rdparty/tinygltf/examples/raytrace/main.cc create mode 100644 3rdparty/tinygltf/examples/raytrace/material.h create mode 100644 3rdparty/tinygltf/examples/raytrace/matrix.cc create mode 100644 3rdparty/tinygltf/examples/raytrace/mesh.h create mode 100644 3rdparty/tinygltf/examples/raytrace/nanort.cc create mode 100644 3rdparty/tinygltf/examples/raytrace/nanort.h create mode 100644 3rdparty/tinygltf/examples/raytrace/nanosg.h create mode 100644 3rdparty/tinygltf/examples/raytrace/obj-loader.cc create mode 100644 3rdparty/tinygltf/examples/raytrace/obj-loader.h create mode 100644 3rdparty/tinygltf/examples/raytrace/premake5.lua create mode 100644 3rdparty/tinygltf/examples/raytrace/render-config.cc create mode 100644 3rdparty/tinygltf/examples/raytrace/render-config.h create mode 100644 3rdparty/tinygltf/examples/raytrace/render.cc create mode 100644 3rdparty/tinygltf/examples/raytrace/render.h create mode 100644 3rdparty/tinygltf/examples/raytrace/stbi-impl.cc create mode 100644 3rdparty/tinygltf/examples/raytrace/viwewer.make create mode 100644 3rdparty/tinygltf/examples/saver/Makefile.dev create mode 100644 3rdparty/tinygltf/examples/saver/README.md create mode 100644 3rdparty/tinygltf/examples/saver/main.cc create mode 100644 3rdparty/tinygltf/examples/validator/CMakeLists.txt create mode 100644 3rdparty/tinygltf/examples/validator/LICENSE.json-schema-validator.MIT create mode 100644 3rdparty/tinygltf/examples/validator/LICENSE.jsonhpp.MIT create mode 100644 3rdparty/tinygltf/examples/validator/README.md create mode 100644 3rdparty/tinygltf/examples/validator/app/tinygltf-validate.cc create mode 100644 3rdparty/tinygltf/examples/validator/src/json-schema-draft4.json.cpp create mode 100644 3rdparty/tinygltf/examples/validator/src/json-schema.hpp create mode 100644 3rdparty/tinygltf/examples/validator/src/json-uri.cpp create mode 100644 3rdparty/tinygltf/examples/validator/src/json-validator.cpp create mode 100644 3rdparty/tinygltf/examples/validator/src/json.hpp create mode 100644 3rdparty/tinygltf/json.hpp create mode 100644 3rdparty/tinygltf/loader_example.cc create mode 100644 3rdparty/tinygltf/models/Cube/Cube.bin create mode 100644 3rdparty/tinygltf/models/Cube/Cube.gltf create mode 100644 3rdparty/tinygltf/models/Cube/Cube_BaseColor.png create mode 100644 3rdparty/tinygltf/models/Cube/Cube_MetallicRoughness.png create mode 100644 3rdparty/tinygltf/models/Cube/README.md create mode 100644 3rdparty/tinygltf/premake5.lua create mode 100644 3rdparty/tinygltf/stb_image.h create mode 100644 3rdparty/tinygltf/test_runner.py create mode 100644 3rdparty/tinygltf/tests/catch.hpp create mode 100644 3rdparty/tinygltf/tests/tester.cc create mode 100644 3rdparty/tinygltf/tiny_gltf.h create mode 100644 3rdparty/tinygltf/vcsetup.bat diff --git a/3rdparty/tinygltf/.clang-format b/3rdparty/tinygltf/.clang-format new file mode 100644 index 0000000..74210b0 --- /dev/null +++ b/3rdparty/tinygltf/.clang-format @@ -0,0 +1,7 @@ +--- +BasedOnStyle: Google +IndentWidth: 2 +TabWidth: 2 +UseTab: Never +BreakBeforeBraces: Attach +Standard: Cpp03 diff --git a/3rdparty/tinygltf/.gitignore b/3rdparty/tinygltf/.gitignore new file mode 100644 index 0000000..9234d82 --- /dev/null +++ b/3rdparty/tinygltf/.gitignore @@ -0,0 +1,70 @@ +# CMake +CMakeCache.txt +CMakeFiles +CMakeScripts +Testing +Makefile +cmake_install.cmake +install_manifest.txt +compile_commands.json +CTestTestfile.cmake + +#Files created by the CI scripts (downloading and installing premake) +premake5 +premake5.tar.gz + +#built examples +/examples/raytrace/bin/ + +#visual studio files +*.sln +*.vcxproj* +.vs + +#binary directories +bin/ +obj/ + +#runtime gui config +imgui.ini + +#visual stuido code +.vscode + +# Prerequisites +*.d + +# Compiled Object files +*.slo +*.lo +*.o +*.obj + +# Precompiled Headers +*.gch +*.pch + +# Compiled Dynamic libraries +*.so +*.dylib +*.dll + +# Fortran module files +*.mod +*.smod + +# Compiled Static libraries +*.lai +*.la +*.a +*.lib + +# Executables +*.exe +*.out +*.app + +loader_example +tests/tester +tests/tester_noexcept + diff --git a/3rdparty/tinygltf/.travis-before-install.sh b/3rdparty/tinygltf/.travis-before-install.sh new file mode 100755 index 0000000..ea6615a --- /dev/null +++ b/3rdparty/tinygltf/.travis-before-install.sh @@ -0,0 +1,10 @@ +#!/bin/bash + +if [[ "$TRAVIS_OS_NAME" == "osx" ]] +then + brew upgrade + curl -o premake5.tar.gz https://github.com/premake/premake-core/releases/download/v5.0.0-alpha12/premake-5.0.0-alpha12-macosx.tar.gz +else + wget https://github.com/premake/premake-core/releases/download/v5.0.0-alpha12/premake-5.0.0-alpha12-linux.tar.gz -O premake5.tar.gz +fi +tar xzf premake5.tar.gz diff --git a/3rdparty/tinygltf/.travis.yml b/3rdparty/tinygltf/.travis.yml new file mode 100644 index 0000000..6e731e5 --- /dev/null +++ b/3rdparty/tinygltf/.travis.yml @@ -0,0 +1,47 @@ +language: cpp +sudo: false +matrix: + include: + - addons: &1 + apt: + sources: + - george-edison55-precise-backports + - ubuntu-toolchain-r-test + - llvm-toolchain-precise-3.7 + packages: + - g++-4.9 + - clang-3.7 + compiler: clang + env: COMPILER_VERSION=3.7 BUILD_TYPE=Debug + - addons: *1 + compiler: clang + env: COMPILER_VERSION=3.7 BUILD_TYPE=Release + - addons: &2 + apt: + sources: + - george-edison55-precise-backports + - ubuntu-toolchain-r-test + packages: + - g++-4.9 + compiler: gcc + env: COMPILER_VERSION=4.9 BUILD_TYPE=Debug EXTRA_CXXFLAGS="-fsanitize=address" + - addons: *2 + compiler: gcc + env: COMPILER_VERSION=4.9 BUILD_TYPE=Release EXTRA_CXXFLAGS="-fsanitize=address" + - addons: *1 + compiler: clang + env: COMPILER_VERSION=3.7 BUILD_TYPE=Debug CFLAGS="-O0" CXXFLAGS="-O0" + +before_install: + - ./.travis-before-install.sh + + +script: + - export CC="${CC}-${COMPILER_VERSION}" + - export CXX="${CXX}-${COMPILER_VERSION}" + - ${CC} -v + - ${CXX} ${EXTRA_CXXFLAGS} -std=c++11 -Wall -g -o loader_example loader_example.cc + - ./loader_example ./models/Cube/Cube.gltf + - cd examples/raytrace + - ../../premake5 gmake + - make diff --git a/3rdparty/tinygltf/LICENSE b/3rdparty/tinygltf/LICENSE new file mode 100644 index 0000000..34398ad --- /dev/null +++ b/3rdparty/tinygltf/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 Syoyo Fujita, Aurélien Chatelain and many contributors + +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. diff --git a/3rdparty/tinygltf/README.md b/3rdparty/tinygltf/README.md new file mode 100644 index 0000000..f8f135b --- /dev/null +++ b/3rdparty/tinygltf/README.md @@ -0,0 +1,140 @@ +# Header only C++ tiny glTF library(loader/saver). + +`TinyGLTF` is a header only C++11 glTF 2.0 https://github.com/KhronosGroup/glTF library. + +## Status + +Work in process(`devel` branch). Very near to release, but need more tests and examples. + +`TinyGLTF` uses Niels Lohmann's json library(https://github.com/nlohmann/json), so now it requires C++11 compiler. +If you are looking for old, C++03 version, please use `devel-picojson` branch. + +## Builds + +[![Build Status](https://travis-ci.org/syoyo/tinygltf.svg?branch=devel)](https://travis-ci.org/syoyo/tinygltf) + +[![Build status](https://ci.appveyor.com/api/projects/status/warngenu9wjjhlm8?svg=true)](https://ci.appveyor.com/project/syoyo/tinygltf) + +## Features + +* Written in portable C++. C++-11 with STL dependency only. + * [x] macOS + clang(LLVM) + * [x] iOS + clang + * [x] Linux + gcc/clang + * [x] Windows + MinGW + * [x] Windows + Visual Studio 2015 or later. + * Visual Studio 2013 is not supported since they have limited C++11 support and failed to compile `json.hpp`. + * [x] Android + CrystaX(NDK drop-in replacement) GCC + * [x] Web using Emscripten(LLVM) +* Moderate parsing time and memory consumption. +* glTF specification v2.0.0 + * [x] ASCII glTF + * [x] Binary glTF(GLB) + * [x] PBR material description +* Buffers + * [x] Parse BASE64 encoded embedded buffer fata(DataURI). + * [x] Load `.bin` file. +* Image(Using stb_image) + * [x] Parse BASE64 encoded embedded image fata(DataURI). + * [x] Load external image file. + * [x] PNG(8bit only) + * [x] JPEG(8bit only) + * [x] BMP + * [x] GIF + +## Examples + +* [glview](examples/glview) : Simple glTF geometry viewer. +* [validator](examples/validator) : Simple glTF validator with JSON schema. + +## TODOs + +* [ ] Write C++ code generator from json schema for robust parsing. +* [x] Serialization +* [ ] Compression/decompression(Open3DGC, etc) +* [ ] Support `extensions` and `extras` property +* [ ] HDR image? +* [ ] Write tests for `animation` and `skin` + +## Licenses + +TinyGLTF is licensed under MIT license. + +TinyGLTF uses the following third party libraries. + +* json.hpp : Copyright (c) 2013-2017 Niels Lohmann. MIT license. +* base64 : Copyright (C) 2004-2008 René Nyffenegger +* stb_image.h : v2.08 - public domain image loader - http://nothings.org/stb_image.h + + +## Build and example + +Copy `stb_image.h`, `json.hpp` and `tiny_gltf.h` to your project. + +### Loading glTF 2.0 model + +```c++ +// Define these only in *one* .cc file. +#define TINYGLTF_IMPLEMENTATION +#define STB_IMAGE_IMPLEMENTATION +// #define TINYGLTF_NOEXCEPTION // optional. disable exception handling. +#include "tiny_gltf.h" + +using namespace tinygltf; + +Model model; +TinyGLTF loader; +std::string err; + +bool ret = loader.LoadASCIIFromFile(&model, &err, argv[1]); +//bool ret = loader.LoadBinaryFromFile(&model, &err, argv[1]); // for binary glTF(.glb) +if (!err.empty()) { + printf("Err: %s\n", err.c_str()); +} + +if (!ret) { + printf("Failed to parse glTF\n"); + return -1; +} +``` + +## Compile options + +* `TINYGLTF_NOEXCEPTION` : Disable C++ exception in JSON parsing. You can use `-fno-exceptions` or by defining the symbol `JSON_NOEXCEPTION` and `TINYGLTF_NOEXCEPTION` to fully remove C++ exception codes when compiling TinyGLTF. +* `TINYGLTF_NO_STB_IMAGE` : Do not load images with stb_image. Instead use `TinyGLTF::SetImageLoader(LoadimageDataFunction LoadImageData, void *user_data)` to set a callback for loading images. + +### Saving gltTF 2.0 model + +T.B.W. + +## Running tests. + +### glTF parsing test + +#### Setup + +Python 2.6 or 2.7 required. +Git clone https://github.com/KhronosGroup/glTF-Sample-Models to your local dir. + +#### Run parsing test + +After building `loader_example`, edit `test_runner.py`, then, + +```bash +$ python test_runner.py +``` + +### Unit tests + +```bash +$ cd tests +$ make +$ ./tester +$ ./tester_noexcept +``` + +## Third party licenses + +* json.hpp : Licensed under the MIT License . Copyright (c) 2013-2017 Niels Lohmann . +* stb_image : Public domain. +* catch : Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved. Distributed under the Boost Software License, Version 1.0. diff --git a/3rdparty/tinygltf/appveyor.yml b/3rdparty/tinygltf/appveyor.yml new file mode 100644 index 0000000..545253e --- /dev/null +++ b/3rdparty/tinygltf/appveyor.yml @@ -0,0 +1,18 @@ +version: 0.9.{build} + +image: + - Visual Studio 2015 + +# scripts that runs after repo cloning. +install: + - vcsetup.bat + +platform: x64 +configuration: Release + +build: + parallel: true + project: TinyGLTFSolution.sln + +after_build: + - examples.bat diff --git a/3rdparty/tinygltf/deps/cpplint.py b/3rdparty/tinygltf/deps/cpplint.py new file mode 100755 index 0000000..ccc25d4 --- /dev/null +++ b/3rdparty/tinygltf/deps/cpplint.py @@ -0,0 +1,6323 @@ +#!/usr/bin/env python +# +# Copyright (c) 2009 Google Inc. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +"""Does google-lint on c++ files. + +The goal of this script is to identify places in the code that *may* +be in non-compliance with google style. It does not attempt to fix +up these problems -- the point is to educate. It does also not +attempt to find all problems, or to ensure that everything it does +find is legitimately a problem. + +In particular, we can get very confused by /* and // inside strings! +We do a small hack, which is to ignore //'s with "'s after them on the +same line, but it is far from perfect (in either direction). +""" + +import codecs +import copy +import getopt +import math # for log +import os +import re +import sre_compile +import string +import sys +import unicodedata + + +_USAGE = """ +Syntax: cpplint.py [--verbose=#] [--output=vs7] [--filter=-x,+y,...] + [--counting=total|toplevel|detailed] [--root=subdir] + [--linelength=digits] + [file] ... + + The style guidelines this tries to follow are those in + http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml + + Every problem is given a confidence score from 1-5, with 5 meaning we are + certain of the problem, and 1 meaning it could be a legitimate construct. + This will miss some errors, and is not a substitute for a code review. + + To suppress false-positive errors of a certain category, add a + 'NOLINT(category)' comment to the line. NOLINT or NOLINT(*) + suppresses errors of all categories on that line. + + The files passed in will be linted; at least one file must be provided. + Default linted extensions are .cc, .cpp, .cu, .cuh and .h. Change the + extensions with the --extensions flag. + + Flags: + + output=vs7 + By default, the output is formatted to ease emacs parsing. Visual Studio + compatible output (vs7) may also be used. Other formats are unsupported. + + verbose=# + Specify a number 0-5 to restrict errors to certain verbosity levels. + + filter=-x,+y,... + Specify a comma-separated list of category-filters to apply: only + error messages whose category names pass the filters will be printed. + (Category names are printed with the message and look like + "[whitespace/indent]".) Filters are evaluated left to right. + "-FOO" and "FOO" means "do not print categories that start with FOO". + "+FOO" means "do print categories that start with FOO". + + Examples: --filter=-whitespace,+whitespace/braces + --filter=whitespace,runtime/printf,+runtime/printf_format + --filter=-,+build/include_what_you_use + + To see a list of all the categories used in cpplint, pass no arg: + --filter= + + counting=total|toplevel|detailed + The total number of errors found is always printed. If + 'toplevel' is provided, then the count of errors in each of + the top-level categories like 'build' and 'whitespace' will + also be printed. If 'detailed' is provided, then a count + is provided for each category like 'build/class'. + + root=subdir + The root directory used for deriving header guard CPP variable. + By default, the header guard CPP variable is calculated as the relative + path to the directory that contains .git, .hg, or .svn. When this flag + is specified, the relative path is calculated from the specified + directory. If the specified directory does not exist, this flag is + ignored. + + Examples: + Assuming that src/.git exists, the header guard CPP variables for + src/chrome/browser/ui/browser.h are: + + No flag => CHROME_BROWSER_UI_BROWSER_H_ + --root=chrome => BROWSER_UI_BROWSER_H_ + --root=chrome/browser => UI_BROWSER_H_ + + linelength=digits + This is the allowed line length for the project. The default value is + 80 characters. + + Examples: + --linelength=120 + + extensions=extension,extension,... + The allowed file extensions that cpplint will check + + Examples: + --extensions=hpp,cpp + + cpplint.py supports per-directory configurations specified in CPPLINT.cfg + files. CPPLINT.cfg file can contain a number of key=value pairs. + Currently the following options are supported: + + set noparent + filter=+filter1,-filter2,... + exclude_files=regex + linelength=80 + + "set noparent" option prevents cpplint from traversing directory tree + upwards looking for more .cfg files in parent directories. This option + is usually placed in the top-level project directory. + + The "filter" option is similar in function to --filter flag. It specifies + message filters in addition to the |_DEFAULT_FILTERS| and those specified + through --filter command-line flag. + + "exclude_files" allows to specify a regular expression to be matched against + a file name. If the expression matches, the file is skipped and not run + through liner. + + "linelength" allows to specify the allowed line length for the project. + + CPPLINT.cfg has an effect on files in the same directory and all + sub-directories, unless overridden by a nested configuration file. + + Example file: + filter=-build/include_order,+build/include_alpha + exclude_files=.*\.cc + + The above example disables build/include_order warning and enables + build/include_alpha as well as excludes all .cc from being + processed by linter, in the current directory (where the .cfg + file is located) and all sub-directories. +""" + +# We categorize each error message we print. Here are the categories. +# We want an explicit list so we can list them all in cpplint --filter=. +# If you add a new error message with a new category, add it to the list +# here! cpplint_unittest.py should tell you if you forget to do this. +_ERROR_CATEGORIES = [ + 'build/class', + 'build/c++11', + 'build/deprecated', + 'build/endif_comment', + 'build/explicit_make_pair', + 'build/forward_decl', + 'build/header_guard', + 'build/include', + 'build/include_alpha', + 'build/include_order', + 'build/include_what_you_use', + 'build/namespaces', + 'build/printf_format', + 'build/storage_class', + 'legal/copyright', + 'readability/alt_tokens', + 'readability/braces', + 'readability/casting', + 'readability/check', + 'readability/constructors', + 'readability/fn_size', + 'readability/function', + 'readability/inheritance', + 'readability/multiline_comment', + 'readability/multiline_string', + 'readability/namespace', + 'readability/nolint', + 'readability/nul', + 'readability/strings', + 'readability/todo', + 'readability/utf8', + 'runtime/arrays', + 'runtime/casting', + 'runtime/explicit', + 'runtime/int', + 'runtime/init', + 'runtime/invalid_increment', + 'runtime/member_string_references', + 'runtime/memset', + 'runtime/indentation_namespace', + 'runtime/operator', + 'runtime/printf', + 'runtime/printf_format', + 'runtime/references', + 'runtime/string', + 'runtime/threadsafe_fn', + 'runtime/vlog', + 'whitespace/blank_line', + 'whitespace/braces', + 'whitespace/comma', + 'whitespace/comments', + 'whitespace/empty_conditional_body', + 'whitespace/empty_loop_body', + 'whitespace/end_of_line', + 'whitespace/ending_newline', + 'whitespace/forcolon', + 'whitespace/indent', + 'whitespace/line_length', + 'whitespace/newline', + 'whitespace/operators', + 'whitespace/parens', + 'whitespace/semicolon', + 'whitespace/tab', + 'whitespace/todo', + ] + +# These error categories are no longer enforced by cpplint, but for backwards- +# compatibility they may still appear in NOLINT comments. +_LEGACY_ERROR_CATEGORIES = [ + 'readability/streams', + ] + +# The default state of the category filter. This is overridden by the --filter= +# flag. By default all errors are on, so only add here categories that should be +# off by default (i.e., categories that must be enabled by the --filter= flags). +# All entries here should start with a '-' or '+', as in the --filter= flag. +_DEFAULT_FILTERS = ['-build/include_alpha'] + +# We used to check for high-bit characters, but after much discussion we +# decided those were OK, as long as they were in UTF-8 and didn't represent +# hard-coded international strings, which belong in a separate i18n file. + +# C++ headers +_CPP_HEADERS = frozenset([ + # Legacy + 'algobase.h', + 'algo.h', + 'alloc.h', + 'builtinbuf.h', + 'bvector.h', + 'complex.h', + 'defalloc.h', + 'deque.h', + 'editbuf.h', + 'fstream.h', + 'function.h', + 'hash_map', + 'hash_map.h', + 'hash_set', + 'hash_set.h', + 'hashtable.h', + 'heap.h', + 'indstream.h', + 'iomanip.h', + 'iostream.h', + 'istream.h', + 'iterator.h', + 'list.h', + 'map.h', + 'multimap.h', + 'multiset.h', + 'ostream.h', + 'pair.h', + 'parsestream.h', + 'pfstream.h', + 'procbuf.h', + 'pthread_alloc', + 'pthread_alloc.h', + 'rope', + 'rope.h', + 'ropeimpl.h', + 'set.h', + 'slist', + 'slist.h', + 'stack.h', + 'stdiostream.h', + 'stl_alloc.h', + 'stl_relops.h', + 'streambuf.h', + 'stream.h', + 'strfile.h', + 'strstream.h', + 'tempbuf.h', + 'tree.h', + 'type_traits.h', + 'vector.h', + # 17.6.1.2 C++ library headers + 'algorithm', + 'array', + 'atomic', + 'bitset', + 'chrono', + 'codecvt', + 'complex', + 'condition_variable', + 'deque', + 'exception', + 'forward_list', + 'fstream', + 'functional', + 'future', + 'initializer_list', + 'iomanip', + 'ios', + 'iosfwd', + 'iostream', + 'istream', + 'iterator', + 'limits', + 'list', + 'locale', + 'map', + 'memory', + 'mutex', + 'new', + 'numeric', + 'ostream', + 'queue', + 'random', + 'ratio', + 'regex', + 'set', + 'sstream', + 'stack', + 'stdexcept', + 'streambuf', + 'string', + 'strstream', + 'system_error', + 'thread', + 'tuple', + 'typeindex', + 'typeinfo', + 'type_traits', + 'unordered_map', + 'unordered_set', + 'utility', + 'valarray', + 'vector', + # 17.6.1.2 C++ headers for C library facilities + 'cassert', + 'ccomplex', + 'cctype', + 'cerrno', + 'cfenv', + 'cfloat', + 'cinttypes', + 'ciso646', + 'climits', + 'clocale', + 'cmath', + 'csetjmp', + 'csignal', + 'cstdalign', + 'cstdarg', + 'cstdbool', + 'cstddef', + 'cstdint', + 'cstdio', + 'cstdlib', + 'cstring', + 'ctgmath', + 'ctime', + 'cuchar', + 'cwchar', + 'cwctype', + ]) + + +# These headers are excluded from [build/include] and [build/include_order] +# checks: +# - Anything not following google file name conventions (containing an +# uppercase character, such as Python.h or nsStringAPI.h, for example). +# - Lua headers. +_THIRD_PARTY_HEADERS_PATTERN = re.compile( + r'^(?:[^/]*[A-Z][^/]*\.h|lua\.h|lauxlib\.h|lualib\.h)$') + + +# Assertion macros. These are defined in base/logging.h and +# testing/base/gunit.h. Note that the _M versions need to come first +# for substring matching to work. +_CHECK_MACROS = [ + 'DCHECK', 'CHECK', + 'EXPECT_TRUE_M', 'EXPECT_TRUE', + 'ASSERT_TRUE_M', 'ASSERT_TRUE', + 'EXPECT_FALSE_M', 'EXPECT_FALSE', + 'ASSERT_FALSE_M', 'ASSERT_FALSE', + ] + +# Replacement macros for CHECK/DCHECK/EXPECT_TRUE/EXPECT_FALSE +_CHECK_REPLACEMENT = dict([(m, {}) for m in _CHECK_MACROS]) + +for op, replacement in [('==', 'EQ'), ('!=', 'NE'), + ('>=', 'GE'), ('>', 'GT'), + ('<=', 'LE'), ('<', 'LT')]: + _CHECK_REPLACEMENT['DCHECK'][op] = 'DCHECK_%s' % replacement + _CHECK_REPLACEMENT['CHECK'][op] = 'CHECK_%s' % replacement + _CHECK_REPLACEMENT['EXPECT_TRUE'][op] = 'EXPECT_%s' % replacement + _CHECK_REPLACEMENT['ASSERT_TRUE'][op] = 'ASSERT_%s' % replacement + _CHECK_REPLACEMENT['EXPECT_TRUE_M'][op] = 'EXPECT_%s_M' % replacement + _CHECK_REPLACEMENT['ASSERT_TRUE_M'][op] = 'ASSERT_%s_M' % replacement + +for op, inv_replacement in [('==', 'NE'), ('!=', 'EQ'), + ('>=', 'LT'), ('>', 'LE'), + ('<=', 'GT'), ('<', 'GE')]: + _CHECK_REPLACEMENT['EXPECT_FALSE'][op] = 'EXPECT_%s' % inv_replacement + _CHECK_REPLACEMENT['ASSERT_FALSE'][op] = 'ASSERT_%s' % inv_replacement + _CHECK_REPLACEMENT['EXPECT_FALSE_M'][op] = 'EXPECT_%s_M' % inv_replacement + _CHECK_REPLACEMENT['ASSERT_FALSE_M'][op] = 'ASSERT_%s_M' % inv_replacement + +# Alternative tokens and their replacements. For full list, see section 2.5 +# Alternative tokens [lex.digraph] in the C++ standard. +# +# Digraphs (such as '%:') are not included here since it's a mess to +# match those on a word boundary. +_ALT_TOKEN_REPLACEMENT = { + 'and': '&&', + 'bitor': '|', + 'or': '||', + 'xor': '^', + 'compl': '~', + 'bitand': '&', + 'and_eq': '&=', + 'or_eq': '|=', + 'xor_eq': '^=', + 'not': '!', + 'not_eq': '!=' + } + +# Compile regular expression that matches all the above keywords. The "[ =()]" +# bit is meant to avoid matching these keywords outside of boolean expressions. +# +# False positives include C-style multi-line comments and multi-line strings +# but those have always been troublesome for cpplint. +_ALT_TOKEN_REPLACEMENT_PATTERN = re.compile( + r'[ =()](' + ('|'.join(_ALT_TOKEN_REPLACEMENT.keys())) + r')(?=[ (]|$)') + + +# These constants define types of headers for use with +# _IncludeState.CheckNextIncludeOrder(). +_C_SYS_HEADER = 1 +_CPP_SYS_HEADER = 2 +_LIKELY_MY_HEADER = 3 +_POSSIBLE_MY_HEADER = 4 +_OTHER_HEADER = 5 + +# These constants define the current inline assembly state +_NO_ASM = 0 # Outside of inline assembly block +_INSIDE_ASM = 1 # Inside inline assembly block +_END_ASM = 2 # Last line of inline assembly block +_BLOCK_ASM = 3 # The whole block is an inline assembly block + +# Match start of assembly blocks +_MATCH_ASM = re.compile(r'^\s*(?:asm|_asm|__asm|__asm__)' + r'(?:\s+(volatile|__volatile__))?' + r'\s*[{(]') + + +_regexp_compile_cache = {} + +# {str, set(int)}: a map from error categories to sets of linenumbers +# on which those errors are expected and should be suppressed. +_error_suppressions = {} + +# The root directory used for deriving header guard CPP variable. +# This is set by --root flag. +_root = None + +# The allowed line length of files. +# This is set by --linelength flag. +_line_length = 80 + +# The allowed extensions for file names +# This is set by --extensions flag. +_valid_extensions = set(['cc', 'h', 'cpp', 'cu', 'cuh']) + +def ParseNolintSuppressions(filename, raw_line, linenum, error): + """Updates the global list of error-suppressions. + + Parses any NOLINT comments on the current line, updating the global + error_suppressions store. Reports an error if the NOLINT comment + was malformed. + + Args: + filename: str, the name of the input file. + raw_line: str, the line of input text, with comments. + linenum: int, the number of the current line. + error: function, an error handler. + """ + matched = Search(r'\bNOLINT(NEXTLINE)?\b(\([^)]+\))?', raw_line) + if matched: + if matched.group(1): + suppressed_line = linenum + 1 + else: + suppressed_line = linenum + category = matched.group(2) + if category in (None, '(*)'): # => "suppress all" + _error_suppressions.setdefault(None, set()).add(suppressed_line) + else: + if category.startswith('(') and category.endswith(')'): + category = category[1:-1] + if category in _ERROR_CATEGORIES: + _error_suppressions.setdefault(category, set()).add(suppressed_line) + elif category not in _LEGACY_ERROR_CATEGORIES: + error(filename, linenum, 'readability/nolint', 5, + 'Unknown NOLINT error category: %s' % category) + + +def ResetNolintSuppressions(): + """Resets the set of NOLINT suppressions to empty.""" + _error_suppressions.clear() + + +def IsErrorSuppressedByNolint(category, linenum): + """Returns true if the specified error category is suppressed on this line. + + Consults the global error_suppressions map populated by + ParseNolintSuppressions/ResetNolintSuppressions. + + Args: + category: str, the category of the error. + linenum: int, the current line number. + Returns: + bool, True iff the error should be suppressed due to a NOLINT comment. + """ + return (linenum in _error_suppressions.get(category, set()) or + linenum in _error_suppressions.get(None, set())) + + +def Match(pattern, s): + """Matches the string with the pattern, caching the compiled regexp.""" + # The regexp compilation caching is inlined in both Match and Search for + # performance reasons; factoring it out into a separate function turns out + # to be noticeably expensive. + if pattern not in _regexp_compile_cache: + _regexp_compile_cache[pattern] = sre_compile.compile(pattern) + return _regexp_compile_cache[pattern].match(s) + + +def ReplaceAll(pattern, rep, s): + """Replaces instances of pattern in a string with a replacement. + + The compiled regex is kept in a cache shared by Match and Search. + + Args: + pattern: regex pattern + rep: replacement text + s: search string + + Returns: + string with replacements made (or original string if no replacements) + """ + if pattern not in _regexp_compile_cache: + _regexp_compile_cache[pattern] = sre_compile.compile(pattern) + return _regexp_compile_cache[pattern].sub(rep, s) + + +def Search(pattern, s): + """Searches the string for the pattern, caching the compiled regexp.""" + if pattern not in _regexp_compile_cache: + _regexp_compile_cache[pattern] = sre_compile.compile(pattern) + return _regexp_compile_cache[pattern].search(s) + + +class _IncludeState(object): + """Tracks line numbers for includes, and the order in which includes appear. + + include_list contains list of lists of (header, line number) pairs. + It's a lists of lists rather than just one flat list to make it + easier to update across preprocessor boundaries. + + Call CheckNextIncludeOrder() once for each header in the file, passing + in the type constants defined above. Calls in an illegal order will + raise an _IncludeError with an appropriate error message. + + """ + # self._section will move monotonically through this set. If it ever + # needs to move backwards, CheckNextIncludeOrder will raise an error. + _INITIAL_SECTION = 0 + _MY_H_SECTION = 1 + _C_SECTION = 2 + _CPP_SECTION = 3 + _OTHER_H_SECTION = 4 + + _TYPE_NAMES = { + _C_SYS_HEADER: 'C system header', + _CPP_SYS_HEADER: 'C++ system header', + _LIKELY_MY_HEADER: 'header this file implements', + _POSSIBLE_MY_HEADER: 'header this file may implement', + _OTHER_HEADER: 'other header', + } + _SECTION_NAMES = { + _INITIAL_SECTION: "... nothing. (This can't be an error.)", + _MY_H_SECTION: 'a header this file implements', + _C_SECTION: 'C system header', + _CPP_SECTION: 'C++ system header', + _OTHER_H_SECTION: 'other header', + } + + def __init__(self): + self.include_list = [[]] + self.ResetSection('') + + def FindHeader(self, header): + """Check if a header has already been included. + + Args: + header: header to check. + Returns: + Line number of previous occurrence, or -1 if the header has not + been seen before. + """ + for section_list in self.include_list: + for f in section_list: + if f[0] == header: + return f[1] + return -1 + + def ResetSection(self, directive): + """Reset section checking for preprocessor directive. + + Args: + directive: preprocessor directive (e.g. "if", "else"). + """ + # The name of the current section. + self._section = self._INITIAL_SECTION + # The path of last found header. + self._last_header = '' + + # Update list of includes. Note that we never pop from the + # include list. + if directive in ('if', 'ifdef', 'ifndef'): + self.include_list.append([]) + elif directive in ('else', 'elif'): + self.include_list[-1] = [] + + def SetLastHeader(self, header_path): + self._last_header = header_path + + def CanonicalizeAlphabeticalOrder(self, header_path): + """Returns a path canonicalized for alphabetical comparison. + + - replaces "-" with "_" so they both cmp the same. + - removes '-inl' since we don't require them to be after the main header. + - lowercase everything, just in case. + + Args: + header_path: Path to be canonicalized. + + Returns: + Canonicalized path. + """ + return header_path.replace('-inl.h', '.h').replace('-', '_').lower() + + def IsInAlphabeticalOrder(self, clean_lines, linenum, header_path): + """Check if a header is in alphabetical order with the previous header. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + header_path: Canonicalized header to be checked. + + Returns: + Returns true if the header is in alphabetical order. + """ + # If previous section is different from current section, _last_header will + # be reset to empty string, so it's always less than current header. + # + # If previous line was a blank line, assume that the headers are + # intentionally sorted the way they are. + if (self._last_header > header_path and + Match(r'^\s*#\s*include\b', clean_lines.elided[linenum - 1])): + return False + return True + + def CheckNextIncludeOrder(self, header_type): + """Returns a non-empty error message if the next header is out of order. + + This function also updates the internal state to be ready to check + the next include. + + Args: + header_type: One of the _XXX_HEADER constants defined above. + + Returns: + The empty string if the header is in the right order, or an + error message describing what's wrong. + + """ + error_message = ('Found %s after %s' % + (self._TYPE_NAMES[header_type], + self._SECTION_NAMES[self._section])) + + last_section = self._section + + if header_type == _C_SYS_HEADER: + if self._section <= self._C_SECTION: + self._section = self._C_SECTION + else: + self._last_header = '' + return error_message + elif header_type == _CPP_SYS_HEADER: + if self._section <= self._CPP_SECTION: + self._section = self._CPP_SECTION + else: + self._last_header = '' + return error_message + elif header_type == _LIKELY_MY_HEADER: + if self._section <= self._MY_H_SECTION: + self._section = self._MY_H_SECTION + else: + self._section = self._OTHER_H_SECTION + elif header_type == _POSSIBLE_MY_HEADER: + if self._section <= self._MY_H_SECTION: + self._section = self._MY_H_SECTION + else: + # This will always be the fallback because we're not sure + # enough that the header is associated with this file. + self._section = self._OTHER_H_SECTION + else: + assert header_type == _OTHER_HEADER + self._section = self._OTHER_H_SECTION + + if last_section != self._section: + self._last_header = '' + + return '' + + +class _CppLintState(object): + """Maintains module-wide state..""" + + def __init__(self): + self.verbose_level = 1 # global setting. + self.error_count = 0 # global count of reported errors + # filters to apply when emitting error messages + self.filters = _DEFAULT_FILTERS[:] + # backup of filter list. Used to restore the state after each file. + self._filters_backup = self.filters[:] + self.counting = 'total' # In what way are we counting errors? + self.errors_by_category = {} # string to int dict storing error counts + + # output format: + # "emacs" - format that emacs can parse (default) + # "vs7" - format that Microsoft Visual Studio 7 can parse + self.output_format = 'emacs' + + def SetOutputFormat(self, output_format): + """Sets the output format for errors.""" + self.output_format = output_format + + def SetVerboseLevel(self, level): + """Sets the module's verbosity, and returns the previous setting.""" + last_verbose_level = self.verbose_level + self.verbose_level = level + return last_verbose_level + + def SetCountingStyle(self, counting_style): + """Sets the module's counting options.""" + self.counting = counting_style + + def SetFilters(self, filters): + """Sets the error-message filters. + + These filters are applied when deciding whether to emit a given + error message. + + Args: + filters: A string of comma-separated filters (eg "+whitespace/indent"). + Each filter should start with + or -; else we die. + + Raises: + ValueError: The comma-separated filters did not all start with '+' or '-'. + E.g. "-,+whitespace,-whitespace/indent,whitespace/badfilter" + """ + # Default filters always have less priority than the flag ones. + self.filters = _DEFAULT_FILTERS[:] + self.AddFilters(filters) + + def AddFilters(self, filters): + """ Adds more filters to the existing list of error-message filters. """ + for filt in filters.split(','): + clean_filt = filt.strip() + if clean_filt: + self.filters.append(clean_filt) + for filt in self.filters: + if not (filt.startswith('+') or filt.startswith('-')): + raise ValueError('Every filter in --filters must start with + or -' + ' (%s does not)' % filt) + + def BackupFilters(self): + """ Saves the current filter list to backup storage.""" + self._filters_backup = self.filters[:] + + def RestoreFilters(self): + """ Restores filters previously backed up.""" + self.filters = self._filters_backup[:] + + def ResetErrorCounts(self): + """Sets the module's error statistic back to zero.""" + self.error_count = 0 + self.errors_by_category = {} + + def IncrementErrorCount(self, category): + """Bumps the module's error statistic.""" + self.error_count += 1 + if self.counting in ('toplevel', 'detailed'): + if self.counting != 'detailed': + category = category.split('/')[0] + if category not in self.errors_by_category: + self.errors_by_category[category] = 0 + self.errors_by_category[category] += 1 + + def PrintErrorCounts(self): + """Print a summary of errors by category, and the total.""" + for category, count in self.errors_by_category.iteritems(): + sys.stderr.write('Category \'%s\' errors found: %d\n' % + (category, count)) + sys.stderr.write('Total errors found: %d\n' % self.error_count) + +_cpplint_state = _CppLintState() + + +def _OutputFormat(): + """Gets the module's output format.""" + return _cpplint_state.output_format + + +def _SetOutputFormat(output_format): + """Sets the module's output format.""" + _cpplint_state.SetOutputFormat(output_format) + + +def _VerboseLevel(): + """Returns the module's verbosity setting.""" + return _cpplint_state.verbose_level + + +def _SetVerboseLevel(level): + """Sets the module's verbosity, and returns the previous setting.""" + return _cpplint_state.SetVerboseLevel(level) + + +def _SetCountingStyle(level): + """Sets the module's counting options.""" + _cpplint_state.SetCountingStyle(level) + + +def _Filters(): + """Returns the module's list of output filters, as a list.""" + return _cpplint_state.filters + + +def _SetFilters(filters): + """Sets the module's error-message filters. + + These filters are applied when deciding whether to emit a given + error message. + + Args: + filters: A string of comma-separated filters (eg "whitespace/indent"). + Each filter should start with + or -; else we die. + """ + _cpplint_state.SetFilters(filters) + +def _AddFilters(filters): + """Adds more filter overrides. + + Unlike _SetFilters, this function does not reset the current list of filters + available. + + Args: + filters: A string of comma-separated filters (eg "whitespace/indent"). + Each filter should start with + or -; else we die. + """ + _cpplint_state.AddFilters(filters) + +def _BackupFilters(): + """ Saves the current filter list to backup storage.""" + _cpplint_state.BackupFilters() + +def _RestoreFilters(): + """ Restores filters previously backed up.""" + _cpplint_state.RestoreFilters() + +class _FunctionState(object): + """Tracks current function name and the number of lines in its body.""" + + _NORMAL_TRIGGER = 250 # for --v=0, 500 for --v=1, etc. + _TEST_TRIGGER = 400 # about 50% more than _NORMAL_TRIGGER. + + def __init__(self): + self.in_a_function = False + self.lines_in_function = 0 + self.current_function = '' + + def Begin(self, function_name): + """Start analyzing function body. + + Args: + function_name: The name of the function being tracked. + """ + self.in_a_function = True + self.lines_in_function = 0 + self.current_function = function_name + + def Count(self): + """Count line in current function body.""" + if self.in_a_function: + self.lines_in_function += 1 + + def Check(self, error, filename, linenum): + """Report if too many lines in function body. + + Args: + error: The function to call with any errors found. + filename: The name of the current file. + linenum: The number of the line to check. + """ + if Match(r'T(EST|est)', self.current_function): + base_trigger = self._TEST_TRIGGER + else: + base_trigger = self._NORMAL_TRIGGER + trigger = base_trigger * 2**_VerboseLevel() + + if self.lines_in_function > trigger: + error_level = int(math.log(self.lines_in_function / base_trigger, 2)) + # 50 => 0, 100 => 1, 200 => 2, 400 => 3, 800 => 4, 1600 => 5, ... + if error_level > 5: + error_level = 5 + error(filename, linenum, 'readability/fn_size', error_level, + 'Small and focused functions are preferred:' + ' %s has %d non-comment lines' + ' (error triggered by exceeding %d lines).' % ( + self.current_function, self.lines_in_function, trigger)) + + def End(self): + """Stop analyzing function body.""" + self.in_a_function = False + + +class _IncludeError(Exception): + """Indicates a problem with the include order in a file.""" + pass + + +class FileInfo(object): + """Provides utility functions for filenames. + + FileInfo provides easy access to the components of a file's path + relative to the project root. + """ + + def __init__(self, filename): + self._filename = filename + + def FullName(self): + """Make Windows paths like Unix.""" + return os.path.abspath(self._filename).replace('\\', '/') + + def RepositoryName(self): + """FullName after removing the local path to the repository. + + If we have a real absolute path name here we can try to do something smart: + detecting the root of the checkout and truncating /path/to/checkout from + the name so that we get header guards that don't include things like + "C:\Documents and Settings\..." or "/home/username/..." in them and thus + people on different computers who have checked the source out to different + locations won't see bogus errors. + """ + fullname = self.FullName() + + if os.path.exists(fullname): + project_dir = os.path.dirname(fullname) + + if os.path.exists(os.path.join(project_dir, ".svn")): + # If there's a .svn file in the current directory, we recursively look + # up the directory tree for the top of the SVN checkout + root_dir = project_dir + one_up_dir = os.path.dirname(root_dir) + while os.path.exists(os.path.join(one_up_dir, ".svn")): + root_dir = os.path.dirname(root_dir) + one_up_dir = os.path.dirname(one_up_dir) + + prefix = os.path.commonprefix([root_dir, project_dir]) + return fullname[len(prefix) + 1:] + + # Not SVN <= 1.6? Try to find a git, hg, or svn top level directory by + # searching up from the current path. + root_dir = os.path.dirname(fullname) + while (root_dir != os.path.dirname(root_dir) and + not os.path.exists(os.path.join(root_dir, ".git")) and + not os.path.exists(os.path.join(root_dir, ".hg")) and + not os.path.exists(os.path.join(root_dir, ".svn"))): + root_dir = os.path.dirname(root_dir) + + if (os.path.exists(os.path.join(root_dir, ".git")) or + os.path.exists(os.path.join(root_dir, ".hg")) or + os.path.exists(os.path.join(root_dir, ".svn"))): + prefix = os.path.commonprefix([root_dir, project_dir]) + return fullname[len(prefix) + 1:] + + # Don't know what to do; header guard warnings may be wrong... + return fullname + + def Split(self): + """Splits the file into the directory, basename, and extension. + + For 'chrome/browser/browser.cc', Split() would + return ('chrome/browser', 'browser', '.cc') + + Returns: + A tuple of (directory, basename, extension). + """ + + googlename = self.RepositoryName() + project, rest = os.path.split(googlename) + return (project,) + os.path.splitext(rest) + + def BaseName(self): + """File base name - text after the final slash, before the final period.""" + return self.Split()[1] + + def Extension(self): + """File extension - text following the final period.""" + return self.Split()[2] + + def NoExtension(self): + """File has no source file extension.""" + return '/'.join(self.Split()[0:2]) + + def IsSource(self): + """File has a source file extension.""" + return self.Extension()[1:] in ('c', 'cc', 'cpp', 'cxx') + + +def _ShouldPrintError(category, confidence, linenum): + """If confidence >= verbose, category passes filter and is not suppressed.""" + + # There are three ways we might decide not to print an error message: + # a "NOLINT(category)" comment appears in the source, + # the verbosity level isn't high enough, or the filters filter it out. + if IsErrorSuppressedByNolint(category, linenum): + return False + + if confidence < _cpplint_state.verbose_level: + return False + + is_filtered = False + for one_filter in _Filters(): + if one_filter.startswith('-'): + if category.startswith(one_filter[1:]): + is_filtered = True + elif one_filter.startswith('+'): + if category.startswith(one_filter[1:]): + is_filtered = False + else: + assert False # should have been checked for in SetFilter. + if is_filtered: + return False + + return True + + +def Error(filename, linenum, category, confidence, message): + """Logs the fact we've found a lint error. + + We log where the error was found, and also our confidence in the error, + that is, how certain we are this is a legitimate style regression, and + not a misidentification or a use that's sometimes justified. + + False positives can be suppressed by the use of + "cpplint(category)" comments on the offending line. These are + parsed into _error_suppressions. + + Args: + filename: The name of the file containing the error. + linenum: The number of the line containing the error. + category: A string used to describe the "category" this bug + falls under: "whitespace", say, or "runtime". Categories + may have a hierarchy separated by slashes: "whitespace/indent". + confidence: A number from 1-5 representing a confidence score for + the error, with 5 meaning that we are certain of the problem, + and 1 meaning that it could be a legitimate construct. + message: The error message. + """ + if _ShouldPrintError(category, confidence, linenum): + _cpplint_state.IncrementErrorCount(category) + if _cpplint_state.output_format == 'vs7': + sys.stderr.write('%s(%s): %s [%s] [%d]\n' % ( + filename, linenum, message, category, confidence)) + elif _cpplint_state.output_format == 'eclipse': + sys.stderr.write('%s:%s: warning: %s [%s] [%d]\n' % ( + filename, linenum, message, category, confidence)) + else: + sys.stderr.write('%s:%s: %s [%s] [%d]\n' % ( + filename, linenum, message, category, confidence)) + + +# Matches standard C++ escape sequences per 2.13.2.3 of the C++ standard. +_RE_PATTERN_CLEANSE_LINE_ESCAPES = re.compile( + r'\\([abfnrtv?"\\\']|\d+|x[0-9a-fA-F]+)') +# Match a single C style comment on the same line. +_RE_PATTERN_C_COMMENTS = r'/\*(?:[^*]|\*(?!/))*\*/' +# Matches multi-line C style comments. +# This RE is a little bit more complicated than one might expect, because we +# have to take care of space removals tools so we can handle comments inside +# statements better. +# The current rule is: We only clear spaces from both sides when we're at the +# end of the line. Otherwise, we try to remove spaces from the right side, +# if this doesn't work we try on left side but only if there's a non-character +# on the right. +_RE_PATTERN_CLEANSE_LINE_C_COMMENTS = re.compile( + r'(\s*' + _RE_PATTERN_C_COMMENTS + r'\s*$|' + + _RE_PATTERN_C_COMMENTS + r'\s+|' + + r'\s+' + _RE_PATTERN_C_COMMENTS + r'(?=\W)|' + + _RE_PATTERN_C_COMMENTS + r')') + + +def IsCppString(line): + """Does line terminate so, that the next symbol is in string constant. + + This function does not consider single-line nor multi-line comments. + + Args: + line: is a partial line of code starting from the 0..n. + + Returns: + True, if next character appended to 'line' is inside a + string constant. + """ + + line = line.replace(r'\\', 'XX') # after this, \\" does not match to \" + return ((line.count('"') - line.count(r'\"') - line.count("'\"'")) & 1) == 1 + + +def CleanseRawStrings(raw_lines): + """Removes C++11 raw strings from lines. + + Before: + static const char kData[] = R"( + multi-line string + )"; + + After: + static const char kData[] = "" + (replaced by blank line) + ""; + + Args: + raw_lines: list of raw lines. + + Returns: + list of lines with C++11 raw strings replaced by empty strings. + """ + + delimiter = None + lines_without_raw_strings = [] + for line in raw_lines: + if delimiter: + # Inside a raw string, look for the end + end = line.find(delimiter) + if end >= 0: + # Found the end of the string, match leading space for this + # line and resume copying the original lines, and also insert + # a "" on the last line. + leading_space = Match(r'^(\s*)\S', line) + line = leading_space.group(1) + '""' + line[end + len(delimiter):] + delimiter = None + else: + # Haven't found the end yet, append a blank line. + line = '""' + + # Look for beginning of a raw string, and replace them with + # empty strings. This is done in a loop to handle multiple raw + # strings on the same line. + while delimiter is None: + # Look for beginning of a raw string. + # See 2.14.15 [lex.string] for syntax. + matched = Match(r'^(.*)\b(?:R|u8R|uR|UR|LR)"([^\s\\()]*)\((.*)$', line) + if matched: + delimiter = ')' + matched.group(2) + '"' + + end = matched.group(3).find(delimiter) + if end >= 0: + # Raw string ended on same line + line = (matched.group(1) + '""' + + matched.group(3)[end + len(delimiter):]) + delimiter = None + else: + # Start of a multi-line raw string + line = matched.group(1) + '""' + else: + break + + lines_without_raw_strings.append(line) + + # TODO(unknown): if delimiter is not None here, we might want to + # emit a warning for unterminated string. + return lines_without_raw_strings + + +def FindNextMultiLineCommentStart(lines, lineix): + """Find the beginning marker for a multiline comment.""" + while lineix < len(lines): + if lines[lineix].strip().startswith('/*'): + # Only return this marker if the comment goes beyond this line + if lines[lineix].strip().find('*/', 2) < 0: + return lineix + lineix += 1 + return len(lines) + + +def FindNextMultiLineCommentEnd(lines, lineix): + """We are inside a comment, find the end marker.""" + while lineix < len(lines): + if lines[lineix].strip().endswith('*/'): + return lineix + lineix += 1 + return len(lines) + + +def RemoveMultiLineCommentsFromRange(lines, begin, end): + """Clears a range of lines for multi-line comments.""" + # Having // dummy comments makes the lines non-empty, so we will not get + # unnecessary blank line warnings later in the code. + for i in range(begin, end): + lines[i] = '/**/' + + +def RemoveMultiLineComments(filename, lines, error): + """Removes multiline (c-style) comments from lines.""" + lineix = 0 + while lineix < len(lines): + lineix_begin = FindNextMultiLineCommentStart(lines, lineix) + if lineix_begin >= len(lines): + return + lineix_end = FindNextMultiLineCommentEnd(lines, lineix_begin) + if lineix_end >= len(lines): + error(filename, lineix_begin + 1, 'readability/multiline_comment', 5, + 'Could not find end of multi-line comment') + return + RemoveMultiLineCommentsFromRange(lines, lineix_begin, lineix_end + 1) + lineix = lineix_end + 1 + + +def CleanseComments(line): + """Removes //-comments and single-line C-style /* */ comments. + + Args: + line: A line of C++ source. + + Returns: + The line with single-line comments removed. + """ + commentpos = line.find('//') + if commentpos != -1 and not IsCppString(line[:commentpos]): + line = line[:commentpos].rstrip() + # get rid of /* ... */ + return _RE_PATTERN_CLEANSE_LINE_C_COMMENTS.sub('', line) + + +class CleansedLines(object): + """Holds 4 copies of all lines with different preprocessing applied to them. + + 1) elided member contains lines without strings and comments. + 2) lines member contains lines without comments. + 3) raw_lines member contains all the lines without processing. + 4) lines_without_raw_strings member is same as raw_lines, but with C++11 raw + strings removed. + All these members are of , and of the same length. + """ + + def __init__(self, lines): + self.elided = [] + self.lines = [] + self.raw_lines = lines + self.num_lines = len(lines) + self.lines_without_raw_strings = CleanseRawStrings(lines) + for linenum in range(len(self.lines_without_raw_strings)): + self.lines.append(CleanseComments( + self.lines_without_raw_strings[linenum])) + elided = self._CollapseStrings(self.lines_without_raw_strings[linenum]) + self.elided.append(CleanseComments(elided)) + + def NumLines(self): + """Returns the number of lines represented.""" + return self.num_lines + + @staticmethod + def _CollapseStrings(elided): + """Collapses strings and chars on a line to simple "" or '' blocks. + + We nix strings first so we're not fooled by text like '"http://"' + + Args: + elided: The line being processed. + + Returns: + The line with collapsed strings. + """ + if _RE_PATTERN_INCLUDE.match(elided): + return elided + + # Remove escaped characters first to make quote/single quote collapsing + # basic. Things that look like escaped characters shouldn't occur + # outside of strings and chars. + elided = _RE_PATTERN_CLEANSE_LINE_ESCAPES.sub('', elided) + + # Replace quoted strings and digit separators. Both single quotes + # and double quotes are processed in the same loop, otherwise + # nested quotes wouldn't work. + collapsed = '' + while True: + # Find the first quote character + match = Match(r'^([^\'"]*)([\'"])(.*)$', elided) + if not match: + collapsed += elided + break + head, quote, tail = match.groups() + + if quote == '"': + # Collapse double quoted strings + second_quote = tail.find('"') + if second_quote >= 0: + collapsed += head + '""' + elided = tail[second_quote + 1:] + else: + # Unmatched double quote, don't bother processing the rest + # of the line since this is probably a multiline string. + collapsed += elided + break + else: + # Found single quote, check nearby text to eliminate digit separators. + # + # There is no special handling for floating point here, because + # the integer/fractional/exponent parts would all be parsed + # correctly as long as there are digits on both sides of the + # separator. So we are fine as long as we don't see something + # like "0.'3" (gcc 4.9.0 will not allow this literal). + if Search(r'\b(?:0[bBxX]?|[1-9])[0-9a-fA-F]*$', head): + match_literal = Match(r'^((?:\'?[0-9a-zA-Z_])*)(.*)$', "'" + tail) + collapsed += head + match_literal.group(1).replace("'", '') + elided = match_literal.group(2) + else: + second_quote = tail.find('\'') + if second_quote >= 0: + collapsed += head + "''" + elided = tail[second_quote + 1:] + else: + # Unmatched single quote + collapsed += elided + break + + return collapsed + + +def FindEndOfExpressionInLine(line, startpos, stack): + """Find the position just after the end of current parenthesized expression. + + Args: + line: a CleansedLines line. + startpos: start searching at this position. + stack: nesting stack at startpos. + + Returns: + On finding matching end: (index just after matching end, None) + On finding an unclosed expression: (-1, None) + Otherwise: (-1, new stack at end of this line) + """ + for i in xrange(startpos, len(line)): + char = line[i] + if char in '([{': + # Found start of parenthesized expression, push to expression stack + stack.append(char) + elif char == '<': + # Found potential start of template argument list + if i > 0 and line[i - 1] == '<': + # Left shift operator + if stack and stack[-1] == '<': + stack.pop() + if not stack: + return (-1, None) + elif i > 0 and Search(r'\boperator\s*$', line[0:i]): + # operator<, don't add to stack + continue + else: + # Tentative start of template argument list + stack.append('<') + elif char in ')]}': + # Found end of parenthesized expression. + # + # If we are currently expecting a matching '>', the pending '<' + # must have been an operator. Remove them from expression stack. + while stack and stack[-1] == '<': + stack.pop() + if not stack: + return (-1, None) + if ((stack[-1] == '(' and char == ')') or + (stack[-1] == '[' and char == ']') or + (stack[-1] == '{' and char == '}')): + stack.pop() + if not stack: + return (i + 1, None) + else: + # Mismatched parentheses + return (-1, None) + elif char == '>': + # Found potential end of template argument list. + + # Ignore "->" and operator functions + if (i > 0 and + (line[i - 1] == '-' or Search(r'\boperator\s*$', line[0:i - 1]))): + continue + + # Pop the stack if there is a matching '<'. Otherwise, ignore + # this '>' since it must be an operator. + if stack: + if stack[-1] == '<': + stack.pop() + if not stack: + return (i + 1, None) + elif char == ';': + # Found something that look like end of statements. If we are currently + # expecting a '>', the matching '<' must have been an operator, since + # template argument list should not contain statements. + while stack and stack[-1] == '<': + stack.pop() + if not stack: + return (-1, None) + + # Did not find end of expression or unbalanced parentheses on this line + return (-1, stack) + + +def CloseExpression(clean_lines, linenum, pos): + """If input points to ( or { or [ or <, finds the position that closes it. + + If lines[linenum][pos] points to a '(' or '{' or '[' or '<', finds the + linenum/pos that correspond to the closing of the expression. + + TODO(unknown): cpplint spends a fair bit of time matching parentheses. + Ideally we would want to index all opening and closing parentheses once + and have CloseExpression be just a simple lookup, but due to preprocessor + tricks, this is not so easy. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + pos: A position on the line. + + Returns: + A tuple (line, linenum, pos) pointer *past* the closing brace, or + (line, len(lines), -1) if we never find a close. Note we ignore + strings and comments when matching; and the line we return is the + 'cleansed' line at linenum. + """ + + line = clean_lines.elided[linenum] + if (line[pos] not in '({[<') or Match(r'<[<=]', line[pos:]): + return (line, clean_lines.NumLines(), -1) + + # Check first line + (end_pos, stack) = FindEndOfExpressionInLine(line, pos, []) + if end_pos > -1: + return (line, linenum, end_pos) + + # Continue scanning forward + while stack and linenum < clean_lines.NumLines() - 1: + linenum += 1 + line = clean_lines.elided[linenum] + (end_pos, stack) = FindEndOfExpressionInLine(line, 0, stack) + if end_pos > -1: + return (line, linenum, end_pos) + + # Did not find end of expression before end of file, give up + return (line, clean_lines.NumLines(), -1) + + +def FindStartOfExpressionInLine(line, endpos, stack): + """Find position at the matching start of current expression. + + This is almost the reverse of FindEndOfExpressionInLine, but note + that the input position and returned position differs by 1. + + Args: + line: a CleansedLines line. + endpos: start searching at this position. + stack: nesting stack at endpos. + + Returns: + On finding matching start: (index at matching start, None) + On finding an unclosed expression: (-1, None) + Otherwise: (-1, new stack at beginning of this line) + """ + i = endpos + while i >= 0: + char = line[i] + if char in ')]}': + # Found end of expression, push to expression stack + stack.append(char) + elif char == '>': + # Found potential end of template argument list. + # + # Ignore it if it's a "->" or ">=" or "operator>" + if (i > 0 and + (line[i - 1] == '-' or + Match(r'\s>=\s', line[i - 1:]) or + Search(r'\boperator\s*$', line[0:i]))): + i -= 1 + else: + stack.append('>') + elif char == '<': + # Found potential start of template argument list + if i > 0 and line[i - 1] == '<': + # Left shift operator + i -= 1 + else: + # If there is a matching '>', we can pop the expression stack. + # Otherwise, ignore this '<' since it must be an operator. + if stack and stack[-1] == '>': + stack.pop() + if not stack: + return (i, None) + elif char in '([{': + # Found start of expression. + # + # If there are any unmatched '>' on the stack, they must be + # operators. Remove those. + while stack and stack[-1] == '>': + stack.pop() + if not stack: + return (-1, None) + if ((char == '(' and stack[-1] == ')') or + (char == '[' and stack[-1] == ']') or + (char == '{' and stack[-1] == '}')): + stack.pop() + if not stack: + return (i, None) + else: + # Mismatched parentheses + return (-1, None) + elif char == ';': + # Found something that look like end of statements. If we are currently + # expecting a '<', the matching '>' must have been an operator, since + # template argument list should not contain statements. + while stack and stack[-1] == '>': + stack.pop() + if not stack: + return (-1, None) + + i -= 1 + + return (-1, stack) + + +def ReverseCloseExpression(clean_lines, linenum, pos): + """If input points to ) or } or ] or >, finds the position that opens it. + + If lines[linenum][pos] points to a ')' or '}' or ']' or '>', finds the + linenum/pos that correspond to the opening of the expression. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + pos: A position on the line. + + Returns: + A tuple (line, linenum, pos) pointer *at* the opening brace, or + (line, 0, -1) if we never find the matching opening brace. Note + we ignore strings and comments when matching; and the line we + return is the 'cleansed' line at linenum. + """ + line = clean_lines.elided[linenum] + if line[pos] not in ')}]>': + return (line, 0, -1) + + # Check last line + (start_pos, stack) = FindStartOfExpressionInLine(line, pos, []) + if start_pos > -1: + return (line, linenum, start_pos) + + # Continue scanning backward + while stack and linenum > 0: + linenum -= 1 + line = clean_lines.elided[linenum] + (start_pos, stack) = FindStartOfExpressionInLine(line, len(line) - 1, stack) + if start_pos > -1: + return (line, linenum, start_pos) + + # Did not find start of expression before beginning of file, give up + return (line, 0, -1) + + +def CheckForCopyright(filename, lines, error): + """Logs an error if no Copyright message appears at the top of the file.""" + + # We'll say it should occur by line 10. Don't forget there's a + # dummy line at the front. + for line in xrange(1, min(len(lines), 11)): + if re.search(r'Copyright', lines[line], re.I): break + else: # means no copyright line was found + error(filename, 0, 'legal/copyright', 5, + 'No copyright message found. ' + 'You should have a line: "Copyright [year] "') + + +def GetIndentLevel(line): + """Return the number of leading spaces in line. + + Args: + line: A string to check. + + Returns: + An integer count of leading spaces, possibly zero. + """ + indent = Match(r'^( *)\S', line) + if indent: + return len(indent.group(1)) + else: + return 0 + + +def GetHeaderGuardCPPVariable(filename): + """Returns the CPP variable that should be used as a header guard. + + Args: + filename: The name of a C++ header file. + + Returns: + The CPP variable that should be used as a header guard in the + named file. + + """ + + # Restores original filename in case that cpplint is invoked from Emacs's + # flymake. + filename = re.sub(r'_flymake\.h$', '.h', filename) + filename = re.sub(r'/\.flymake/([^/]*)$', r'/\1', filename) + # Replace 'c++' with 'cpp'. + filename = filename.replace('C++', 'cpp').replace('c++', 'cpp') + + fileinfo = FileInfo(filename) + file_path_from_root = fileinfo.RepositoryName() + if _root: + file_path_from_root = re.sub('^' + _root + os.sep, '', file_path_from_root) + return re.sub(r'[^a-zA-Z0-9]', '_', file_path_from_root).upper() + '_' + + +def CheckForHeaderGuard(filename, clean_lines, error): + """Checks that the file contains a header guard. + + Logs an error if no #ifndef header guard is present. For other + headers, checks that the full pathname is used. + + Args: + filename: The name of the C++ header file. + clean_lines: A CleansedLines instance containing the file. + error: The function to call with any errors found. + """ + + # Don't check for header guards if there are error suppression + # comments somewhere in this file. + # + # Because this is silencing a warning for a nonexistent line, we + # only support the very specific NOLINT(build/header_guard) syntax, + # and not the general NOLINT or NOLINT(*) syntax. + raw_lines = clean_lines.lines_without_raw_strings + for i in raw_lines: + if Search(r'//\s*NOLINT\(build/header_guard\)', i): + return + + cppvar = GetHeaderGuardCPPVariable(filename) + + ifndef = '' + ifndef_linenum = 0 + define = '' + endif = '' + endif_linenum = 0 + for linenum, line in enumerate(raw_lines): + linesplit = line.split() + if len(linesplit) >= 2: + # find the first occurrence of #ifndef and #define, save arg + if not ifndef and linesplit[0] == '#ifndef': + # set ifndef to the header guard presented on the #ifndef line. + ifndef = linesplit[1] + ifndef_linenum = linenum + if not define and linesplit[0] == '#define': + define = linesplit[1] + # find the last occurrence of #endif, save entire line + if line.startswith('#endif'): + endif = line + endif_linenum = linenum + + if not ifndef or not define or ifndef != define: + error(filename, 0, 'build/header_guard', 5, + 'No #ifndef header guard found, suggested CPP variable is: %s' % + cppvar) + return + + # The guard should be PATH_FILE_H_, but we also allow PATH_FILE_H__ + # for backward compatibility. + if ifndef != cppvar: + error_level = 0 + if ifndef != cppvar + '_': + error_level = 5 + + ParseNolintSuppressions(filename, raw_lines[ifndef_linenum], ifndef_linenum, + error) + error(filename, ifndef_linenum, 'build/header_guard', error_level, + '#ifndef header guard has wrong style, please use: %s' % cppvar) + + # Check for "//" comments on endif line. + ParseNolintSuppressions(filename, raw_lines[endif_linenum], endif_linenum, + error) + match = Match(r'#endif\s*//\s*' + cppvar + r'(_)?\b', endif) + if match: + if match.group(1) == '_': + # Issue low severity warning for deprecated double trailing underscore + error(filename, endif_linenum, 'build/header_guard', 0, + '#endif line should be "#endif // %s"' % cppvar) + return + + # Didn't find the corresponding "//" comment. If this file does not + # contain any "//" comments at all, it could be that the compiler + # only wants "/**/" comments, look for those instead. + no_single_line_comments = True + for i in xrange(1, len(raw_lines) - 1): + line = raw_lines[i] + if Match(r'^(?:(?:\'(?:\.|[^\'])*\')|(?:"(?:\.|[^"])*")|[^\'"])*//', line): + no_single_line_comments = False + break + + if no_single_line_comments: + match = Match(r'#endif\s*/\*\s*' + cppvar + r'(_)?\s*\*/', endif) + if match: + if match.group(1) == '_': + # Low severity warning for double trailing underscore + error(filename, endif_linenum, 'build/header_guard', 0, + '#endif line should be "#endif /* %s */"' % cppvar) + return + + # Didn't find anything + error(filename, endif_linenum, 'build/header_guard', 5, + '#endif line should be "#endif // %s"' % cppvar) + + +def CheckHeaderFileIncluded(filename, include_state, error): + """Logs an error if a .cc file does not include its header.""" + + # Do not check test files + if filename.endswith('_test.cc') or filename.endswith('_unittest.cc'): + return + + fileinfo = FileInfo(filename) + headerfile = filename[0:len(filename) - 2] + 'h' + if not os.path.exists(headerfile): + return + headername = FileInfo(headerfile).RepositoryName() + first_include = 0 + for section_list in include_state.include_list: + for f in section_list: + if headername in f[0] or f[0] in headername: + return + if not first_include: + first_include = f[1] + + error(filename, first_include, 'build/include', 5, + '%s should include its header file %s' % (fileinfo.RepositoryName(), + headername)) + + +def CheckForBadCharacters(filename, lines, error): + """Logs an error for each line containing bad characters. + + Two kinds of bad characters: + + 1. Unicode replacement characters: These indicate that either the file + contained invalid UTF-8 (likely) or Unicode replacement characters (which + it shouldn't). Note that it's possible for this to throw off line + numbering if the invalid UTF-8 occurred adjacent to a newline. + + 2. NUL bytes. These are problematic for some tools. + + Args: + filename: The name of the current file. + lines: An array of strings, each representing a line of the file. + error: The function to call with any errors found. + """ + for linenum, line in enumerate(lines): + if u'\ufffd' in line: + error(filename, linenum, 'readability/utf8', 5, + 'Line contains invalid UTF-8 (or Unicode replacement character).') + if '\0' in line: + error(filename, linenum, 'readability/nul', 5, 'Line contains NUL byte.') + + +def CheckForNewlineAtEOF(filename, lines, error): + """Logs an error if there is no newline char at the end of the file. + + Args: + filename: The name of the current file. + lines: An array of strings, each representing a line of the file. + error: The function to call with any errors found. + """ + + # The array lines() was created by adding two newlines to the + # original file (go figure), then splitting on \n. + # To verify that the file ends in \n, we just have to make sure the + # last-but-two element of lines() exists and is empty. + if len(lines) < 3 or lines[-2]: + error(filename, len(lines) - 2, 'whitespace/ending_newline', 5, + 'Could not find a newline character at the end of the file.') + + +def CheckForMultilineCommentsAndStrings(filename, clean_lines, linenum, error): + """Logs an error if we see /* ... */ or "..." that extend past one line. + + /* ... */ comments are legit inside macros, for one line. + Otherwise, we prefer // comments, so it's ok to warn about the + other. Likewise, it's ok for strings to extend across multiple + lines, as long as a line continuation character (backslash) + terminates each line. Although not currently prohibited by the C++ + style guide, it's ugly and unnecessary. We don't do well with either + in this lint program, so we warn about both. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Remove all \\ (escaped backslashes) from the line. They are OK, and the + # second (escaped) slash may trigger later \" detection erroneously. + line = line.replace('\\\\', '') + + if line.count('/*') > line.count('*/'): + error(filename, linenum, 'readability/multiline_comment', 5, + 'Complex multi-line /*...*/-style comment found. ' + 'Lint may give bogus warnings. ' + 'Consider replacing these with //-style comments, ' + 'with #if 0...#endif, ' + 'or with more clearly structured multi-line comments.') + + if (line.count('"') - line.count('\\"')) % 2: + error(filename, linenum, 'readability/multiline_string', 5, + 'Multi-line string ("...") found. This lint script doesn\'t ' + 'do well with such strings, and may give bogus warnings. ' + 'Use C++11 raw strings or concatenation instead.') + + +# (non-threadsafe name, thread-safe alternative, validation pattern) +# +# The validation pattern is used to eliminate false positives such as: +# _rand(); // false positive due to substring match. +# ->rand(); // some member function rand(). +# ACMRandom rand(seed); // some variable named rand. +# ISAACRandom rand(); // another variable named rand. +# +# Basically we require the return value of these functions to be used +# in some expression context on the same line by matching on some +# operator before the function name. This eliminates constructors and +# member function calls. +_UNSAFE_FUNC_PREFIX = r'(?:[-+*/=%^&|(<]\s*|>\s+)' +_THREADING_LIST = ( + ('asctime(', 'asctime_r(', _UNSAFE_FUNC_PREFIX + r'asctime\([^)]+\)'), + ('ctime(', 'ctime_r(', _UNSAFE_FUNC_PREFIX + r'ctime\([^)]+\)'), + ('getgrgid(', 'getgrgid_r(', _UNSAFE_FUNC_PREFIX + r'getgrgid\([^)]+\)'), + ('getgrnam(', 'getgrnam_r(', _UNSAFE_FUNC_PREFIX + r'getgrnam\([^)]+\)'), + ('getlogin(', 'getlogin_r(', _UNSAFE_FUNC_PREFIX + r'getlogin\(\)'), + ('getpwnam(', 'getpwnam_r(', _UNSAFE_FUNC_PREFIX + r'getpwnam\([^)]+\)'), + ('getpwuid(', 'getpwuid_r(', _UNSAFE_FUNC_PREFIX + r'getpwuid\([^)]+\)'), + ('gmtime(', 'gmtime_r(', _UNSAFE_FUNC_PREFIX + r'gmtime\([^)]+\)'), + ('localtime(', 'localtime_r(', _UNSAFE_FUNC_PREFIX + r'localtime\([^)]+\)'), + ('rand(', 'rand_r(', _UNSAFE_FUNC_PREFIX + r'rand\(\)'), + ('strtok(', 'strtok_r(', + _UNSAFE_FUNC_PREFIX + r'strtok\([^)]+\)'), + ('ttyname(', 'ttyname_r(', _UNSAFE_FUNC_PREFIX + r'ttyname\([^)]+\)'), + ) + + +def CheckPosixThreading(filename, clean_lines, linenum, error): + """Checks for calls to thread-unsafe functions. + + Much code has been originally written without consideration of + multi-threading. Also, engineers are relying on their old experience; + they have learned posix before threading extensions were added. These + tests guide the engineers to use thread-safe functions (when using + posix directly). + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + for single_thread_func, multithread_safe_func, pattern in _THREADING_LIST: + # Additional pattern matching check to confirm that this is the + # function we are looking for + if Search(pattern, line): + error(filename, linenum, 'runtime/threadsafe_fn', 2, + 'Consider using ' + multithread_safe_func + + '...) instead of ' + single_thread_func + + '...) for improved thread safety.') + + +def CheckVlogArguments(filename, clean_lines, linenum, error): + """Checks that VLOG() is only used for defining a logging level. + + For example, VLOG(2) is correct. VLOG(INFO), VLOG(WARNING), VLOG(ERROR), and + VLOG(FATAL) are not. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + if Search(r'\bVLOG\((INFO|ERROR|WARNING|DFATAL|FATAL)\)', line): + error(filename, linenum, 'runtime/vlog', 5, + 'VLOG() should be used with numeric verbosity level. ' + 'Use LOG() if you want symbolic severity levels.') + +# Matches invalid increment: *count++, which moves pointer instead of +# incrementing a value. +_RE_PATTERN_INVALID_INCREMENT = re.compile( + r'^\s*\*\w+(\+\+|--);') + + +def CheckInvalidIncrement(filename, clean_lines, linenum, error): + """Checks for invalid increment *count++. + + For example following function: + void increment_counter(int* count) { + *count++; + } + is invalid, because it effectively does count++, moving pointer, and should + be replaced with ++*count, (*count)++ or *count += 1. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + if _RE_PATTERN_INVALID_INCREMENT.match(line): + error(filename, linenum, 'runtime/invalid_increment', 5, + 'Changing pointer instead of value (or unused value of operator*).') + + +def IsMacroDefinition(clean_lines, linenum): + if Search(r'^#define', clean_lines[linenum]): + return True + + if linenum > 0 and Search(r'\\$', clean_lines[linenum - 1]): + return True + + return False + + +def IsForwardClassDeclaration(clean_lines, linenum): + return Match(r'^\s*(\btemplate\b)*.*class\s+\w+;\s*$', clean_lines[linenum]) + + +class _BlockInfo(object): + """Stores information about a generic block of code.""" + + def __init__(self, seen_open_brace): + self.seen_open_brace = seen_open_brace + self.open_parentheses = 0 + self.inline_asm = _NO_ASM + self.check_namespace_indentation = False + + def CheckBegin(self, filename, clean_lines, linenum, error): + """Run checks that applies to text up to the opening brace. + + This is mostly for checking the text after the class identifier + and the "{", usually where the base class is specified. For other + blocks, there isn't much to check, so we always pass. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + pass + + def CheckEnd(self, filename, clean_lines, linenum, error): + """Run checks that applies to text after the closing brace. + + This is mostly used for checking end of namespace comments. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + pass + + def IsBlockInfo(self): + """Returns true if this block is a _BlockInfo. + + This is convenient for verifying that an object is an instance of + a _BlockInfo, but not an instance of any of the derived classes. + + Returns: + True for this class, False for derived classes. + """ + return self.__class__ == _BlockInfo + + +class _ExternCInfo(_BlockInfo): + """Stores information about an 'extern "C"' block.""" + + def __init__(self): + _BlockInfo.__init__(self, True) + + +class _ClassInfo(_BlockInfo): + """Stores information about a class.""" + + def __init__(self, name, class_or_struct, clean_lines, linenum): + _BlockInfo.__init__(self, False) + self.name = name + self.starting_linenum = linenum + self.is_derived = False + self.check_namespace_indentation = True + if class_or_struct == 'struct': + self.access = 'public' + self.is_struct = True + else: + self.access = 'private' + self.is_struct = False + + # Remember initial indentation level for this class. Using raw_lines here + # instead of elided to account for leading comments. + self.class_indent = GetIndentLevel(clean_lines.raw_lines[linenum]) + + # Try to find the end of the class. This will be confused by things like: + # class A { + # } *x = { ... + # + # But it's still good enough for CheckSectionSpacing. + self.last_line = 0 + depth = 0 + for i in range(linenum, clean_lines.NumLines()): + line = clean_lines.elided[i] + depth += line.count('{') - line.count('}') + if not depth: + self.last_line = i + break + + def CheckBegin(self, filename, clean_lines, linenum, error): + # Look for a bare ':' + if Search('(^|[^:]):($|[^:])', clean_lines.elided[linenum]): + self.is_derived = True + + def CheckEnd(self, filename, clean_lines, linenum, error): + # If there is a DISALLOW macro, it should appear near the end of + # the class. + seen_last_thing_in_class = False + for i in xrange(linenum - 1, self.starting_linenum, -1): + match = Search( + r'\b(DISALLOW_COPY_AND_ASSIGN|DISALLOW_IMPLICIT_CONSTRUCTORS)\(' + + self.name + r'\)', + clean_lines.elided[i]) + if match: + if seen_last_thing_in_class: + error(filename, i, 'readability/constructors', 3, + match.group(1) + ' should be the last thing in the class') + break + + if not Match(r'^\s*$', clean_lines.elided[i]): + seen_last_thing_in_class = True + + # Check that closing brace is aligned with beginning of the class. + # Only do this if the closing brace is indented by only whitespaces. + # This means we will not check single-line class definitions. + indent = Match(r'^( *)\}', clean_lines.elided[linenum]) + if indent and len(indent.group(1)) != self.class_indent: + if self.is_struct: + parent = 'struct ' + self.name + else: + parent = 'class ' + self.name + error(filename, linenum, 'whitespace/indent', 3, + 'Closing brace should be aligned with beginning of %s' % parent) + + +class _NamespaceInfo(_BlockInfo): + """Stores information about a namespace.""" + + def __init__(self, name, linenum): + _BlockInfo.__init__(self, False) + self.name = name or '' + self.starting_linenum = linenum + self.check_namespace_indentation = True + + def CheckEnd(self, filename, clean_lines, linenum, error): + """Check end of namespace comments.""" + line = clean_lines.raw_lines[linenum] + + # Check how many lines is enclosed in this namespace. Don't issue + # warning for missing namespace comments if there aren't enough + # lines. However, do apply checks if there is already an end of + # namespace comment and it's incorrect. + # + # TODO(unknown): We always want to check end of namespace comments + # if a namespace is large, but sometimes we also want to apply the + # check if a short namespace contained nontrivial things (something + # other than forward declarations). There is currently no logic on + # deciding what these nontrivial things are, so this check is + # triggered by namespace size only, which works most of the time. + if (linenum - self.starting_linenum < 10 + and not Match(r'};*\s*(//|/\*).*\bnamespace\b', line)): + return + + # Look for matching comment at end of namespace. + # + # Note that we accept C style "/* */" comments for terminating + # namespaces, so that code that terminate namespaces inside + # preprocessor macros can be cpplint clean. + # + # We also accept stuff like "// end of namespace ." with the + # period at the end. + # + # Besides these, we don't accept anything else, otherwise we might + # get false negatives when existing comment is a substring of the + # expected namespace. + if self.name: + # Named namespace + if not Match((r'};*\s*(//|/\*).*\bnamespace\s+' + re.escape(self.name) + + r'[\*/\.\\\s]*$'), + line): + error(filename, linenum, 'readability/namespace', 5, + 'Namespace should be terminated with "// namespace %s"' % + self.name) + else: + # Anonymous namespace + if not Match(r'};*\s*(//|/\*).*\bnamespace[\*/\.\\\s]*$', line): + # If "// namespace anonymous" or "// anonymous namespace (more text)", + # mention "// anonymous namespace" as an acceptable form + if Match(r'}.*\b(namespace anonymous|anonymous namespace)\b', line): + error(filename, linenum, 'readability/namespace', 5, + 'Anonymous namespace should be terminated with "// namespace"' + ' or "// anonymous namespace"') + else: + error(filename, linenum, 'readability/namespace', 5, + 'Anonymous namespace should be terminated with "// namespace"') + + +class _PreprocessorInfo(object): + """Stores checkpoints of nesting stacks when #if/#else is seen.""" + + def __init__(self, stack_before_if): + # The entire nesting stack before #if + self.stack_before_if = stack_before_if + + # The entire nesting stack up to #else + self.stack_before_else = [] + + # Whether we have already seen #else or #elif + self.seen_else = False + + +class NestingState(object): + """Holds states related to parsing braces.""" + + def __init__(self): + # Stack for tracking all braces. An object is pushed whenever we + # see a "{", and popped when we see a "}". Only 3 types of + # objects are possible: + # - _ClassInfo: a class or struct. + # - _NamespaceInfo: a namespace. + # - _BlockInfo: some other type of block. + self.stack = [] + + # Top of the previous stack before each Update(). + # + # Because the nesting_stack is updated at the end of each line, we + # had to do some convoluted checks to find out what is the current + # scope at the beginning of the line. This check is simplified by + # saving the previous top of nesting stack. + # + # We could save the full stack, but we only need the top. Copying + # the full nesting stack would slow down cpplint by ~10%. + self.previous_stack_top = [] + + # Stack of _PreprocessorInfo objects. + self.pp_stack = [] + + def SeenOpenBrace(self): + """Check if we have seen the opening brace for the innermost block. + + Returns: + True if we have seen the opening brace, False if the innermost + block is still expecting an opening brace. + """ + return (not self.stack) or self.stack[-1].seen_open_brace + + def InNamespaceBody(self): + """Check if we are currently one level inside a namespace body. + + Returns: + True if top of the stack is a namespace block, False otherwise. + """ + return self.stack and isinstance(self.stack[-1], _NamespaceInfo) + + def InExternC(self): + """Check if we are currently one level inside an 'extern "C"' block. + + Returns: + True if top of the stack is an extern block, False otherwise. + """ + return self.stack and isinstance(self.stack[-1], _ExternCInfo) + + def InClassDeclaration(self): + """Check if we are currently one level inside a class or struct declaration. + + Returns: + True if top of the stack is a class/struct, False otherwise. + """ + return self.stack and isinstance(self.stack[-1], _ClassInfo) + + def InAsmBlock(self): + """Check if we are currently one level inside an inline ASM block. + + Returns: + True if the top of the stack is a block containing inline ASM. + """ + return self.stack and self.stack[-1].inline_asm != _NO_ASM + + def InTemplateArgumentList(self, clean_lines, linenum, pos): + """Check if current position is inside template argument list. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + pos: position just after the suspected template argument. + Returns: + True if (linenum, pos) is inside template arguments. + """ + while linenum < clean_lines.NumLines(): + # Find the earliest character that might indicate a template argument + line = clean_lines.elided[linenum] + match = Match(r'^[^{};=\[\]\.<>]*(.)', line[pos:]) + if not match: + linenum += 1 + pos = 0 + continue + token = match.group(1) + pos += len(match.group(0)) + + # These things do not look like template argument list: + # class Suspect { + # class Suspect x; } + if token in ('{', '}', ';'): return False + + # These things look like template argument list: + # template + # template + # template + # template + if token in ('>', '=', '[', ']', '.'): return True + + # Check if token is an unmatched '<'. + # If not, move on to the next character. + if token != '<': + pos += 1 + if pos >= len(line): + linenum += 1 + pos = 0 + continue + + # We can't be sure if we just find a single '<', and need to + # find the matching '>'. + (_, end_line, end_pos) = CloseExpression(clean_lines, linenum, pos - 1) + if end_pos < 0: + # Not sure if template argument list or syntax error in file + return False + linenum = end_line + pos = end_pos + return False + + def UpdatePreprocessor(self, line): + """Update preprocessor stack. + + We need to handle preprocessors due to classes like this: + #ifdef SWIG + struct ResultDetailsPageElementExtensionPoint { + #else + struct ResultDetailsPageElementExtensionPoint : public Extension { + #endif + + We make the following assumptions (good enough for most files): + - Preprocessor condition evaluates to true from #if up to first + #else/#elif/#endif. + + - Preprocessor condition evaluates to false from #else/#elif up + to #endif. We still perform lint checks on these lines, but + these do not affect nesting stack. + + Args: + line: current line to check. + """ + if Match(r'^\s*#\s*(if|ifdef|ifndef)\b', line): + # Beginning of #if block, save the nesting stack here. The saved + # stack will allow us to restore the parsing state in the #else case. + self.pp_stack.append(_PreprocessorInfo(copy.deepcopy(self.stack))) + elif Match(r'^\s*#\s*(else|elif)\b', line): + # Beginning of #else block + if self.pp_stack: + if not self.pp_stack[-1].seen_else: + # This is the first #else or #elif block. Remember the + # whole nesting stack up to this point. This is what we + # keep after the #endif. + self.pp_stack[-1].seen_else = True + self.pp_stack[-1].stack_before_else = copy.deepcopy(self.stack) + + # Restore the stack to how it was before the #if + self.stack = copy.deepcopy(self.pp_stack[-1].stack_before_if) + else: + # TODO(unknown): unexpected #else, issue warning? + pass + elif Match(r'^\s*#\s*endif\b', line): + # End of #if or #else blocks. + if self.pp_stack: + # If we saw an #else, we will need to restore the nesting + # stack to its former state before the #else, otherwise we + # will just continue from where we left off. + if self.pp_stack[-1].seen_else: + # Here we can just use a shallow copy since we are the last + # reference to it. + self.stack = self.pp_stack[-1].stack_before_else + # Drop the corresponding #if + self.pp_stack.pop() + else: + # TODO(unknown): unexpected #endif, issue warning? + pass + + # TODO(unknown): Update() is too long, but we will refactor later. + def Update(self, filename, clean_lines, linenum, error): + """Update nesting state with current line. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Remember top of the previous nesting stack. + # + # The stack is always pushed/popped and not modified in place, so + # we can just do a shallow copy instead of copy.deepcopy. Using + # deepcopy would slow down cpplint by ~28%. + if self.stack: + self.previous_stack_top = self.stack[-1] + else: + self.previous_stack_top = None + + # Update pp_stack + self.UpdatePreprocessor(line) + + # Count parentheses. This is to avoid adding struct arguments to + # the nesting stack. + if self.stack: + inner_block = self.stack[-1] + depth_change = line.count('(') - line.count(')') + inner_block.open_parentheses += depth_change + + # Also check if we are starting or ending an inline assembly block. + if inner_block.inline_asm in (_NO_ASM, _END_ASM): + if (depth_change != 0 and + inner_block.open_parentheses == 1 and + _MATCH_ASM.match(line)): + # Enter assembly block + inner_block.inline_asm = _INSIDE_ASM + else: + # Not entering assembly block. If previous line was _END_ASM, + # we will now shift to _NO_ASM state. + inner_block.inline_asm = _NO_ASM + elif (inner_block.inline_asm == _INSIDE_ASM and + inner_block.open_parentheses == 0): + # Exit assembly block + inner_block.inline_asm = _END_ASM + + # Consume namespace declaration at the beginning of the line. Do + # this in a loop so that we catch same line declarations like this: + # namespace proto2 { namespace bridge { class MessageSet; } } + while True: + # Match start of namespace. The "\b\s*" below catches namespace + # declarations even if it weren't followed by a whitespace, this + # is so that we don't confuse our namespace checker. The + # missing spaces will be flagged by CheckSpacing. + namespace_decl_match = Match(r'^\s*namespace\b\s*([:\w]+)?(.*)$', line) + if not namespace_decl_match: + break + + new_namespace = _NamespaceInfo(namespace_decl_match.group(1), linenum) + self.stack.append(new_namespace) + + line = namespace_decl_match.group(2) + if line.find('{') != -1: + new_namespace.seen_open_brace = True + line = line[line.find('{') + 1:] + + # Look for a class declaration in whatever is left of the line + # after parsing namespaces. The regexp accounts for decorated classes + # such as in: + # class LOCKABLE API Object { + # }; + class_decl_match = Match( + r'^(\s*(?:template\s*<[\w\s<>,:]*>\s*)?' + r'(class|struct)\s+(?:[A-Z_]+\s+)*(\w+(?:::\w+)*))' + r'(.*)$', line) + if (class_decl_match and + (not self.stack or self.stack[-1].open_parentheses == 0)): + # We do not want to accept classes that are actually template arguments: + # template , + # template class Ignore3> + # void Function() {}; + # + # To avoid template argument cases, we scan forward and look for + # an unmatched '>'. If we see one, assume we are inside a + # template argument list. + end_declaration = len(class_decl_match.group(1)) + if not self.InTemplateArgumentList(clean_lines, linenum, end_declaration): + self.stack.append(_ClassInfo( + class_decl_match.group(3), class_decl_match.group(2), + clean_lines, linenum)) + line = class_decl_match.group(4) + + # If we have not yet seen the opening brace for the innermost block, + # run checks here. + if not self.SeenOpenBrace(): + self.stack[-1].CheckBegin(filename, clean_lines, linenum, error) + + # Update access control if we are inside a class/struct + if self.stack and isinstance(self.stack[-1], _ClassInfo): + classinfo = self.stack[-1] + access_match = Match( + r'^(.*)\b(public|private|protected|signals)(\s+(?:slots\s*)?)?' + r':(?:[^:]|$)', + line) + if access_match: + classinfo.access = access_match.group(2) + + # Check that access keywords are indented +1 space. Skip this + # check if the keywords are not preceded by whitespaces. + indent = access_match.group(1) + if (len(indent) != classinfo.class_indent + 1 and + Match(r'^\s*$', indent)): + if classinfo.is_struct: + parent = 'struct ' + classinfo.name + else: + parent = 'class ' + classinfo.name + slots = '' + if access_match.group(3): + slots = access_match.group(3) + error(filename, linenum, 'whitespace/indent', 3, + '%s%s: should be indented +1 space inside %s' % ( + access_match.group(2), slots, parent)) + + # Consume braces or semicolons from what's left of the line + while True: + # Match first brace, semicolon, or closed parenthesis. + matched = Match(r'^[^{;)}]*([{;)}])(.*)$', line) + if not matched: + break + + token = matched.group(1) + if token == '{': + # If namespace or class hasn't seen a opening brace yet, mark + # namespace/class head as complete. Push a new block onto the + # stack otherwise. + if not self.SeenOpenBrace(): + self.stack[-1].seen_open_brace = True + elif Match(r'^extern\s*"[^"]*"\s*\{', line): + self.stack.append(_ExternCInfo()) + else: + self.stack.append(_BlockInfo(True)) + if _MATCH_ASM.match(line): + self.stack[-1].inline_asm = _BLOCK_ASM + + elif token == ';' or token == ')': + # If we haven't seen an opening brace yet, but we already saw + # a semicolon, this is probably a forward declaration. Pop + # the stack for these. + # + # Similarly, if we haven't seen an opening brace yet, but we + # already saw a closing parenthesis, then these are probably + # function arguments with extra "class" or "struct" keywords. + # Also pop these stack for these. + if not self.SeenOpenBrace(): + self.stack.pop() + else: # token == '}' + # Perform end of block checks and pop the stack. + if self.stack: + self.stack[-1].CheckEnd(filename, clean_lines, linenum, error) + self.stack.pop() + line = matched.group(2) + + def InnermostClass(self): + """Get class info on the top of the stack. + + Returns: + A _ClassInfo object if we are inside a class, or None otherwise. + """ + for i in range(len(self.stack), 0, -1): + classinfo = self.stack[i - 1] + if isinstance(classinfo, _ClassInfo): + return classinfo + return None + + def CheckCompletedBlocks(self, filename, error): + """Checks that all classes and namespaces have been completely parsed. + + Call this when all lines in a file have been processed. + Args: + filename: The name of the current file. + error: The function to call with any errors found. + """ + # Note: This test can result in false positives if #ifdef constructs + # get in the way of brace matching. See the testBuildClass test in + # cpplint_unittest.py for an example of this. + for obj in self.stack: + if isinstance(obj, _ClassInfo): + error(filename, obj.starting_linenum, 'build/class', 5, + 'Failed to find complete declaration of class %s' % + obj.name) + elif isinstance(obj, _NamespaceInfo): + error(filename, obj.starting_linenum, 'build/namespaces', 5, + 'Failed to find complete declaration of namespace %s' % + obj.name) + + +def CheckForNonStandardConstructs(filename, clean_lines, linenum, + nesting_state, error): + r"""Logs an error if we see certain non-ANSI constructs ignored by gcc-2. + + Complain about several constructs which gcc-2 accepts, but which are + not standard C++. Warning about these in lint is one way to ease the + transition to new compilers. + - put storage class first (e.g. "static const" instead of "const static"). + - "%lld" instead of %qd" in printf-type functions. + - "%1$d" is non-standard in printf-type functions. + - "\%" is an undefined character escape sequence. + - text after #endif is not allowed. + - invalid inner-style forward declaration. + - >? and ?= and )\?=?\s*(\w+|[+-]?\d+)(\.\d*)?', + line): + error(filename, linenum, 'build/deprecated', 3, + '>? and ))?' + # r'\s*const\s*' + type_name + '\s*&\s*\w+\s*;' + error(filename, linenum, 'runtime/member_string_references', 2, + 'const string& members are dangerous. It is much better to use ' + 'alternatives, such as pointers or simple constants.') + + # Everything else in this function operates on class declarations. + # Return early if the top of the nesting stack is not a class, or if + # the class head is not completed yet. + classinfo = nesting_state.InnermostClass() + if not classinfo or not classinfo.seen_open_brace: + return + + # The class may have been declared with namespace or classname qualifiers. + # The constructor and destructor will not have those qualifiers. + base_classname = classinfo.name.split('::')[-1] + + # Look for single-argument constructors that aren't marked explicit. + # Technically a valid construct, but against style. Also look for + # non-single-argument constructors which are also technically valid, but + # strongly suggest something is wrong. + explicit_constructor_match = Match( + r'\s+(?:inline\s+)?(explicit\s+)?(?:inline\s+)?%s\s*' + r'\(((?:[^()]|\([^()]*\))*)\)' + % re.escape(base_classname), + line) + + if explicit_constructor_match: + is_marked_explicit = explicit_constructor_match.group(1) + + if not explicit_constructor_match.group(2): + constructor_args = [] + else: + constructor_args = explicit_constructor_match.group(2).split(',') + + # collapse arguments so that commas in template parameter lists and function + # argument parameter lists don't split arguments in two + i = 0 + while i < len(constructor_args): + constructor_arg = constructor_args[i] + while (constructor_arg.count('<') > constructor_arg.count('>') or + constructor_arg.count('(') > constructor_arg.count(')')): + constructor_arg += ',' + constructor_args[i + 1] + del constructor_args[i + 1] + constructor_args[i] = constructor_arg + i += 1 + + defaulted_args = [arg for arg in constructor_args if '=' in arg] + noarg_constructor = (not constructor_args or # empty arg list + # 'void' arg specifier + (len(constructor_args) == 1 and + constructor_args[0].strip() == 'void')) + onearg_constructor = ((len(constructor_args) == 1 and # exactly one arg + not noarg_constructor) or + # all but at most one arg defaulted + (len(constructor_args) >= 1 and + not noarg_constructor and + len(defaulted_args) >= len(constructor_args) - 1)) + initializer_list_constructor = bool( + onearg_constructor and + Search(r'\bstd\s*::\s*initializer_list\b', constructor_args[0])) + copy_constructor = bool( + onearg_constructor and + Match(r'(const\s+)?%s(\s*<[^>]*>)?(\s+const)?\s*(?:<\w+>\s*)?&' + % re.escape(base_classname), constructor_args[0].strip())) + + if (not is_marked_explicit and + onearg_constructor and + not initializer_list_constructor and + not copy_constructor): + if defaulted_args: + error(filename, linenum, 'runtime/explicit', 5, + 'Constructors callable with one argument ' + 'should be marked explicit.') + else: + error(filename, linenum, 'runtime/explicit', 5, + 'Single-parameter constructors should be marked explicit.') + elif is_marked_explicit and not onearg_constructor: + if noarg_constructor: + error(filename, linenum, 'runtime/explicit', 5, + 'Zero-parameter constructors should not be marked explicit.') + else: + error(filename, linenum, 'runtime/explicit', 0, + 'Constructors that require multiple arguments ' + 'should not be marked explicit.') + + +def CheckSpacingForFunctionCall(filename, clean_lines, linenum, error): + """Checks for the correctness of various spacing around function calls. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Since function calls often occur inside if/for/while/switch + # expressions - which have their own, more liberal conventions - we + # first see if we should be looking inside such an expression for a + # function call, to which we can apply more strict standards. + fncall = line # if there's no control flow construct, look at whole line + for pattern in (r'\bif\s*\((.*)\)\s*{', + r'\bfor\s*\((.*)\)\s*{', + r'\bwhile\s*\((.*)\)\s*[{;]', + r'\bswitch\s*\((.*)\)\s*{'): + match = Search(pattern, line) + if match: + fncall = match.group(1) # look inside the parens for function calls + break + + # Except in if/for/while/switch, there should never be space + # immediately inside parens (eg "f( 3, 4 )"). We make an exception + # for nested parens ( (a+b) + c ). Likewise, there should never be + # a space before a ( when it's a function argument. I assume it's a + # function argument when the char before the whitespace is legal in + # a function name (alnum + _) and we're not starting a macro. Also ignore + # pointers and references to arrays and functions coz they're too tricky: + # we use a very simple way to recognize these: + # " (something)(maybe-something)" or + # " (something)(maybe-something," or + # " (something)[something]" + # Note that we assume the contents of [] to be short enough that + # they'll never need to wrap. + if ( # Ignore control structures. + not Search(r'\b(if|for|while|switch|return|new|delete|catch|sizeof)\b', + fncall) and + # Ignore pointers/references to functions. + not Search(r' \([^)]+\)\([^)]*(\)|,$)', fncall) and + # Ignore pointers/references to arrays. + not Search(r' \([^)]+\)\[[^\]]+\]', fncall)): + if Search(r'\w\s*\(\s(?!\s*\\$)', fncall): # a ( used for a fn call + error(filename, linenum, 'whitespace/parens', 4, + 'Extra space after ( in function call') + elif Search(r'\(\s+(?!(\s*\\)|\()', fncall): + error(filename, linenum, 'whitespace/parens', 2, + 'Extra space after (') + if (Search(r'\w\s+\(', fncall) and + not Search(r'#\s*define|typedef|using\s+\w+\s*=', fncall) and + not Search(r'\w\s+\((\w+::)*\*\w+\)\(', fncall) and + not Search(r'\bcase\s+\(', fncall)): + # TODO(unknown): Space after an operator function seem to be a common + # error, silence those for now by restricting them to highest verbosity. + if Search(r'\boperator_*\b', line): + error(filename, linenum, 'whitespace/parens', 0, + 'Extra space before ( in function call') + else: + error(filename, linenum, 'whitespace/parens', 4, + 'Extra space before ( in function call') + # If the ) is followed only by a newline or a { + newline, assume it's + # part of a control statement (if/while/etc), and don't complain + if Search(r'[^)]\s+\)\s*[^{\s]', fncall): + # If the closing parenthesis is preceded by only whitespaces, + # try to give a more descriptive error message. + if Search(r'^\s+\)', fncall): + error(filename, linenum, 'whitespace/parens', 2, + 'Closing ) should be moved to the previous line') + else: + error(filename, linenum, 'whitespace/parens', 2, + 'Extra space before )') + + +def IsBlankLine(line): + """Returns true if the given line is blank. + + We consider a line to be blank if the line is empty or consists of + only white spaces. + + Args: + line: A line of a string. + + Returns: + True, if the given line is blank. + """ + return not line or line.isspace() + + +def CheckForNamespaceIndentation(filename, nesting_state, clean_lines, line, + error): + is_namespace_indent_item = ( + len(nesting_state.stack) > 1 and + nesting_state.stack[-1].check_namespace_indentation and + isinstance(nesting_state.previous_stack_top, _NamespaceInfo) and + nesting_state.previous_stack_top == nesting_state.stack[-2]) + + if ShouldCheckNamespaceIndentation(nesting_state, is_namespace_indent_item, + clean_lines.elided, line): + CheckItemIndentationInNamespace(filename, clean_lines.elided, + line, error) + + +def CheckForFunctionLengths(filename, clean_lines, linenum, + function_state, error): + """Reports for long function bodies. + + For an overview why this is done, see: + http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Write_Short_Functions + + Uses a simplistic algorithm assuming other style guidelines + (especially spacing) are followed. + Only checks unindented functions, so class members are unchecked. + Trivial bodies are unchecked, so constructors with huge initializer lists + may be missed. + Blank/comment lines are not counted so as to avoid encouraging the removal + of vertical space and comments just to get through a lint check. + NOLINT *on the last line of a function* disables this check. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + function_state: Current function name and lines in body so far. + error: The function to call with any errors found. + """ + lines = clean_lines.lines + line = lines[linenum] + joined_line = '' + + starting_func = False + regexp = r'(\w(\w|::|\*|\&|\s)*)\(' # decls * & space::name( ... + match_result = Match(regexp, line) + if match_result: + # If the name is all caps and underscores, figure it's a macro and + # ignore it, unless it's TEST or TEST_F. + function_name = match_result.group(1).split()[-1] + if function_name == 'TEST' or function_name == 'TEST_F' or ( + not Match(r'[A-Z_]+$', function_name)): + starting_func = True + + if starting_func: + body_found = False + for start_linenum in xrange(linenum, clean_lines.NumLines()): + start_line = lines[start_linenum] + joined_line += ' ' + start_line.lstrip() + if Search(r'(;|})', start_line): # Declarations and trivial functions + body_found = True + break # ... ignore + elif Search(r'{', start_line): + body_found = True + function = Search(r'((\w|:)*)\(', line).group(1) + if Match(r'TEST', function): # Handle TEST... macros + parameter_regexp = Search(r'(\(.*\))', joined_line) + if parameter_regexp: # Ignore bad syntax + function += parameter_regexp.group(1) + else: + function += '()' + function_state.Begin(function) + break + if not body_found: + # No body for the function (or evidence of a non-function) was found. + error(filename, linenum, 'readability/fn_size', 5, + 'Lint failed to find start of function body.') + elif Match(r'^\}\s*$', line): # function end + function_state.Check(error, filename, linenum) + function_state.End() + elif not Match(r'^\s*$', line): + function_state.Count() # Count non-blank/non-comment lines. + + +_RE_PATTERN_TODO = re.compile(r'^//(\s*)TODO(\(.+?\))?:?(\s|$)?') + + +def CheckComment(line, filename, linenum, next_line_start, error): + """Checks for common mistakes in comments. + + Args: + line: The line in question. + filename: The name of the current file. + linenum: The number of the line to check. + next_line_start: The first non-whitespace column of the next line. + error: The function to call with any errors found. + """ + commentpos = line.find('//') + if commentpos != -1: + # Check if the // may be in quotes. If so, ignore it + # Comparisons made explicit for clarity -- pylint: disable=g-explicit-bool-comparison + if (line.count('"', 0, commentpos) - + line.count('\\"', 0, commentpos)) % 2 == 0: # not in quotes + # Allow one space for new scopes, two spaces otherwise: + if (not (Match(r'^.*{ *//', line) and next_line_start == commentpos) and + ((commentpos >= 1 and + line[commentpos-1] not in string.whitespace) or + (commentpos >= 2 and + line[commentpos-2] not in string.whitespace))): + error(filename, linenum, 'whitespace/comments', 2, + 'At least two spaces is best between code and comments') + + # Checks for common mistakes in TODO comments. + comment = line[commentpos:] + match = _RE_PATTERN_TODO.match(comment) + if match: + # One whitespace is correct; zero whitespace is handled elsewhere. + leading_whitespace = match.group(1) + if len(leading_whitespace) > 1: + error(filename, linenum, 'whitespace/todo', 2, + 'Too many spaces before TODO') + + username = match.group(2) + if not username: + error(filename, linenum, 'readability/todo', 2, + 'Missing username in TODO; it should look like ' + '"// TODO(my_username): Stuff."') + + middle_whitespace = match.group(3) + # Comparisons made explicit for correctness -- pylint: disable=g-explicit-bool-comparison + if middle_whitespace != ' ' and middle_whitespace != '': + error(filename, linenum, 'whitespace/todo', 2, + 'TODO(my_username) should be followed by a space') + + # If the comment contains an alphanumeric character, there + # should be a space somewhere between it and the // unless + # it's a /// or //! Doxygen comment. + if (Match(r'//[^ ]*\w', comment) and + not Match(r'(///|//\!)(\s+|$)', comment)): + error(filename, linenum, 'whitespace/comments', 4, + 'Should have a space between // and comment') + + +def CheckAccess(filename, clean_lines, linenum, nesting_state, error): + """Checks for improper use of DISALLOW* macros. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] # get rid of comments and strings + + matched = Match((r'\s*(DISALLOW_COPY_AND_ASSIGN|' + r'DISALLOW_IMPLICIT_CONSTRUCTORS)'), line) + if not matched: + return + if nesting_state.stack and isinstance(nesting_state.stack[-1], _ClassInfo): + if nesting_state.stack[-1].access != 'private': + error(filename, linenum, 'readability/constructors', 3, + '%s must be in the private: section' % matched.group(1)) + + else: + # Found DISALLOW* macro outside a class declaration, or perhaps it + # was used inside a function when it should have been part of the + # class declaration. We could issue a warning here, but it + # probably resulted in a compiler error already. + pass + + +def CheckSpacing(filename, clean_lines, linenum, nesting_state, error): + """Checks for the correctness of various spacing issues in the code. + + Things we check for: spaces around operators, spaces after + if/for/while/switch, no spaces around parens in function calls, two + spaces between code and comment, don't start a block with a blank + line, don't end a function with a blank line, don't add a blank line + after public/protected/private, don't have too many blank lines in a row. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + error: The function to call with any errors found. + """ + + # Don't use "elided" lines here, otherwise we can't check commented lines. + # Don't want to use "raw" either, because we don't want to check inside C++11 + # raw strings, + raw = clean_lines.lines_without_raw_strings + line = raw[linenum] + + # Before nixing comments, check if the line is blank for no good + # reason. This includes the first line after a block is opened, and + # blank lines at the end of a function (ie, right before a line like '}' + # + # Skip all the blank line checks if we are immediately inside a + # namespace body. In other words, don't issue blank line warnings + # for this block: + # namespace { + # + # } + # + # A warning about missing end of namespace comments will be issued instead. + # + # Also skip blank line checks for 'extern "C"' blocks, which are formatted + # like namespaces. + if (IsBlankLine(line) and + not nesting_state.InNamespaceBody() and + not nesting_state.InExternC()): + elided = clean_lines.elided + prev_line = elided[linenum - 1] + prevbrace = prev_line.rfind('{') + # TODO(unknown): Don't complain if line before blank line, and line after, + # both start with alnums and are indented the same amount. + # This ignores whitespace at the start of a namespace block + # because those are not usually indented. + if prevbrace != -1 and prev_line[prevbrace:].find('}') == -1: + # OK, we have a blank line at the start of a code block. Before we + # complain, we check if it is an exception to the rule: The previous + # non-empty line has the parameters of a function header that are indented + # 4 spaces (because they did not fit in a 80 column line when placed on + # the same line as the function name). We also check for the case where + # the previous line is indented 6 spaces, which may happen when the + # initializers of a constructor do not fit into a 80 column line. + exception = False + if Match(r' {6}\w', prev_line): # Initializer list? + # We are looking for the opening column of initializer list, which + # should be indented 4 spaces to cause 6 space indentation afterwards. + search_position = linenum-2 + while (search_position >= 0 + and Match(r' {6}\w', elided[search_position])): + search_position -= 1 + exception = (search_position >= 0 + and elided[search_position][:5] == ' :') + else: + # Search for the function arguments or an initializer list. We use a + # simple heuristic here: If the line is indented 4 spaces; and we have a + # closing paren, without the opening paren, followed by an opening brace + # or colon (for initializer lists) we assume that it is the last line of + # a function header. If we have a colon indented 4 spaces, it is an + # initializer list. + exception = (Match(r' {4}\w[^\(]*\)\s*(const\s*)?(\{\s*$|:)', + prev_line) + or Match(r' {4}:', prev_line)) + + if not exception: + error(filename, linenum, 'whitespace/blank_line', 2, + 'Redundant blank line at the start of a code block ' + 'should be deleted.') + # Ignore blank lines at the end of a block in a long if-else + # chain, like this: + # if (condition1) { + # // Something followed by a blank line + # + # } else if (condition2) { + # // Something else + # } + if linenum + 1 < clean_lines.NumLines(): + next_line = raw[linenum + 1] + if (next_line + and Match(r'\s*}', next_line) + and next_line.find('} else ') == -1): + error(filename, linenum, 'whitespace/blank_line', 3, + 'Redundant blank line at the end of a code block ' + 'should be deleted.') + + matched = Match(r'\s*(public|protected|private):', prev_line) + if matched: + error(filename, linenum, 'whitespace/blank_line', 3, + 'Do not leave a blank line after "%s:"' % matched.group(1)) + + # Next, check comments + next_line_start = 0 + if linenum + 1 < clean_lines.NumLines(): + next_line = raw[linenum + 1] + next_line_start = len(next_line) - len(next_line.lstrip()) + CheckComment(line, filename, linenum, next_line_start, error) + + # get rid of comments and strings + line = clean_lines.elided[linenum] + + # You shouldn't have spaces before your brackets, except maybe after + # 'delete []' or 'return []() {};' + if Search(r'\w\s+\[', line) and not Search(r'(?:delete|return)\s+\[', line): + error(filename, linenum, 'whitespace/braces', 5, + 'Extra space before [') + + # In range-based for, we wanted spaces before and after the colon, but + # not around "::" tokens that might appear. + if (Search(r'for *\(.*[^:]:[^: ]', line) or + Search(r'for *\(.*[^: ]:[^:]', line)): + error(filename, linenum, 'whitespace/forcolon', 2, + 'Missing space around colon in range-based for loop') + + +def CheckOperatorSpacing(filename, clean_lines, linenum, error): + """Checks for horizontal spacing around operators. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Don't try to do spacing checks for operator methods. Do this by + # replacing the troublesome characters with something else, + # preserving column position for all other characters. + # + # The replacement is done repeatedly to avoid false positives from + # operators that call operators. + while True: + match = Match(r'^(.*\boperator\b)(\S+)(\s*\(.*)$', line) + if match: + line = match.group(1) + ('_' * len(match.group(2))) + match.group(3) + else: + break + + # We allow no-spaces around = within an if: "if ( (a=Foo()) == 0 )". + # Otherwise not. Note we only check for non-spaces on *both* sides; + # sometimes people put non-spaces on one side when aligning ='s among + # many lines (not that this is behavior that I approve of...) + if ((Search(r'[\w.]=', line) or + Search(r'=[\w.]', line)) + and not Search(r'\b(if|while|for) ', line) + # Operators taken from [lex.operators] in C++11 standard. + and not Search(r'(>=|<=|==|!=|&=|\^=|\|=|\+=|\*=|\/=|\%=)', line) + and not Search(r'operator=', line)): + error(filename, linenum, 'whitespace/operators', 4, + 'Missing spaces around =') + + # It's ok not to have spaces around binary operators like + - * /, but if + # there's too little whitespace, we get concerned. It's hard to tell, + # though, so we punt on this one for now. TODO. + + # You should always have whitespace around binary operators. + # + # Check <= and >= first to avoid false positives with < and >, then + # check non-include lines for spacing around < and >. + # + # If the operator is followed by a comma, assume it's be used in a + # macro context and don't do any checks. This avoids false + # positives. + # + # Note that && is not included here. Those are checked separately + # in CheckRValueReference + match = Search(r'[^<>=!\s](==|!=|<=|>=|\|\|)[^<>=!\s,;\)]', line) + if match: + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around %s' % match.group(1)) + elif not Match(r'#.*include', line): + # Look for < that is not surrounded by spaces. This is only + # triggered if both sides are missing spaces, even though + # technically should should flag if at least one side is missing a + # space. This is done to avoid some false positives with shifts. + match = Match(r'^(.*[^\s<])<[^\s=<,]', line) + if match: + (_, _, end_pos) = CloseExpression( + clean_lines, linenum, len(match.group(1))) + if end_pos <= -1: + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around <') + + # Look for > that is not surrounded by spaces. Similar to the + # above, we only trigger if both sides are missing spaces to avoid + # false positives with shifts. + match = Match(r'^(.*[^-\s>])>[^\s=>,]', line) + if match: + (_, _, start_pos) = ReverseCloseExpression( + clean_lines, linenum, len(match.group(1))) + if start_pos <= -1: + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around >') + + # We allow no-spaces around << when used like this: 10<<20, but + # not otherwise (particularly, not when used as streams) + # + # We also allow operators following an opening parenthesis, since + # those tend to be macros that deal with operators. + match = Search(r'(operator|[^\s(<])(?:L|UL|ULL|l|ul|ull)?<<([^\s,=<])', line) + if (match and not (match.group(1).isdigit() and match.group(2).isdigit()) and + not (match.group(1) == 'operator' and match.group(2) == ';')): + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around <<') + + # We allow no-spaces around >> for almost anything. This is because + # C++11 allows ">>" to close nested templates, which accounts for + # most cases when ">>" is not followed by a space. + # + # We still warn on ">>" followed by alpha character, because that is + # likely due to ">>" being used for right shifts, e.g.: + # value >> alpha + # + # When ">>" is used to close templates, the alphanumeric letter that + # follows would be part of an identifier, and there should still be + # a space separating the template type and the identifier. + # type> alpha + match = Search(r'>>[a-zA-Z_]', line) + if match: + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around >>') + + # There shouldn't be space around unary operators + match = Search(r'(!\s|~\s|[\s]--[\s;]|[\s]\+\+[\s;])', line) + if match: + error(filename, linenum, 'whitespace/operators', 4, + 'Extra space for operator %s' % match.group(1)) + + +def CheckParenthesisSpacing(filename, clean_lines, linenum, error): + """Checks for horizontal spacing around parentheses. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # No spaces after an if, while, switch, or for + match = Search(r' (if\(|for\(|while\(|switch\()', line) + if match: + error(filename, linenum, 'whitespace/parens', 5, + 'Missing space before ( in %s' % match.group(1)) + + # For if/for/while/switch, the left and right parens should be + # consistent about how many spaces are inside the parens, and + # there should either be zero or one spaces inside the parens. + # We don't want: "if ( foo)" or "if ( foo )". + # Exception: "for ( ; foo; bar)" and "for (foo; bar; )" are allowed. + match = Search(r'\b(if|for|while|switch)\s*' + r'\(([ ]*)(.).*[^ ]+([ ]*)\)\s*{\s*$', + line) + if match: + if len(match.group(2)) != len(match.group(4)): + if not (match.group(3) == ';' and + len(match.group(2)) == 1 + len(match.group(4)) or + not match.group(2) and Search(r'\bfor\s*\(.*; \)', line)): + error(filename, linenum, 'whitespace/parens', 5, + 'Mismatching spaces inside () in %s' % match.group(1)) + if len(match.group(2)) not in [0, 1]: + error(filename, linenum, 'whitespace/parens', 5, + 'Should have zero or one spaces inside ( and ) in %s' % + match.group(1)) + + +def CheckCommaSpacing(filename, clean_lines, linenum, error): + """Checks for horizontal spacing near commas and semicolons. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + raw = clean_lines.lines_without_raw_strings + line = clean_lines.elided[linenum] + + # You should always have a space after a comma (either as fn arg or operator) + # + # This does not apply when the non-space character following the + # comma is another comma, since the only time when that happens is + # for empty macro arguments. + # + # We run this check in two passes: first pass on elided lines to + # verify that lines contain missing whitespaces, second pass on raw + # lines to confirm that those missing whitespaces are not due to + # elided comments. + if (Search(r',[^,\s]', ReplaceAll(r'\boperator\s*,\s*\(', 'F(', line)) and + Search(r',[^,\s]', raw[linenum])): + error(filename, linenum, 'whitespace/comma', 3, + 'Missing space after ,') + + # You should always have a space after a semicolon + # except for few corner cases + # TODO(unknown): clarify if 'if (1) { return 1;}' is requires one more + # space after ; + if Search(r';[^\s};\\)/]', line): + error(filename, linenum, 'whitespace/semicolon', 3, + 'Missing space after ;') + + +def CheckBracesSpacing(filename, clean_lines, linenum, error): + """Checks for horizontal spacing near commas. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Except after an opening paren, or after another opening brace (in case of + # an initializer list, for instance), you should have spaces before your + # braces. And since you should never have braces at the beginning of a line, + # this is an easy test. + match = Match(r'^(.*[^ ({>]){', line) + if match: + # Try a bit harder to check for brace initialization. This + # happens in one of the following forms: + # Constructor() : initializer_list_{} { ... } + # Constructor{}.MemberFunction() + # Type variable{}; + # FunctionCall(type{}, ...); + # LastArgument(..., type{}); + # LOG(INFO) << type{} << " ..."; + # map_of_type[{...}] = ...; + # ternary = expr ? new type{} : nullptr; + # OuterTemplate{}> + # + # We check for the character following the closing brace, and + # silence the warning if it's one of those listed above, i.e. + # "{.;,)<>]:". + # + # To account for nested initializer list, we allow any number of + # closing braces up to "{;,)<". We can't simply silence the + # warning on first sight of closing brace, because that would + # cause false negatives for things that are not initializer lists. + # Silence this: But not this: + # Outer{ if (...) { + # Inner{...} if (...){ // Missing space before { + # }; } + # + # There is a false negative with this approach if people inserted + # spurious semicolons, e.g. "if (cond){};", but we will catch the + # spurious semicolon with a separate check. + (endline, endlinenum, endpos) = CloseExpression( + clean_lines, linenum, len(match.group(1))) + trailing_text = '' + if endpos > -1: + trailing_text = endline[endpos:] + for offset in xrange(endlinenum + 1, + min(endlinenum + 3, clean_lines.NumLines() - 1)): + trailing_text += clean_lines.elided[offset] + if not Match(r'^[\s}]*[{.;,)<>\]:]', trailing_text): + error(filename, linenum, 'whitespace/braces', 5, + 'Missing space before {') + + # Make sure '} else {' has spaces. + if Search(r'}else', line): + error(filename, linenum, 'whitespace/braces', 5, + 'Missing space before else') + + # You shouldn't have a space before a semicolon at the end of the line. + # There's a special case for "for" since the style guide allows space before + # the semicolon there. + if Search(r':\s*;\s*$', line): + error(filename, linenum, 'whitespace/semicolon', 5, + 'Semicolon defining empty statement. Use {} instead.') + elif Search(r'^\s*;\s*$', line): + error(filename, linenum, 'whitespace/semicolon', 5, + 'Line contains only semicolon. If this should be an empty statement, ' + 'use {} instead.') + elif (Search(r'\s+;\s*$', line) and + not Search(r'\bfor\b', line)): + error(filename, linenum, 'whitespace/semicolon', 5, + 'Extra space before last semicolon. If this should be an empty ' + 'statement, use {} instead.') + + +def IsDecltype(clean_lines, linenum, column): + """Check if the token ending on (linenum, column) is decltype(). + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: the number of the line to check. + column: end column of the token to check. + Returns: + True if this token is decltype() expression, False otherwise. + """ + (text, _, start_col) = ReverseCloseExpression(clean_lines, linenum, column) + if start_col < 0: + return False + if Search(r'\bdecltype\s*$', text[0:start_col]): + return True + return False + + +def IsTemplateParameterList(clean_lines, linenum, column): + """Check if the token ending on (linenum, column) is the end of template<>. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: the number of the line to check. + column: end column of the token to check. + Returns: + True if this token is end of a template parameter list, False otherwise. + """ + (_, startline, startpos) = ReverseCloseExpression( + clean_lines, linenum, column) + if (startpos > -1 and + Search(r'\btemplate\s*$', clean_lines.elided[startline][0:startpos])): + return True + return False + + +def IsRValueType(typenames, clean_lines, nesting_state, linenum, column): + """Check if the token ending on (linenum, column) is a type. + + Assumes that text to the right of the column is "&&" or a function + name. + + Args: + typenames: set of type names from template-argument-list. + clean_lines: A CleansedLines instance containing the file. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + linenum: the number of the line to check. + column: end column of the token to check. + Returns: + True if this token is a type, False if we are not sure. + """ + prefix = clean_lines.elided[linenum][0:column] + + # Get one word to the left. If we failed to do so, this is most + # likely not a type, since it's unlikely that the type name and "&&" + # would be split across multiple lines. + match = Match(r'^(.*)(\b\w+|[>*)&])\s*$', prefix) + if not match: + return False + + # Check text following the token. If it's "&&>" or "&&," or "&&...", it's + # most likely a rvalue reference used inside a template. + suffix = clean_lines.elided[linenum][column:] + if Match(r'&&\s*(?:[>,]|\.\.\.)', suffix): + return True + + # Check for known types and end of templates: + # int&& variable + # vector&& variable + # + # Because this function is called recursively, we also need to + # recognize pointer and reference types: + # int* Function() + # int& Function() + if (match.group(2) in typenames or + match.group(2) in ['char', 'char16_t', 'char32_t', 'wchar_t', 'bool', + 'short', 'int', 'long', 'signed', 'unsigned', + 'float', 'double', 'void', 'auto', '>', '*', '&']): + return True + + # If we see a close parenthesis, look for decltype on the other side. + # decltype would unambiguously identify a type, anything else is + # probably a parenthesized expression and not a type. + if match.group(2) == ')': + return IsDecltype( + clean_lines, linenum, len(match.group(1)) + len(match.group(2)) - 1) + + # Check for casts and cv-qualifiers. + # match.group(1) remainder + # -------------- --------- + # const_cast< type&& + # const type&& + # type const&& + if Search(r'\b(?:const_cast\s*<|static_cast\s*<|dynamic_cast\s*<|' + r'reinterpret_cast\s*<|\w+\s)\s*$', + match.group(1)): + return True + + # Look for a preceding symbol that might help differentiate the context. + # These are the cases that would be ambiguous: + # match.group(1) remainder + # -------------- --------- + # Call ( expression && + # Declaration ( type&& + # sizeof ( type&& + # if ( expression && + # while ( expression && + # for ( type&& + # for( ; expression && + # statement ; type&& + # block { type&& + # constructor { expression && + start = linenum + line = match.group(1) + match_symbol = None + while start >= 0: + # We want to skip over identifiers and commas to get to a symbol. + # Commas are skipped so that we can find the opening parenthesis + # for function parameter lists. + match_symbol = Match(r'^(.*)([^\w\s,])[\w\s,]*$', line) + if match_symbol: + break + start -= 1 + line = clean_lines.elided[start] + + if not match_symbol: + # Probably the first statement in the file is an rvalue reference + return True + + if match_symbol.group(2) == '}': + # Found closing brace, probably an indicate of this: + # block{} type&& + return True + + if match_symbol.group(2) == ';': + # Found semicolon, probably one of these: + # for(; expression && + # statement; type&& + + # Look for the previous 'for(' in the previous lines. + before_text = match_symbol.group(1) + for i in xrange(start - 1, max(start - 6, 0), -1): + before_text = clean_lines.elided[i] + before_text + if Search(r'for\s*\([^{};]*$', before_text): + # This is the condition inside a for-loop + return False + + # Did not find a for-init-statement before this semicolon, so this + # is probably a new statement and not a condition. + return True + + if match_symbol.group(2) == '{': + # Found opening brace, probably one of these: + # block{ type&& = ... ; } + # constructor{ expression && expression } + + # Look for a closing brace or a semicolon. If we see a semicolon + # first, this is probably a rvalue reference. + line = clean_lines.elided[start][0:len(match_symbol.group(1)) + 1] + end = start + depth = 1 + while True: + for ch in line: + if ch == ';': + return True + elif ch == '{': + depth += 1 + elif ch == '}': + depth -= 1 + if depth == 0: + return False + end += 1 + if end >= clean_lines.NumLines(): + break + line = clean_lines.elided[end] + # Incomplete program? + return False + + if match_symbol.group(2) == '(': + # Opening parenthesis. Need to check what's to the left of the + # parenthesis. Look back one extra line for additional context. + before_text = match_symbol.group(1) + if linenum > 1: + before_text = clean_lines.elided[linenum - 1] + before_text + before_text = match_symbol.group(1) + + # Patterns that are likely to be types: + # [](type&& + # for (type&& + # sizeof(type&& + # operator=(type&& + # + if Search(r'(?:\]|\bfor|\bsizeof|\boperator\s*\S+\s*)\s*$', before_text): + return True + + # Patterns that are likely to be expressions: + # if (expression && + # while (expression && + # : initializer(expression && + # , initializer(expression && + # ( FunctionCall(expression && + # + FunctionCall(expression && + # + (expression && + # + # The last '+' represents operators such as '+' and '-'. + if Search(r'(?:\bif|\bwhile|[-+=%^(]*>)?\s*$', + match_symbol.group(1)) + if match_func: + # Check for constructors, which don't have return types. + if Search(r'\b(?:explicit|inline)$', match_func.group(1)): + return True + implicit_constructor = Match(r'\s*(\w+)\((?:const\s+)?(\w+)', prefix) + if (implicit_constructor and + implicit_constructor.group(1) == implicit_constructor.group(2)): + return True + return IsRValueType(typenames, clean_lines, nesting_state, linenum, + len(match_func.group(1))) + + # Nothing before the function name. If this is inside a block scope, + # this is probably a function call. + return not (nesting_state.previous_stack_top and + nesting_state.previous_stack_top.IsBlockInfo()) + + if match_symbol.group(2) == '>': + # Possibly a closing bracket, check that what's on the other side + # looks like the start of a template. + return IsTemplateParameterList( + clean_lines, start, len(match_symbol.group(1))) + + # Some other symbol, usually something like "a=b&&c". This is most + # likely not a type. + return False + + +def IsDeletedOrDefault(clean_lines, linenum): + """Check if current constructor or operator is deleted or default. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + Returns: + True if this is a deleted or default constructor. + """ + open_paren = clean_lines.elided[linenum].find('(') + if open_paren < 0: + return False + (close_line, _, close_paren) = CloseExpression( + clean_lines, linenum, open_paren) + if close_paren < 0: + return False + return Match(r'\s*=\s*(?:delete|default)\b', close_line[close_paren:]) + + +def IsRValueAllowed(clean_lines, linenum, typenames): + """Check if RValue reference is allowed on a particular line. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + typenames: set of type names from template-argument-list. + Returns: + True if line is within the region where RValue references are allowed. + """ + # Allow region marked by PUSH/POP macros + for i in xrange(linenum, 0, -1): + line = clean_lines.elided[i] + if Match(r'GOOGLE_ALLOW_RVALUE_REFERENCES_(?:PUSH|POP)', line): + if not line.endswith('PUSH'): + return False + for j in xrange(linenum, clean_lines.NumLines(), 1): + line = clean_lines.elided[j] + if Match(r'GOOGLE_ALLOW_RVALUE_REFERENCES_(?:PUSH|POP)', line): + return line.endswith('POP') + + # Allow operator= + line = clean_lines.elided[linenum] + if Search(r'\boperator\s*=\s*\(', line): + return IsDeletedOrDefault(clean_lines, linenum) + + # Allow constructors + match = Match(r'\s*(?:[\w<>]+::)*([\w<>]+)\s*::\s*([\w<>]+)\s*\(', line) + if match and match.group(1) == match.group(2): + return IsDeletedOrDefault(clean_lines, linenum) + if Search(r'\b(?:explicit|inline)\s+[\w<>]+\s*\(', line): + return IsDeletedOrDefault(clean_lines, linenum) + + if Match(r'\s*[\w<>]+\s*\(', line): + previous_line = 'ReturnType' + if linenum > 0: + previous_line = clean_lines.elided[linenum - 1] + if Match(r'^\s*$', previous_line) or Search(r'[{}:;]\s*$', previous_line): + return IsDeletedOrDefault(clean_lines, linenum) + + # Reject types not mentioned in template-argument-list + while line: + match = Match(r'^.*?(\w+)\s*&&(.*)$', line) + if not match: + break + if match.group(1) not in typenames: + return False + line = match.group(2) + + # All RValue types that were in template-argument-list should have + # been removed by now. Those were allowed, assuming that they will + # be forwarded. + # + # If there are no remaining RValue types left (i.e. types that were + # not found in template-argument-list), flag those as not allowed. + return line.find('&&') < 0 + + +def GetTemplateArgs(clean_lines, linenum): + """Find list of template arguments associated with this function declaration. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: Line number containing the start of the function declaration, + usually one line after the end of the template-argument-list. + Returns: + Set of type names, or empty set if this does not appear to have + any template parameters. + """ + # Find start of function + func_line = linenum + while func_line > 0: + line = clean_lines.elided[func_line] + if Match(r'^\s*$', line): + return set() + if line.find('(') >= 0: + break + func_line -= 1 + if func_line == 0: + return set() + + # Collapse template-argument-list into a single string + argument_list = '' + match = Match(r'^(\s*template\s*)<', clean_lines.elided[func_line]) + if match: + # template-argument-list on the same line as function name + start_col = len(match.group(1)) + _, end_line, end_col = CloseExpression(clean_lines, func_line, start_col) + if end_col > -1 and end_line == func_line: + start_col += 1 # Skip the opening bracket + argument_list = clean_lines.elided[func_line][start_col:end_col] + + elif func_line > 1: + # template-argument-list one line before function name + match = Match(r'^(.*)>\s*$', clean_lines.elided[func_line - 1]) + if match: + end_col = len(match.group(1)) + _, start_line, start_col = ReverseCloseExpression( + clean_lines, func_line - 1, end_col) + if start_col > -1: + start_col += 1 # Skip the opening bracket + while start_line < func_line - 1: + argument_list += clean_lines.elided[start_line][start_col:] + start_col = 0 + start_line += 1 + argument_list += clean_lines.elided[func_line - 1][start_col:end_col] + + if not argument_list: + return set() + + # Extract type names + typenames = set() + while True: + match = Match(r'^[,\s]*(?:typename|class)(?:\.\.\.)?\s+(\w+)(.*)$', + argument_list) + if not match: + break + typenames.add(match.group(1)) + argument_list = match.group(2) + return typenames + + +def CheckRValueReference(filename, clean_lines, linenum, nesting_state, error): + """Check for rvalue references. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + error: The function to call with any errors found. + """ + # Find lines missing spaces around &&. + # TODO(unknown): currently we don't check for rvalue references + # with spaces surrounding the && to avoid false positives with + # boolean expressions. + line = clean_lines.elided[linenum] + match = Match(r'^(.*\S)&&', line) + if not match: + match = Match(r'(.*)&&\S', line) + if (not match) or '(&&)' in line or Search(r'\boperator\s*$', match.group(1)): + return + + # Either poorly formed && or an rvalue reference, check the context + # to get a more accurate error message. Mostly we want to determine + # if what's to the left of "&&" is a type or not. + typenames = GetTemplateArgs(clean_lines, linenum) + and_pos = len(match.group(1)) + if IsRValueType(typenames, clean_lines, nesting_state, linenum, and_pos): + if not IsRValueAllowed(clean_lines, linenum, typenames): + error(filename, linenum, 'build/c++11', 3, + 'RValue references are an unapproved C++ feature.') + else: + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around &&') + + +def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error): + """Checks for additional blank line issues related to sections. + + Currently the only thing checked here is blank line before protected/private. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + class_info: A _ClassInfo objects. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + # Skip checks if the class is small, where small means 25 lines or less. + # 25 lines seems like a good cutoff since that's the usual height of + # terminals, and any class that can't fit in one screen can't really + # be considered "small". + # + # Also skip checks if we are on the first line. This accounts for + # classes that look like + # class Foo { public: ... }; + # + # If we didn't find the end of the class, last_line would be zero, + # and the check will be skipped by the first condition. + if (class_info.last_line - class_info.starting_linenum <= 24 or + linenum <= class_info.starting_linenum): + return + + matched = Match(r'\s*(public|protected|private):', clean_lines.lines[linenum]) + if matched: + # Issue warning if the line before public/protected/private was + # not a blank line, but don't do this if the previous line contains + # "class" or "struct". This can happen two ways: + # - We are at the beginning of the class. + # - We are forward-declaring an inner class that is semantically + # private, but needed to be public for implementation reasons. + # Also ignores cases where the previous line ends with a backslash as can be + # common when defining classes in C macros. + prev_line = clean_lines.lines[linenum - 1] + if (not IsBlankLine(prev_line) and + not Search(r'\b(class|struct)\b', prev_line) and + not Search(r'\\$', prev_line)): + # Try a bit harder to find the beginning of the class. This is to + # account for multi-line base-specifier lists, e.g.: + # class Derived + # : public Base { + end_class_head = class_info.starting_linenum + for i in range(class_info.starting_linenum, linenum): + if Search(r'\{\s*$', clean_lines.lines[i]): + end_class_head = i + break + if end_class_head < linenum - 1: + error(filename, linenum, 'whitespace/blank_line', 3, + '"%s:" should be preceded by a blank line' % matched.group(1)) + + +def GetPreviousNonBlankLine(clean_lines, linenum): + """Return the most recent non-blank line and its line number. + + Args: + clean_lines: A CleansedLines instance containing the file contents. + linenum: The number of the line to check. + + Returns: + A tuple with two elements. The first element is the contents of the last + non-blank line before the current line, or the empty string if this is the + first non-blank line. The second is the line number of that line, or -1 + if this is the first non-blank line. + """ + + prevlinenum = linenum - 1 + while prevlinenum >= 0: + prevline = clean_lines.elided[prevlinenum] + if not IsBlankLine(prevline): # if not a blank line... + return (prevline, prevlinenum) + prevlinenum -= 1 + return ('', -1) + + +def CheckBraces(filename, clean_lines, linenum, error): + """Looks for misplaced braces (e.g. at the end of line). + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + + line = clean_lines.elided[linenum] # get rid of comments and strings + + if Match(r'\s*{\s*$', line): + # We allow an open brace to start a line in the case where someone is using + # braces in a block to explicitly create a new scope, which is commonly used + # to control the lifetime of stack-allocated variables. Braces are also + # used for brace initializers inside function calls. We don't detect this + # perfectly: we just don't complain if the last non-whitespace character on + # the previous non-blank line is ',', ';', ':', '(', '{', or '}', or if the + # previous line starts a preprocessor block. + prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0] + if (not Search(r'[,;:}{(]\s*$', prevline) and + not Match(r'\s*#', prevline)): + error(filename, linenum, 'whitespace/braces', 4, + '{ should almost always be at the end of the previous line') + + # An else clause should be on the same line as the preceding closing brace. + if Match(r'\s*else\b\s*(?:if\b|\{|$)', line): + prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0] + if Match(r'\s*}\s*$', prevline): + error(filename, linenum, 'whitespace/newline', 4, + 'An else should appear on the same line as the preceding }') + + # If braces come on one side of an else, they should be on both. + # However, we have to worry about "else if" that spans multiple lines! + if Search(r'else if\s*\(', line): # could be multi-line if + brace_on_left = bool(Search(r'}\s*else if\s*\(', line)) + # find the ( after the if + pos = line.find('else if') + pos = line.find('(', pos) + if pos > 0: + (endline, _, endpos) = CloseExpression(clean_lines, linenum, pos) + brace_on_right = endline[endpos:].find('{') != -1 + if brace_on_left != brace_on_right: # must be brace after if + error(filename, linenum, 'readability/braces', 5, + 'If an else has a brace on one side, it should have it on both') + elif Search(r'}\s*else[^{]*$', line) or Match(r'[^}]*else\s*{', line): + error(filename, linenum, 'readability/braces', 5, + 'If an else has a brace on one side, it should have it on both') + + # Likewise, an else should never have the else clause on the same line + if Search(r'\belse [^\s{]', line) and not Search(r'\belse if\b', line): + error(filename, linenum, 'whitespace/newline', 4, + 'Else clause should never be on same line as else (use 2 lines)') + + # In the same way, a do/while should never be on one line + if Match(r'\s*do [^\s{]', line): + error(filename, linenum, 'whitespace/newline', 4, + 'do/while clauses should not be on a single line') + + # Check single-line if/else bodies. The style guide says 'curly braces are not + # required for single-line statements'. We additionally allow multi-line, + # single statements, but we reject anything with more than one semicolon in + # it. This means that the first semicolon after the if should be at the end of + # its line, and the line after that should have an indent level equal to or + # lower than the if. We also check for ambiguous if/else nesting without + # braces. + if_else_match = Search(r'\b(if\s*\(|else\b)', line) + if if_else_match and not Match(r'\s*#', line): + if_indent = GetIndentLevel(line) + endline, endlinenum, endpos = line, linenum, if_else_match.end() + if_match = Search(r'\bif\s*\(', line) + if if_match: + # This could be a multiline if condition, so find the end first. + pos = if_match.end() - 1 + (endline, endlinenum, endpos) = CloseExpression(clean_lines, linenum, pos) + # Check for an opening brace, either directly after the if or on the next + # line. If found, this isn't a single-statement conditional. + if (not Match(r'\s*{', endline[endpos:]) + and not (Match(r'\s*$', endline[endpos:]) + and endlinenum < (len(clean_lines.elided) - 1) + and Match(r'\s*{', clean_lines.elided[endlinenum + 1]))): + while (endlinenum < len(clean_lines.elided) + and ';' not in clean_lines.elided[endlinenum][endpos:]): + endlinenum += 1 + endpos = 0 + if endlinenum < len(clean_lines.elided): + endline = clean_lines.elided[endlinenum] + # We allow a mix of whitespace and closing braces (e.g. for one-liner + # methods) and a single \ after the semicolon (for macros) + endpos = endline.find(';') + if not Match(r';[\s}]*(\\?)$', endline[endpos:]): + # Semicolon isn't the last character, there's something trailing. + # Output a warning if the semicolon is not contained inside + # a lambda expression. + if not Match(r'^[^{};]*\[[^\[\]]*\][^{}]*\{[^{}]*\}\s*\)*[;,]\s*$', + endline): + error(filename, linenum, 'readability/braces', 4, + 'If/else bodies with multiple statements require braces') + elif endlinenum < len(clean_lines.elided) - 1: + # Make sure the next line is dedented + next_line = clean_lines.elided[endlinenum + 1] + next_indent = GetIndentLevel(next_line) + # With ambiguous nested if statements, this will error out on the + # if that *doesn't* match the else, regardless of whether it's the + # inner one or outer one. + if (if_match and Match(r'\s*else\b', next_line) + and next_indent != if_indent): + error(filename, linenum, 'readability/braces', 4, + 'Else clause should be indented at the same level as if. ' + 'Ambiguous nested if/else chains require braces.') + elif next_indent > if_indent: + error(filename, linenum, 'readability/braces', 4, + 'If/else bodies with multiple statements require braces') + + +def CheckTrailingSemicolon(filename, clean_lines, linenum, error): + """Looks for redundant trailing semicolon. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + + line = clean_lines.elided[linenum] + + # Block bodies should not be followed by a semicolon. Due to C++11 + # brace initialization, there are more places where semicolons are + # required than not, so we use a whitelist approach to check these + # rather than a blacklist. These are the places where "};" should + # be replaced by just "}": + # 1. Some flavor of block following closing parenthesis: + # for (;;) {}; + # while (...) {}; + # switch (...) {}; + # Function(...) {}; + # if (...) {}; + # if (...) else if (...) {}; + # + # 2. else block: + # if (...) else {}; + # + # 3. const member function: + # Function(...) const {}; + # + # 4. Block following some statement: + # x = 42; + # {}; + # + # 5. Block at the beginning of a function: + # Function(...) { + # {}; + # } + # + # Note that naively checking for the preceding "{" will also match + # braces inside multi-dimensional arrays, but this is fine since + # that expression will not contain semicolons. + # + # 6. Block following another block: + # while (true) {} + # {}; + # + # 7. End of namespaces: + # namespace {}; + # + # These semicolons seems far more common than other kinds of + # redundant semicolons, possibly due to people converting classes + # to namespaces. For now we do not warn for this case. + # + # Try matching case 1 first. + match = Match(r'^(.*\)\s*)\{', line) + if match: + # Matched closing parenthesis (case 1). Check the token before the + # matching opening parenthesis, and don't warn if it looks like a + # macro. This avoids these false positives: + # - macro that defines a base class + # - multi-line macro that defines a base class + # - macro that defines the whole class-head + # + # But we still issue warnings for macros that we know are safe to + # warn, specifically: + # - TEST, TEST_F, TEST_P, MATCHER, MATCHER_P + # - TYPED_TEST + # - INTERFACE_DEF + # - EXCLUSIVE_LOCKS_REQUIRED, SHARED_LOCKS_REQUIRED, LOCKS_EXCLUDED: + # + # We implement a whitelist of safe macros instead of a blacklist of + # unsafe macros, even though the latter appears less frequently in + # google code and would have been easier to implement. This is because + # the downside for getting the whitelist wrong means some extra + # semicolons, while the downside for getting the blacklist wrong + # would result in compile errors. + # + # In addition to macros, we also don't want to warn on + # - Compound literals + # - Lambdas + # - alignas specifier with anonymous structs: + closing_brace_pos = match.group(1).rfind(')') + opening_parenthesis = ReverseCloseExpression( + clean_lines, linenum, closing_brace_pos) + if opening_parenthesis[2] > -1: + line_prefix = opening_parenthesis[0][0:opening_parenthesis[2]] + macro = Search(r'\b([A-Z_]+)\s*$', line_prefix) + func = Match(r'^(.*\])\s*$', line_prefix) + if ((macro and + macro.group(1) not in ( + 'TEST', 'TEST_F', 'MATCHER', 'MATCHER_P', 'TYPED_TEST', + 'EXCLUSIVE_LOCKS_REQUIRED', 'SHARED_LOCKS_REQUIRED', + 'LOCKS_EXCLUDED', 'INTERFACE_DEF')) or + (func and not Search(r'\boperator\s*\[\s*\]', func.group(1))) or + Search(r'\b(?:struct|union)\s+alignas\s*$', line_prefix) or + Search(r'\s+=\s*$', line_prefix)): + match = None + if (match and + opening_parenthesis[1] > 1 and + Search(r'\]\s*$', clean_lines.elided[opening_parenthesis[1] - 1])): + # Multi-line lambda-expression + match = None + + else: + # Try matching cases 2-3. + match = Match(r'^(.*(?:else|\)\s*const)\s*)\{', line) + if not match: + # Try matching cases 4-6. These are always matched on separate lines. + # + # Note that we can't simply concatenate the previous line to the + # current line and do a single match, otherwise we may output + # duplicate warnings for the blank line case: + # if (cond) { + # // blank line + # } + prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0] + if prevline and Search(r'[;{}]\s*$', prevline): + match = Match(r'^(\s*)\{', line) + + # Check matching closing brace + if match: + (endline, endlinenum, endpos) = CloseExpression( + clean_lines, linenum, len(match.group(1))) + if endpos > -1 and Match(r'^\s*;', endline[endpos:]): + # Current {} pair is eligible for semicolon check, and we have found + # the redundant semicolon, output warning here. + # + # Note: because we are scanning forward for opening braces, and + # outputting warnings for the matching closing brace, if there are + # nested blocks with trailing semicolons, we will get the error + # messages in reversed order. + error(filename, endlinenum, 'readability/braces', 4, + "You don't need a ; after a }") + + +def CheckEmptyBlockBody(filename, clean_lines, linenum, error): + """Look for empty loop/conditional body with only a single semicolon. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + + # Search for loop keywords at the beginning of the line. Because only + # whitespaces are allowed before the keywords, this will also ignore most + # do-while-loops, since those lines should start with closing brace. + # + # We also check "if" blocks here, since an empty conditional block + # is likely an error. + line = clean_lines.elided[linenum] + matched = Match(r'\s*(for|while|if)\s*\(', line) + if matched: + # Find the end of the conditional expression + (end_line, end_linenum, end_pos) = CloseExpression( + clean_lines, linenum, line.find('(')) + + # Output warning if what follows the condition expression is a semicolon. + # No warning for all other cases, including whitespace or newline, since we + # have a separate check for semicolons preceded by whitespace. + if end_pos >= 0 and Match(r';', end_line[end_pos:]): + if matched.group(1) == 'if': + error(filename, end_linenum, 'whitespace/empty_conditional_body', 5, + 'Empty conditional bodies should use {}') + else: + error(filename, end_linenum, 'whitespace/empty_loop_body', 5, + 'Empty loop bodies should use {} or continue') + + +def FindCheckMacro(line): + """Find a replaceable CHECK-like macro. + + Args: + line: line to search on. + Returns: + (macro name, start position), or (None, -1) if no replaceable + macro is found. + """ + for macro in _CHECK_MACROS: + i = line.find(macro) + if i >= 0: + # Find opening parenthesis. Do a regular expression match here + # to make sure that we are matching the expected CHECK macro, as + # opposed to some other macro that happens to contain the CHECK + # substring. + matched = Match(r'^(.*\b' + macro + r'\s*)\(', line) + if not matched: + continue + return (macro, len(matched.group(1))) + return (None, -1) + + +def CheckCheck(filename, clean_lines, linenum, error): + """Checks the use of CHECK and EXPECT macros. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + + # Decide the set of replacement macros that should be suggested + lines = clean_lines.elided + (check_macro, start_pos) = FindCheckMacro(lines[linenum]) + if not check_macro: + return + + # Find end of the boolean expression by matching parentheses + (last_line, end_line, end_pos) = CloseExpression( + clean_lines, linenum, start_pos) + if end_pos < 0: + return + + # If the check macro is followed by something other than a + # semicolon, assume users will log their own custom error messages + # and don't suggest any replacements. + if not Match(r'\s*;', last_line[end_pos:]): + return + + if linenum == end_line: + expression = lines[linenum][start_pos + 1:end_pos - 1] + else: + expression = lines[linenum][start_pos + 1:] + for i in xrange(linenum + 1, end_line): + expression += lines[i] + expression += last_line[0:end_pos - 1] + + # Parse expression so that we can take parentheses into account. + # This avoids false positives for inputs like "CHECK((a < 4) == b)", + # which is not replaceable by CHECK_LE. + lhs = '' + rhs = '' + operator = None + while expression: + matched = Match(r'^\s*(<<|<<=|>>|>>=|->\*|->|&&|\|\||' + r'==|!=|>=|>|<=|<|\()(.*)$', expression) + if matched: + token = matched.group(1) + if token == '(': + # Parenthesized operand + expression = matched.group(2) + (end, _) = FindEndOfExpressionInLine(expression, 0, ['(']) + if end < 0: + return # Unmatched parenthesis + lhs += '(' + expression[0:end] + expression = expression[end:] + elif token in ('&&', '||'): + # Logical and/or operators. This means the expression + # contains more than one term, for example: + # CHECK(42 < a && a < b); + # + # These are not replaceable with CHECK_LE, so bail out early. + return + elif token in ('<<', '<<=', '>>', '>>=', '->*', '->'): + # Non-relational operator + lhs += token + expression = matched.group(2) + else: + # Relational operator + operator = token + rhs = matched.group(2) + break + else: + # Unparenthesized operand. Instead of appending to lhs one character + # at a time, we do another regular expression match to consume several + # characters at once if possible. Trivial benchmark shows that this + # is more efficient when the operands are longer than a single + # character, which is generally the case. + matched = Match(r'^([^-=!<>()&|]+)(.*)$', expression) + if not matched: + matched = Match(r'^(\s*\S)(.*)$', expression) + if not matched: + break + lhs += matched.group(1) + expression = matched.group(2) + + # Only apply checks if we got all parts of the boolean expression + if not (lhs and operator and rhs): + return + + # Check that rhs do not contain logical operators. We already know + # that lhs is fine since the loop above parses out && and ||. + if rhs.find('&&') > -1 or rhs.find('||') > -1: + return + + # At least one of the operands must be a constant literal. This is + # to avoid suggesting replacements for unprintable things like + # CHECK(variable != iterator) + # + # The following pattern matches decimal, hex integers, strings, and + # characters (in that order). + lhs = lhs.strip() + rhs = rhs.strip() + match_constant = r'^([-+]?(\d+|0[xX][0-9a-fA-F]+)[lLuU]{0,3}|".*"|\'.*\')$' + if Match(match_constant, lhs) or Match(match_constant, rhs): + # Note: since we know both lhs and rhs, we can provide a more + # descriptive error message like: + # Consider using CHECK_EQ(x, 42) instead of CHECK(x == 42) + # Instead of: + # Consider using CHECK_EQ instead of CHECK(a == b) + # + # We are still keeping the less descriptive message because if lhs + # or rhs gets long, the error message might become unreadable. + error(filename, linenum, 'readability/check', 2, + 'Consider using %s instead of %s(a %s b)' % ( + _CHECK_REPLACEMENT[check_macro][operator], + check_macro, operator)) + + +def CheckAltTokens(filename, clean_lines, linenum, error): + """Check alternative keywords being used in boolean expressions. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Avoid preprocessor lines + if Match(r'^\s*#', line): + return + + # Last ditch effort to avoid multi-line comments. This will not help + # if the comment started before the current line or ended after the + # current line, but it catches most of the false positives. At least, + # it provides a way to workaround this warning for people who use + # multi-line comments in preprocessor macros. + # + # TODO(unknown): remove this once cpplint has better support for + # multi-line comments. + if line.find('/*') >= 0 or line.find('*/') >= 0: + return + + for match in _ALT_TOKEN_REPLACEMENT_PATTERN.finditer(line): + error(filename, linenum, 'readability/alt_tokens', 2, + 'Use operator %s instead of %s' % ( + _ALT_TOKEN_REPLACEMENT[match.group(1)], match.group(1))) + + +def GetLineWidth(line): + """Determines the width of the line in column positions. + + Args: + line: A string, which may be a Unicode string. + + Returns: + The width of the line in column positions, accounting for Unicode + combining characters and wide characters. + """ + if isinstance(line, unicode): + width = 0 + for uc in unicodedata.normalize('NFC', line): + if unicodedata.east_asian_width(uc) in ('W', 'F'): + width += 2 + elif not unicodedata.combining(uc): + width += 1 + return width + else: + return len(line) + + +def CheckStyle(filename, clean_lines, linenum, file_extension, nesting_state, + error): + """Checks rules from the 'C++ style rules' section of cppguide.html. + + Most of these rules are hard to test (naming, comment style), but we + do what we can. In particular we check for 2-space indents, line lengths, + tab usage, spaces inside code, etc. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + file_extension: The extension (without the dot) of the filename. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + error: The function to call with any errors found. + """ + + # Don't use "elided" lines here, otherwise we can't check commented lines. + # Don't want to use "raw" either, because we don't want to check inside C++11 + # raw strings, + raw_lines = clean_lines.lines_without_raw_strings + line = raw_lines[linenum] + + if line.find('\t') != -1: + error(filename, linenum, 'whitespace/tab', 1, + 'Tab found; better to use spaces') + + # One or three blank spaces at the beginning of the line is weird; it's + # hard to reconcile that with 2-space indents. + # NOTE: here are the conditions rob pike used for his tests. Mine aren't + # as sophisticated, but it may be worth becoming so: RLENGTH==initial_spaces + # if(RLENGTH > 20) complain = 0; + # if(match($0, " +(error|private|public|protected):")) complain = 0; + # if(match(prev, "&& *$")) complain = 0; + # if(match(prev, "\\|\\| *$")) complain = 0; + # if(match(prev, "[\",=><] *$")) complain = 0; + # if(match($0, " <<")) complain = 0; + # if(match(prev, " +for \\(")) complain = 0; + # if(prevodd && match(prevprev, " +for \\(")) complain = 0; + scope_or_label_pattern = r'\s*\w+\s*:\s*\\?$' + classinfo = nesting_state.InnermostClass() + initial_spaces = 0 + cleansed_line = clean_lines.elided[linenum] + while initial_spaces < len(line) and line[initial_spaces] == ' ': + initial_spaces += 1 + if line and line[-1].isspace(): + error(filename, linenum, 'whitespace/end_of_line', 4, + 'Line ends in whitespace. Consider deleting these extra spaces.') + # There are certain situations we allow one space, notably for + # section labels, and also lines containing multi-line raw strings. + elif ((initial_spaces == 1 or initial_spaces == 3) and + not Match(scope_or_label_pattern, cleansed_line) and + not (clean_lines.raw_lines[linenum] != line and + Match(r'^\s*""', line))): + error(filename, linenum, 'whitespace/indent', 3, + 'Weird number of spaces at line-start. ' + 'Are you using a 2-space indent?') + + # Check if the line is a header guard. + is_header_guard = False + if file_extension == 'h': + cppvar = GetHeaderGuardCPPVariable(filename) + if (line.startswith('#ifndef %s' % cppvar) or + line.startswith('#define %s' % cppvar) or + line.startswith('#endif // %s' % cppvar)): + is_header_guard = True + # #include lines and header guards can be long, since there's no clean way to + # split them. + # + # URLs can be long too. It's possible to split these, but it makes them + # harder to cut&paste. + # + # The "$Id:...$" comment may also get very long without it being the + # developers fault. + if (not line.startswith('#include') and not is_header_guard and + not Match(r'^\s*//.*http(s?)://\S*$', line) and + not Match(r'^// \$Id:.*#[0-9]+ \$$', line)): + line_width = GetLineWidth(line) + extended_length = int((_line_length * 1.25)) + if line_width > extended_length: + error(filename, linenum, 'whitespace/line_length', 4, + 'Lines should very rarely be longer than %i characters' % + extended_length) + elif line_width > _line_length: + error(filename, linenum, 'whitespace/line_length', 2, + 'Lines should be <= %i characters long' % _line_length) + + if (cleansed_line.count(';') > 1 and + # for loops are allowed two ;'s (and may run over two lines). + cleansed_line.find('for') == -1 and + (GetPreviousNonBlankLine(clean_lines, linenum)[0].find('for') == -1 or + GetPreviousNonBlankLine(clean_lines, linenum)[0].find(';') != -1) and + # It's ok to have many commands in a switch case that fits in 1 line + not ((cleansed_line.find('case ') != -1 or + cleansed_line.find('default:') != -1) and + cleansed_line.find('break;') != -1)): + error(filename, linenum, 'whitespace/newline', 0, + 'More than one command on the same line') + + # Some more style checks + CheckBraces(filename, clean_lines, linenum, error) + CheckTrailingSemicolon(filename, clean_lines, linenum, error) + CheckEmptyBlockBody(filename, clean_lines, linenum, error) + CheckAccess(filename, clean_lines, linenum, nesting_state, error) + CheckSpacing(filename, clean_lines, linenum, nesting_state, error) + CheckOperatorSpacing(filename, clean_lines, linenum, error) + CheckParenthesisSpacing(filename, clean_lines, linenum, error) + CheckCommaSpacing(filename, clean_lines, linenum, error) + CheckBracesSpacing(filename, clean_lines, linenum, error) + CheckSpacingForFunctionCall(filename, clean_lines, linenum, error) + CheckRValueReference(filename, clean_lines, linenum, nesting_state, error) + CheckCheck(filename, clean_lines, linenum, error) + CheckAltTokens(filename, clean_lines, linenum, error) + classinfo = nesting_state.InnermostClass() + if classinfo: + CheckSectionSpacing(filename, clean_lines, classinfo, linenum, error) + + +_RE_PATTERN_INCLUDE = re.compile(r'^\s*#\s*include\s*([<"])([^>"]*)[>"].*$') +# Matches the first component of a filename delimited by -s and _s. That is: +# _RE_FIRST_COMPONENT.match('foo').group(0) == 'foo' +# _RE_FIRST_COMPONENT.match('foo.cc').group(0) == 'foo' +# _RE_FIRST_COMPONENT.match('foo-bar_baz.cc').group(0) == 'foo' +# _RE_FIRST_COMPONENT.match('foo_bar-baz.cc').group(0) == 'foo' +_RE_FIRST_COMPONENT = re.compile(r'^[^-_.]+') + + +def _DropCommonSuffixes(filename): + """Drops common suffixes like _test.cc or -inl.h from filename. + + For example: + >>> _DropCommonSuffixes('foo/foo-inl.h') + 'foo/foo' + >>> _DropCommonSuffixes('foo/bar/foo.cc') + 'foo/bar/foo' + >>> _DropCommonSuffixes('foo/foo_internal.h') + 'foo/foo' + >>> _DropCommonSuffixes('foo/foo_unusualinternal.h') + 'foo/foo_unusualinternal' + + Args: + filename: The input filename. + + Returns: + The filename with the common suffix removed. + """ + for suffix in ('test.cc', 'regtest.cc', 'unittest.cc', + 'inl.h', 'impl.h', 'internal.h'): + if (filename.endswith(suffix) and len(filename) > len(suffix) and + filename[-len(suffix) - 1] in ('-', '_')): + return filename[:-len(suffix) - 1] + return os.path.splitext(filename)[0] + + +def _IsTestFilename(filename): + """Determines if the given filename has a suffix that identifies it as a test. + + Args: + filename: The input filename. + + Returns: + True if 'filename' looks like a test, False otherwise. + """ + if (filename.endswith('_test.cc') or + filename.endswith('_unittest.cc') or + filename.endswith('_regtest.cc')): + return True + else: + return False + + +def _ClassifyInclude(fileinfo, include, is_system): + """Figures out what kind of header 'include' is. + + Args: + fileinfo: The current file cpplint is running over. A FileInfo instance. + include: The path to a #included file. + is_system: True if the #include used <> rather than "". + + Returns: + One of the _XXX_HEADER constants. + + For example: + >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'stdio.h', True) + _C_SYS_HEADER + >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'string', True) + _CPP_SYS_HEADER + >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/foo.h', False) + _LIKELY_MY_HEADER + >>> _ClassifyInclude(FileInfo('foo/foo_unknown_extension.cc'), + ... 'bar/foo_other_ext.h', False) + _POSSIBLE_MY_HEADER + >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/bar.h', False) + _OTHER_HEADER + """ + # This is a list of all standard c++ header files, except + # those already checked for above. + is_cpp_h = include in _CPP_HEADERS + + if is_system: + if is_cpp_h: + return _CPP_SYS_HEADER + else: + return _C_SYS_HEADER + + # If the target file and the include we're checking share a + # basename when we drop common extensions, and the include + # lives in . , then it's likely to be owned by the target file. + target_dir, target_base = ( + os.path.split(_DropCommonSuffixes(fileinfo.RepositoryName()))) + include_dir, include_base = os.path.split(_DropCommonSuffixes(include)) + if target_base == include_base and ( + include_dir == target_dir or + include_dir == os.path.normpath(target_dir + '/../public')): + return _LIKELY_MY_HEADER + + # If the target and include share some initial basename + # component, it's possible the target is implementing the + # include, so it's allowed to be first, but we'll never + # complain if it's not there. + target_first_component = _RE_FIRST_COMPONENT.match(target_base) + include_first_component = _RE_FIRST_COMPONENT.match(include_base) + if (target_first_component and include_first_component and + target_first_component.group(0) == + include_first_component.group(0)): + return _POSSIBLE_MY_HEADER + + return _OTHER_HEADER + + + +def CheckIncludeLine(filename, clean_lines, linenum, include_state, error): + """Check rules that are applicable to #include lines. + + Strings on #include lines are NOT removed from elided line, to make + certain tasks easier. However, to prevent false positives, checks + applicable to #include lines in CheckLanguage must be put here. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + include_state: An _IncludeState instance in which the headers are inserted. + error: The function to call with any errors found. + """ + fileinfo = FileInfo(filename) + line = clean_lines.lines[linenum] + + # "include" should use the new style "foo/bar.h" instead of just "bar.h" + # Only do this check if the included header follows google naming + # conventions. If not, assume that it's a 3rd party API that + # requires special include conventions. + # + # We also make an exception for Lua headers, which follow google + # naming convention but not the include convention. + match = Match(r'#include\s*"([^/]+\.h)"', line) + if match and not _THIRD_PARTY_HEADERS_PATTERN.match(match.group(1)): + error(filename, linenum, 'build/include', 4, + 'Include the directory when naming .h files') + + # we shouldn't include a file more than once. actually, there are a + # handful of instances where doing so is okay, but in general it's + # not. + match = _RE_PATTERN_INCLUDE.search(line) + if match: + include = match.group(2) + is_system = (match.group(1) == '<') + duplicate_line = include_state.FindHeader(include) + if duplicate_line >= 0: + error(filename, linenum, 'build/include', 4, + '"%s" already included at %s:%s' % + (include, filename, duplicate_line)) + elif (include.endswith('.cc') and + os.path.dirname(fileinfo.RepositoryName()) != os.path.dirname(include)): + error(filename, linenum, 'build/include', 4, + 'Do not include .cc files from other packages') + elif not _THIRD_PARTY_HEADERS_PATTERN.match(include): + include_state.include_list[-1].append((include, linenum)) + + # We want to ensure that headers appear in the right order: + # 1) for foo.cc, foo.h (preferred location) + # 2) c system files + # 3) cpp system files + # 4) for foo.cc, foo.h (deprecated location) + # 5) other google headers + # + # We classify each include statement as one of those 5 types + # using a number of techniques. The include_state object keeps + # track of the highest type seen, and complains if we see a + # lower type after that. + error_message = include_state.CheckNextIncludeOrder( + _ClassifyInclude(fileinfo, include, is_system)) + if error_message: + error(filename, linenum, 'build/include_order', 4, + '%s. Should be: %s.h, c system, c++ system, other.' % + (error_message, fileinfo.BaseName())) + canonical_include = include_state.CanonicalizeAlphabeticalOrder(include) + if not include_state.IsInAlphabeticalOrder( + clean_lines, linenum, canonical_include): + error(filename, linenum, 'build/include_alpha', 4, + 'Include "%s" not in alphabetical order' % include) + include_state.SetLastHeader(canonical_include) + + + +def _GetTextInside(text, start_pattern): + r"""Retrieves all the text between matching open and close parentheses. + + Given a string of lines and a regular expression string, retrieve all the text + following the expression and between opening punctuation symbols like + (, [, or {, and the matching close-punctuation symbol. This properly nested + occurrences of the punctuations, so for the text like + printf(a(), b(c())); + a call to _GetTextInside(text, r'printf\(') will return 'a(), b(c())'. + start_pattern must match string having an open punctuation symbol at the end. + + Args: + text: The lines to extract text. Its comments and strings must be elided. + It can be single line and can span multiple lines. + start_pattern: The regexp string indicating where to start extracting + the text. + Returns: + The extracted text. + None if either the opening string or ending punctuation could not be found. + """ + # TODO(unknown): Audit cpplint.py to see what places could be profitably + # rewritten to use _GetTextInside (and use inferior regexp matching today). + + # Give opening punctuations to get the matching close-punctuations. + matching_punctuation = {'(': ')', '{': '}', '[': ']'} + closing_punctuation = set(matching_punctuation.itervalues()) + + # Find the position to start extracting text. + match = re.search(start_pattern, text, re.M) + if not match: # start_pattern not found in text. + return None + start_position = match.end(0) + + assert start_position > 0, ( + 'start_pattern must ends with an opening punctuation.') + assert text[start_position - 1] in matching_punctuation, ( + 'start_pattern must ends with an opening punctuation.') + # Stack of closing punctuations we expect to have in text after position. + punctuation_stack = [matching_punctuation[text[start_position - 1]]] + position = start_position + while punctuation_stack and position < len(text): + if text[position] == punctuation_stack[-1]: + punctuation_stack.pop() + elif text[position] in closing_punctuation: + # A closing punctuation without matching opening punctuations. + return None + elif text[position] in matching_punctuation: + punctuation_stack.append(matching_punctuation[text[position]]) + position += 1 + if punctuation_stack: + # Opening punctuations left without matching close-punctuations. + return None + # punctuations match. + return text[start_position:position - 1] + + +# Patterns for matching call-by-reference parameters. +# +# Supports nested templates up to 2 levels deep using this messy pattern: +# < (?: < (?: < [^<>]* +# > +# | [^<>] )* +# > +# | [^<>] )* +# > +_RE_PATTERN_IDENT = r'[_a-zA-Z]\w*' # =~ [[:alpha:]][[:alnum:]]* +_RE_PATTERN_TYPE = ( + r'(?:const\s+)?(?:typename\s+|class\s+|struct\s+|union\s+|enum\s+)?' + r'(?:\w|' + r'\s*<(?:<(?:<[^<>]*>|[^<>])*>|[^<>])*>|' + r'::)+') +# A call-by-reference parameter ends with '& identifier'. +_RE_PATTERN_REF_PARAM = re.compile( + r'(' + _RE_PATTERN_TYPE + r'(?:\s*(?:\bconst\b|[*]))*\s*' + r'&\s*' + _RE_PATTERN_IDENT + r')\s*(?:=[^,()]+)?[,)]') +# A call-by-const-reference parameter either ends with 'const& identifier' +# or looks like 'const type& identifier' when 'type' is atomic. +_RE_PATTERN_CONST_REF_PARAM = ( + r'(?:.*\s*\bconst\s*&\s*' + _RE_PATTERN_IDENT + + r'|const\s+' + _RE_PATTERN_TYPE + r'\s*&\s*' + _RE_PATTERN_IDENT + r')') + + +def CheckLanguage(filename, clean_lines, linenum, file_extension, + include_state, nesting_state, error): + """Checks rules from the 'C++ language rules' section of cppguide.html. + + Some of these rules are hard to test (function overloading, using + uint32 inappropriately), but we do the best we can. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + file_extension: The extension (without the dot) of the filename. + include_state: An _IncludeState instance in which the headers are inserted. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + error: The function to call with any errors found. + """ + # If the line is empty or consists of entirely a comment, no need to + # check it. + line = clean_lines.elided[linenum] + if not line: + return + + match = _RE_PATTERN_INCLUDE.search(line) + if match: + CheckIncludeLine(filename, clean_lines, linenum, include_state, error) + return + + # Reset include state across preprocessor directives. This is meant + # to silence warnings for conditional includes. + match = Match(r'^\s*#\s*(if|ifdef|ifndef|elif|else|endif)\b', line) + if match: + include_state.ResetSection(match.group(1)) + + # Make Windows paths like Unix. + fullname = os.path.abspath(filename).replace('\\', '/') + + # Perform other checks now that we are sure that this is not an include line + CheckCasts(filename, clean_lines, linenum, error) + CheckGlobalStatic(filename, clean_lines, linenum, error) + CheckPrintf(filename, clean_lines, linenum, error) + + if file_extension == 'h': + # TODO(unknown): check that 1-arg constructors are explicit. + # How to tell it's a constructor? + # (handled in CheckForNonStandardConstructs for now) + # TODO(unknown): check that classes declare or disable copy/assign + # (level 1 error) + pass + + # Check if people are using the verboten C basic types. The only exception + # we regularly allow is "unsigned short port" for port. + if Search(r'\bshort port\b', line): + if not Search(r'\bunsigned short port\b', line): + error(filename, linenum, 'runtime/int', 4, + 'Use "unsigned short" for ports, not "short"') + else: + match = Search(r'\b(short|long(?! +double)|long long)\b', line) + if match: + error(filename, linenum, 'runtime/int', 4, + 'Use int16/int64/etc, rather than the C type %s' % match.group(1)) + + # Check if some verboten operator overloading is going on + # TODO(unknown): catch out-of-line unary operator&: + # class X {}; + # int operator&(const X& x) { return 42; } // unary operator& + # The trick is it's hard to tell apart from binary operator&: + # class Y { int operator&(const Y& x) { return 23; } }; // binary operator& + if Search(r'\boperator\s*&\s*\(\s*\)', line): + error(filename, linenum, 'runtime/operator', 4, + 'Unary operator& is dangerous. Do not use it.') + + # Check for suspicious usage of "if" like + # } if (a == b) { + if Search(r'\}\s*if\s*\(', line): + error(filename, linenum, 'readability/braces', 4, + 'Did you mean "else if"? If not, start a new line for "if".') + + # Check for potential format string bugs like printf(foo). + # We constrain the pattern not to pick things like DocidForPrintf(foo). + # Not perfect but it can catch printf(foo.c_str()) and printf(foo->c_str()) + # TODO(unknown): Catch the following case. Need to change the calling + # convention of the whole function to process multiple line to handle it. + # printf( + # boy_this_is_a_really_long_variable_that_cannot_fit_on_the_prev_line); + printf_args = _GetTextInside(line, r'(?i)\b(string)?printf\s*\(') + if printf_args: + match = Match(r'([\w.\->()]+)$', printf_args) + if match and match.group(1) != '__VA_ARGS__': + function_name = re.search(r'\b((?:string)?printf)\s*\(', + line, re.I).group(1) + error(filename, linenum, 'runtime/printf', 4, + 'Potential format string bug. Do %s("%%s", %s) instead.' + % (function_name, match.group(1))) + + # Check for potential memset bugs like memset(buf, sizeof(buf), 0). + match = Search(r'memset\s*\(([^,]*),\s*([^,]*),\s*0\s*\)', line) + if match and not Match(r"^''|-?[0-9]+|0x[0-9A-Fa-f]$", match.group(2)): + error(filename, linenum, 'runtime/memset', 4, + 'Did you mean "memset(%s, 0, %s)"?' + % (match.group(1), match.group(2))) + + if Search(r'\busing namespace\b', line): + error(filename, linenum, 'build/namespaces', 5, + 'Do not use namespace using-directives. ' + 'Use using-declarations instead.') + + # Detect variable-length arrays. + match = Match(r'\s*(.+::)?(\w+) [a-z]\w*\[(.+)];', line) + if (match and match.group(2) != 'return' and match.group(2) != 'delete' and + match.group(3).find(']') == -1): + # Split the size using space and arithmetic operators as delimiters. + # If any of the resulting tokens are not compile time constants then + # report the error. + tokens = re.split(r'\s|\+|\-|\*|\/|<<|>>]', match.group(3)) + is_const = True + skip_next = False + for tok in tokens: + if skip_next: + skip_next = False + continue + + if Search(r'sizeof\(.+\)', tok): continue + if Search(r'arraysize\(\w+\)', tok): continue + + tok = tok.lstrip('(') + tok = tok.rstrip(')') + if not tok: continue + if Match(r'\d+', tok): continue + if Match(r'0[xX][0-9a-fA-F]+', tok): continue + if Match(r'k[A-Z0-9]\w*', tok): continue + if Match(r'(.+::)?k[A-Z0-9]\w*', tok): continue + if Match(r'(.+::)?[A-Z][A-Z0-9_]*', tok): continue + # A catch all for tricky sizeof cases, including 'sizeof expression', + # 'sizeof(*type)', 'sizeof(const type)', 'sizeof(struct StructName)' + # requires skipping the next token because we split on ' ' and '*'. + if tok.startswith('sizeof'): + skip_next = True + continue + is_const = False + break + if not is_const: + error(filename, linenum, 'runtime/arrays', 1, + 'Do not use variable-length arrays. Use an appropriately named ' + "('k' followed by CamelCase) compile-time constant for the size.") + + # Check for use of unnamed namespaces in header files. Registration + # macros are typically OK, so we allow use of "namespace {" on lines + # that end with backslashes. + if (file_extension == 'h' + and Search(r'\bnamespace\s*{', line) + and line[-1] != '\\'): + error(filename, linenum, 'build/namespaces', 4, + 'Do not use unnamed namespaces in header files. See ' + 'http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces' + ' for more information.') + + +def CheckGlobalStatic(filename, clean_lines, linenum, error): + """Check for unsafe global or static objects. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Match two lines at a time to support multiline declarations + if linenum + 1 < clean_lines.NumLines() and not Search(r'[;({]', line): + line += clean_lines.elided[linenum + 1].strip() + + # Check for people declaring static/global STL strings at the top level. + # This is dangerous because the C++ language does not guarantee that + # globals with constructors are initialized before the first access. + match = Match( + r'((?:|static +)(?:|const +))string +([a-zA-Z0-9_:]+)\b(.*)', + line) + + # Remove false positives: + # - String pointers (as opposed to values). + # string *pointer + # const string *pointer + # string const *pointer + # string *const pointer + # + # - Functions and template specializations. + # string Function(... + # string Class::Method(... + # + # - Operators. These are matched separately because operator names + # cross non-word boundaries, and trying to match both operators + # and functions at the same time would decrease accuracy of + # matching identifiers. + # string Class::operator*() + if (match and + not Search(r'\bstring\b(\s+const)?\s*\*\s*(const\s+)?\w', line) and + not Search(r'\boperator\W', line) and + not Match(r'\s*(<.*>)?(::[a-zA-Z0-9_]+)*\s*\(([^"]|$)', match.group(3))): + error(filename, linenum, 'runtime/string', 4, + 'For a static/global string constant, use a C style string instead: ' + '"%schar %s[]".' % + (match.group(1), match.group(2))) + + if Search(r'\b([A-Za-z0-9_]*_)\(\1\)', line): + error(filename, linenum, 'runtime/init', 4, + 'You seem to be initializing a member variable with itself.') + + +def CheckPrintf(filename, clean_lines, linenum, error): + """Check for printf related issues. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # When snprintf is used, the second argument shouldn't be a literal. + match = Search(r'snprintf\s*\(([^,]*),\s*([0-9]*)\s*,', line) + if match and match.group(2) != '0': + # If 2nd arg is zero, snprintf is used to calculate size. + error(filename, linenum, 'runtime/printf', 3, + 'If you can, use sizeof(%s) instead of %s as the 2nd arg ' + 'to snprintf.' % (match.group(1), match.group(2))) + + # Check if some verboten C functions are being used. + if Search(r'\bsprintf\s*\(', line): + error(filename, linenum, 'runtime/printf', 5, + 'Never use sprintf. Use snprintf instead.') + match = Search(r'\b(strcpy|strcat)\s*\(', line) + if match: + error(filename, linenum, 'runtime/printf', 4, + 'Almost always, snprintf is better than %s' % match.group(1)) + + +def IsDerivedFunction(clean_lines, linenum): + """Check if current line contains an inherited function. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + Returns: + True if current line contains a function with "override" + virt-specifier. + """ + # Scan back a few lines for start of current function + for i in xrange(linenum, max(-1, linenum - 10), -1): + match = Match(r'^([^()]*\w+)\(', clean_lines.elided[i]) + if match: + # Look for "override" after the matching closing parenthesis + line, _, closing_paren = CloseExpression( + clean_lines, i, len(match.group(1))) + return (closing_paren >= 0 and + Search(r'\boverride\b', line[closing_paren:])) + return False + + +def IsOutOfLineMethodDefinition(clean_lines, linenum): + """Check if current line contains an out-of-line method definition. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + Returns: + True if current line contains an out-of-line method definition. + """ + # Scan back a few lines for start of current function + for i in xrange(linenum, max(-1, linenum - 10), -1): + if Match(r'^([^()]*\w+)\(', clean_lines.elided[i]): + return Match(r'^[^()]*\w+::\w+\(', clean_lines.elided[i]) is not None + return False + + +def IsInitializerList(clean_lines, linenum): + """Check if current line is inside constructor initializer list. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + Returns: + True if current line appears to be inside constructor initializer + list, False otherwise. + """ + for i in xrange(linenum, 1, -1): + line = clean_lines.elided[i] + if i == linenum: + remove_function_body = Match(r'^(.*)\{\s*$', line) + if remove_function_body: + line = remove_function_body.group(1) + + if Search(r'\s:\s*\w+[({]', line): + # A lone colon tend to indicate the start of a constructor + # initializer list. It could also be a ternary operator, which + # also tend to appear in constructor initializer lists as + # opposed to parameter lists. + return True + if Search(r'\}\s*,\s*$', line): + # A closing brace followed by a comma is probably the end of a + # brace-initialized member in constructor initializer list. + return True + if Search(r'[{};]\s*$', line): + # Found one of the following: + # - A closing brace or semicolon, probably the end of the previous + # function. + # - An opening brace, probably the start of current class or namespace. + # + # Current line is probably not inside an initializer list since + # we saw one of those things without seeing the starting colon. + return False + + # Got to the beginning of the file without seeing the start of + # constructor initializer list. + return False + + +def CheckForNonConstReference(filename, clean_lines, linenum, + nesting_state, error): + """Check for non-const references. + + Separate from CheckLanguage since it scans backwards from current + line, instead of scanning forward. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + error: The function to call with any errors found. + """ + # Do nothing if there is no '&' on current line. + line = clean_lines.elided[linenum] + if '&' not in line: + return + + # If a function is inherited, current function doesn't have much of + # a choice, so any non-const references should not be blamed on + # derived function. + if IsDerivedFunction(clean_lines, linenum): + return + + # Don't warn on out-of-line method definitions, as we would warn on the + # in-line declaration, if it isn't marked with 'override'. + if IsOutOfLineMethodDefinition(clean_lines, linenum): + return + + # Long type names may be broken across multiple lines, usually in one + # of these forms: + # LongType + # ::LongTypeContinued &identifier + # LongType:: + # LongTypeContinued &identifier + # LongType< + # ...>::LongTypeContinued &identifier + # + # If we detected a type split across two lines, join the previous + # line to current line so that we can match const references + # accordingly. + # + # Note that this only scans back one line, since scanning back + # arbitrary number of lines would be expensive. If you have a type + # that spans more than 2 lines, please use a typedef. + if linenum > 1: + previous = None + if Match(r'\s*::(?:[\w<>]|::)+\s*&\s*\S', line): + # previous_line\n + ::current_line + previous = Search(r'\b((?:const\s*)?(?:[\w<>]|::)+[\w<>])\s*$', + clean_lines.elided[linenum - 1]) + elif Match(r'\s*[a-zA-Z_]([\w<>]|::)+\s*&\s*\S', line): + # previous_line::\n + current_line + previous = Search(r'\b((?:const\s*)?(?:[\w<>]|::)+::)\s*$', + clean_lines.elided[linenum - 1]) + if previous: + line = previous.group(1) + line.lstrip() + else: + # Check for templated parameter that is split across multiple lines + endpos = line.rfind('>') + if endpos > -1: + (_, startline, startpos) = ReverseCloseExpression( + clean_lines, linenum, endpos) + if startpos > -1 and startline < linenum: + # Found the matching < on an earlier line, collect all + # pieces up to current line. + line = '' + for i in xrange(startline, linenum + 1): + line += clean_lines.elided[i].strip() + + # Check for non-const references in function parameters. A single '&' may + # found in the following places: + # inside expression: binary & for bitwise AND + # inside expression: unary & for taking the address of something + # inside declarators: reference parameter + # We will exclude the first two cases by checking that we are not inside a + # function body, including one that was just introduced by a trailing '{'. + # TODO(unknown): Doesn't account for 'catch(Exception& e)' [rare]. + if (nesting_state.previous_stack_top and + not (isinstance(nesting_state.previous_stack_top, _ClassInfo) or + isinstance(nesting_state.previous_stack_top, _NamespaceInfo))): + # Not at toplevel, not within a class, and not within a namespace + return + + # Avoid initializer lists. We only need to scan back from the + # current line for something that starts with ':'. + # + # We don't need to check the current line, since the '&' would + # appear inside the second set of parentheses on the current line as + # opposed to the first set. + if linenum > 0: + for i in xrange(linenum - 1, max(0, linenum - 10), -1): + previous_line = clean_lines.elided[i] + if not Search(r'[),]\s*$', previous_line): + break + if Match(r'^\s*:\s+\S', previous_line): + return + + # Avoid preprocessors + if Search(r'\\\s*$', line): + return + + # Avoid constructor initializer lists + if IsInitializerList(clean_lines, linenum): + return + + # We allow non-const references in a few standard places, like functions + # called "swap()" or iostream operators like "<<" or ">>". Do not check + # those function parameters. + # + # We also accept & in static_assert, which looks like a function but + # it's actually a declaration expression. + whitelisted_functions = (r'(?:[sS]wap(?:<\w:+>)?|' + r'operator\s*[<>][<>]|' + r'static_assert|COMPILE_ASSERT' + r')\s*\(') + if Search(whitelisted_functions, line): + return + elif not Search(r'\S+\([^)]*$', line): + # Don't see a whitelisted function on this line. Actually we + # didn't see any function name on this line, so this is likely a + # multi-line parameter list. Try a bit harder to catch this case. + for i in xrange(2): + if (linenum > i and + Search(whitelisted_functions, clean_lines.elided[linenum - i - 1])): + return + + decls = ReplaceAll(r'{[^}]*}', ' ', line) # exclude function body + for parameter in re.findall(_RE_PATTERN_REF_PARAM, decls): + if not Match(_RE_PATTERN_CONST_REF_PARAM, parameter): + error(filename, linenum, 'runtime/references', 2, + 'Is this a non-const reference? ' + 'If so, make const or use a pointer: ' + + ReplaceAll(' *<', '<', parameter)) + + +def CheckCasts(filename, clean_lines, linenum, error): + """Various cast related checks. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Check to see if they're using an conversion function cast. + # I just try to capture the most common basic types, though there are more. + # Parameterless conversion functions, such as bool(), are allowed as they are + # probably a member operator declaration or default constructor. + match = Search( + r'(\bnew\s+|\S<\s*(?:const\s+)?)?\b' + r'(int|float|double|bool|char|int32|uint32|int64|uint64)' + r'(\([^)].*)', line) + expecting_function = ExpectingFunctionArgs(clean_lines, linenum) + if match and not expecting_function: + matched_type = match.group(2) + + # matched_new_or_template is used to silence two false positives: + # - New operators + # - Template arguments with function types + # + # For template arguments, we match on types immediately following + # an opening bracket without any spaces. This is a fast way to + # silence the common case where the function type is the first + # template argument. False negative with less-than comparison is + # avoided because those operators are usually followed by a space. + # + # function // bracket + no space = false positive + # value < double(42) // bracket + space = true positive + matched_new_or_template = match.group(1) + + # Avoid arrays by looking for brackets that come after the closing + # parenthesis. + if Match(r'\([^()]+\)\s*\[', match.group(3)): + return + + # Other things to ignore: + # - Function pointers + # - Casts to pointer types + # - Placement new + # - Alias declarations + matched_funcptr = match.group(3) + if (matched_new_or_template is None and + not (matched_funcptr and + (Match(r'\((?:[^() ]+::\s*\*\s*)?[^() ]+\)\s*\(', + matched_funcptr) or + matched_funcptr.startswith('(*)'))) and + not Match(r'\s*using\s+\S+\s*=\s*' + matched_type, line) and + not Search(r'new\(\S+\)\s*' + matched_type, line)): + error(filename, linenum, 'readability/casting', 4, + 'Using deprecated casting style. ' + 'Use static_cast<%s>(...) instead' % + matched_type) + + if not expecting_function: + CheckCStyleCast(filename, clean_lines, linenum, 'static_cast', + r'\((int|float|double|bool|char|u?int(16|32|64))\)', error) + + # This doesn't catch all cases. Consider (const char * const)"hello". + # + # (char *) "foo" should always be a const_cast (reinterpret_cast won't + # compile). + if CheckCStyleCast(filename, clean_lines, linenum, 'const_cast', + r'\((char\s?\*+\s?)\)\s*"', error): + pass + else: + # Check pointer casts for other than string constants + CheckCStyleCast(filename, clean_lines, linenum, 'reinterpret_cast', + r'\((\w+\s?\*+\s?)\)', error) + + # In addition, we look for people taking the address of a cast. This + # is dangerous -- casts can assign to temporaries, so the pointer doesn't + # point where you think. + # + # Some non-identifier character is required before the '&' for the + # expression to be recognized as a cast. These are casts: + # expression = &static_cast(temporary()); + # function(&(int*)(temporary())); + # + # This is not a cast: + # reference_type&(int* function_param); + match = Search( + r'(?:[^\w]&\(([^)*][^)]*)\)[\w(])|' + r'(?:[^\w]&(static|dynamic|down|reinterpret)_cast\b)', line) + if match: + # Try a better error message when the & is bound to something + # dereferenced by the casted pointer, as opposed to the casted + # pointer itself. + parenthesis_error = False + match = Match(r'^(.*&(?:static|dynamic|down|reinterpret)_cast\b)<', line) + if match: + _, y1, x1 = CloseExpression(clean_lines, linenum, len(match.group(1))) + if x1 >= 0 and clean_lines.elided[y1][x1] == '(': + _, y2, x2 = CloseExpression(clean_lines, y1, x1) + if x2 >= 0: + extended_line = clean_lines.elided[y2][x2:] + if y2 < clean_lines.NumLines() - 1: + extended_line += clean_lines.elided[y2 + 1] + if Match(r'\s*(?:->|\[)', extended_line): + parenthesis_error = True + + if parenthesis_error: + error(filename, linenum, 'readability/casting', 4, + ('Are you taking an address of something dereferenced ' + 'from a cast? Wrapping the dereferenced expression in ' + 'parentheses will make the binding more obvious')) + else: + error(filename, linenum, 'runtime/casting', 4, + ('Are you taking an address of a cast? ' + 'This is dangerous: could be a temp var. ' + 'Take the address before doing the cast, rather than after')) + + +def CheckCStyleCast(filename, clean_lines, linenum, cast_type, pattern, error): + """Checks for a C-style cast by looking for the pattern. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + cast_type: The string for the C++ cast to recommend. This is either + reinterpret_cast, static_cast, or const_cast, depending. + pattern: The regular expression used to find C-style casts. + error: The function to call with any errors found. + + Returns: + True if an error was emitted. + False otherwise. + """ + line = clean_lines.elided[linenum] + match = Search(pattern, line) + if not match: + return False + + # Exclude lines with keywords that tend to look like casts + context = line[0:match.start(1) - 1] + if Match(r'.*\b(?:sizeof|alignof|alignas|[_A-Z][_A-Z0-9]*)\s*$', context): + return False + + # Try expanding current context to see if we one level of + # parentheses inside a macro. + if linenum > 0: + for i in xrange(linenum - 1, max(0, linenum - 5), -1): + context = clean_lines.elided[i] + context + if Match(r'.*\b[_A-Z][_A-Z0-9]*\s*\((?:\([^()]*\)|[^()])*$', context): + return False + + # operator++(int) and operator--(int) + if context.endswith(' operator++') or context.endswith(' operator--'): + return False + + # A single unnamed argument for a function tends to look like old + # style cast. If we see those, don't issue warnings for deprecated + # casts, instead issue warnings for unnamed arguments where + # appropriate. + # + # These are things that we want warnings for, since the style guide + # explicitly require all parameters to be named: + # Function(int); + # Function(int) { + # ConstMember(int) const; + # ConstMember(int) const { + # ExceptionMember(int) throw (...); + # ExceptionMember(int) throw (...) { + # PureVirtual(int) = 0; + # [](int) -> bool { + # + # These are functions of some sort, where the compiler would be fine + # if they had named parameters, but people often omit those + # identifiers to reduce clutter: + # (FunctionPointer)(int); + # (FunctionPointer)(int) = value; + # Function((function_pointer_arg)(int)) + # Function((function_pointer_arg)(int), int param) + # ; + # <(FunctionPointerTemplateArgument)(int)>; + remainder = line[match.end(0):] + if Match(r'^\s*(?:;|const\b|throw\b|final\b|override\b|[=>{),]|->)', + remainder): + # Looks like an unnamed parameter. + + # Don't warn on any kind of template arguments. + if Match(r'^\s*>', remainder): + return False + + # Don't warn on assignments to function pointers, but keep warnings for + # unnamed parameters to pure virtual functions. Note that this pattern + # will also pass on assignments of "0" to function pointers, but the + # preferred values for those would be "nullptr" or "NULL". + matched_zero = Match(r'^\s=\s*(\S+)\s*;', remainder) + if matched_zero and matched_zero.group(1) != '0': + return False + + # Don't warn on function pointer declarations. For this we need + # to check what came before the "(type)" string. + if Match(r'.*\)\s*$', line[0:match.start(0)]): + return False + + # Don't warn if the parameter is named with block comments, e.g.: + # Function(int /*unused_param*/); + raw_line = clean_lines.raw_lines[linenum] + if '/*' in raw_line: + return False + + # Passed all filters, issue warning here. + error(filename, linenum, 'readability/function', 3, + 'All parameters should be named in a function') + return True + + # At this point, all that should be left is actual casts. + error(filename, linenum, 'readability/casting', 4, + 'Using C-style cast. Use %s<%s>(...) instead' % + (cast_type, match.group(1))) + + return True + + +def ExpectingFunctionArgs(clean_lines, linenum): + """Checks whether where function type arguments are expected. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + + Returns: + True if the line at 'linenum' is inside something that expects arguments + of function types. + """ + line = clean_lines.elided[linenum] + return (Match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(', line) or + (linenum >= 2 and + (Match(r'^\s*MOCK_(?:CONST_)?METHOD\d+(?:_T)?\((?:\S+,)?\s*$', + clean_lines.elided[linenum - 1]) or + Match(r'^\s*MOCK_(?:CONST_)?METHOD\d+(?:_T)?\(\s*$', + clean_lines.elided[linenum - 2]) or + Search(r'\bstd::m?function\s*\<\s*$', + clean_lines.elided[linenum - 1])))) + + +_HEADERS_CONTAINING_TEMPLATES = ( + ('', ('deque',)), + ('', ('unary_function', 'binary_function', + 'plus', 'minus', 'multiplies', 'divides', 'modulus', + 'negate', + 'equal_to', 'not_equal_to', 'greater', 'less', + 'greater_equal', 'less_equal', + 'logical_and', 'logical_or', 'logical_not', + 'unary_negate', 'not1', 'binary_negate', 'not2', + 'bind1st', 'bind2nd', + 'pointer_to_unary_function', + 'pointer_to_binary_function', + 'ptr_fun', + 'mem_fun_t', 'mem_fun', 'mem_fun1_t', 'mem_fun1_ref_t', + 'mem_fun_ref_t', + 'const_mem_fun_t', 'const_mem_fun1_t', + 'const_mem_fun_ref_t', 'const_mem_fun1_ref_t', + 'mem_fun_ref', + )), + ('', ('numeric_limits',)), + ('', ('list',)), + ('', ('map', 'multimap',)), + ('', ('allocator',)), + ('', ('queue', 'priority_queue',)), + ('', ('set', 'multiset',)), + ('', ('stack',)), + ('', ('char_traits', 'basic_string',)), + ('', ('tuple',)), + ('', ('pair',)), + ('', ('vector',)), + + # gcc extensions. + # Note: std::hash is their hash, ::hash is our hash + ('', ('hash_map', 'hash_multimap',)), + ('', ('hash_set', 'hash_multiset',)), + ('', ('slist',)), + ) + +_RE_PATTERN_STRING = re.compile(r'\bstring\b') + +_re_pattern_algorithm_header = [] +for _template in ('copy', 'max', 'min', 'min_element', 'sort', 'swap', + 'transform'): + # Match max(..., ...), max(..., ...), but not foo->max, foo.max or + # type::max(). + _re_pattern_algorithm_header.append( + (re.compile(r'[^>.]\b' + _template + r'(<.*?>)?\([^\)]'), + _template, + '')) + +_re_pattern_templates = [] +for _header, _templates in _HEADERS_CONTAINING_TEMPLATES: + for _template in _templates: + _re_pattern_templates.append( + (re.compile(r'(\<|\b)' + _template + r'\s*\<'), + _template + '<>', + _header)) + + +def FilesBelongToSameModule(filename_cc, filename_h): + """Check if these two filenames belong to the same module. + + The concept of a 'module' here is a as follows: + foo.h, foo-inl.h, foo.cc, foo_test.cc and foo_unittest.cc belong to the + same 'module' if they are in the same directory. + some/path/public/xyzzy and some/path/internal/xyzzy are also considered + to belong to the same module here. + + If the filename_cc contains a longer path than the filename_h, for example, + '/absolute/path/to/base/sysinfo.cc', and this file would include + 'base/sysinfo.h', this function also produces the prefix needed to open the + header. This is used by the caller of this function to more robustly open the + header file. We don't have access to the real include paths in this context, + so we need this guesswork here. + + Known bugs: tools/base/bar.cc and base/bar.h belong to the same module + according to this implementation. Because of this, this function gives + some false positives. This should be sufficiently rare in practice. + + Args: + filename_cc: is the path for the .cc file + filename_h: is the path for the header path + + Returns: + Tuple with a bool and a string: + bool: True if filename_cc and filename_h belong to the same module. + string: the additional prefix needed to open the header file. + """ + + if not filename_cc.endswith('.cc'): + return (False, '') + filename_cc = filename_cc[:-len('.cc')] + if filename_cc.endswith('_unittest'): + filename_cc = filename_cc[:-len('_unittest')] + elif filename_cc.endswith('_test'): + filename_cc = filename_cc[:-len('_test')] + filename_cc = filename_cc.replace('/public/', '/') + filename_cc = filename_cc.replace('/internal/', '/') + + if not filename_h.endswith('.h'): + return (False, '') + filename_h = filename_h[:-len('.h')] + if filename_h.endswith('-inl'): + filename_h = filename_h[:-len('-inl')] + filename_h = filename_h.replace('/public/', '/') + filename_h = filename_h.replace('/internal/', '/') + + files_belong_to_same_module = filename_cc.endswith(filename_h) + common_path = '' + if files_belong_to_same_module: + common_path = filename_cc[:-len(filename_h)] + return files_belong_to_same_module, common_path + + +def UpdateIncludeState(filename, include_dict, io=codecs): + """Fill up the include_dict with new includes found from the file. + + Args: + filename: the name of the header to read. + include_dict: a dictionary in which the headers are inserted. + io: The io factory to use to read the file. Provided for testability. + + Returns: + True if a header was successfully added. False otherwise. + """ + headerfile = None + try: + headerfile = io.open(filename, 'r', 'utf8', 'replace') + except IOError: + return False + linenum = 0 + for line in headerfile: + linenum += 1 + clean_line = CleanseComments(line) + match = _RE_PATTERN_INCLUDE.search(clean_line) + if match: + include = match.group(2) + include_dict.setdefault(include, linenum) + return True + + +def CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error, + io=codecs): + """Reports for missing stl includes. + + This function will output warnings to make sure you are including the headers + necessary for the stl containers and functions that you use. We only give one + reason to include a header. For example, if you use both equal_to<> and + less<> in a .h file, only one (the latter in the file) of these will be + reported as a reason to include the . + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + include_state: An _IncludeState instance. + error: The function to call with any errors found. + io: The IO factory to use to read the header file. Provided for unittest + injection. + """ + required = {} # A map of header name to linenumber and the template entity. + # Example of required: { '': (1219, 'less<>') } + + for linenum in xrange(clean_lines.NumLines()): + line = clean_lines.elided[linenum] + if not line or line[0] == '#': + continue + + # String is special -- it is a non-templatized type in STL. + matched = _RE_PATTERN_STRING.search(line) + if matched: + # Don't warn about strings in non-STL namespaces: + # (We check only the first match per line; good enough.) + prefix = line[:matched.start()] + if prefix.endswith('std::') or not prefix.endswith('::'): + required[''] = (linenum, 'string') + + for pattern, template, header in _re_pattern_algorithm_header: + if pattern.search(line): + required[header] = (linenum, template) + + # The following function is just a speed up, no semantics are changed. + if not '<' in line: # Reduces the cpu time usage by skipping lines. + continue + + for pattern, template, header in _re_pattern_templates: + if pattern.search(line): + required[header] = (linenum, template) + + # The policy is that if you #include something in foo.h you don't need to + # include it again in foo.cc. Here, we will look at possible includes. + # Let's flatten the include_state include_list and copy it into a dictionary. + include_dict = dict([item for sublist in include_state.include_list + for item in sublist]) + + # Did we find the header for this file (if any) and successfully load it? + header_found = False + + # Use the absolute path so that matching works properly. + abs_filename = FileInfo(filename).FullName() + + # For Emacs's flymake. + # If cpplint is invoked from Emacs's flymake, a temporary file is generated + # by flymake and that file name might end with '_flymake.cc'. In that case, + # restore original file name here so that the corresponding header file can be + # found. + # e.g. If the file name is 'foo_flymake.cc', we should search for 'foo.h' + # instead of 'foo_flymake.h' + abs_filename = re.sub(r'_flymake\.cc$', '.cc', abs_filename) + + # include_dict is modified during iteration, so we iterate over a copy of + # the keys. + header_keys = include_dict.keys() + for header in header_keys: + (same_module, common_path) = FilesBelongToSameModule(abs_filename, header) + fullpath = common_path + header + if same_module and UpdateIncludeState(fullpath, include_dict, io): + header_found = True + + # If we can't find the header file for a .cc, assume it's because we don't + # know where to look. In that case we'll give up as we're not sure they + # didn't include it in the .h file. + # TODO(unknown): Do a better job of finding .h files so we are confident that + # not having the .h file means there isn't one. + if filename.endswith('.cc') and not header_found: + return + + # All the lines have been processed, report the errors found. + for required_header_unstripped in required: + template = required[required_header_unstripped][1] + if required_header_unstripped.strip('<>"') not in include_dict: + error(filename, required[required_header_unstripped][0], + 'build/include_what_you_use', 4, + 'Add #include ' + required_header_unstripped + ' for ' + template) + + +_RE_PATTERN_EXPLICIT_MAKEPAIR = re.compile(r'\bmake_pair\s*<') + + +def CheckMakePairUsesDeduction(filename, clean_lines, linenum, error): + """Check that make_pair's template arguments are deduced. + + G++ 4.6 in C++11 mode fails badly if make_pair's template arguments are + specified explicitly, and such use isn't intended in any case. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + match = _RE_PATTERN_EXPLICIT_MAKEPAIR.search(line) + if match: + error(filename, linenum, 'build/explicit_make_pair', + 4, # 4 = high confidence + 'For C++11-compatibility, omit template arguments from make_pair' + ' OR use pair directly OR if appropriate, construct a pair directly') + + +def CheckDefaultLambdaCaptures(filename, clean_lines, linenum, error): + """Check that default lambda captures are not used. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # A lambda introducer specifies a default capture if it starts with "[=" + # or if it starts with "[&" _not_ followed by an identifier. + match = Match(r'^(.*)\[\s*(?:=|&[^\w])', line) + if match: + # Found a potential error, check what comes after the lambda-introducer. + # If it's not open parenthesis (for lambda-declarator) or open brace + # (for compound-statement), it's not a lambda. + line, _, pos = CloseExpression(clean_lines, linenum, len(match.group(1))) + if pos >= 0 and Match(r'^\s*[{(]', line[pos:]): + error(filename, linenum, 'build/c++11', + 4, # 4 = high confidence + 'Default lambda captures are an unapproved C++ feature.') + + +def CheckRedundantVirtual(filename, clean_lines, linenum, error): + """Check if line contains a redundant "virtual" function-specifier. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + # Look for "virtual" on current line. + line = clean_lines.elided[linenum] + virtual = Match(r'^(.*)(\bvirtual\b)(.*)$', line) + if not virtual: return + + # Ignore "virtual" keywords that are near access-specifiers. These + # are only used in class base-specifier and do not apply to member + # functions. + if (Search(r'\b(public|protected|private)\s+$', virtual.group(1)) or + Match(r'^\s+(public|protected|private)\b', virtual.group(3))): + return + + # Ignore the "virtual" keyword from virtual base classes. Usually + # there is a column on the same line in these cases (virtual base + # classes are rare in google3 because multiple inheritance is rare). + if Match(r'^.*[^:]:[^:].*$', line): return + + # Look for the next opening parenthesis. This is the start of the + # parameter list (possibly on the next line shortly after virtual). + # TODO(unknown): doesn't work if there are virtual functions with + # decltype() or other things that use parentheses, but csearch suggests + # that this is rare. + end_col = -1 + end_line = -1 + start_col = len(virtual.group(2)) + for start_line in xrange(linenum, min(linenum + 3, clean_lines.NumLines())): + line = clean_lines.elided[start_line][start_col:] + parameter_list = Match(r'^([^(]*)\(', line) + if parameter_list: + # Match parentheses to find the end of the parameter list + (_, end_line, end_col) = CloseExpression( + clean_lines, start_line, start_col + len(parameter_list.group(1))) + break + start_col = 0 + + if end_col < 0: + return # Couldn't find end of parameter list, give up + + # Look for "override" or "final" after the parameter list + # (possibly on the next few lines). + for i in xrange(end_line, min(end_line + 3, clean_lines.NumLines())): + line = clean_lines.elided[i][end_col:] + match = Search(r'\b(override|final)\b', line) + if match: + error(filename, linenum, 'readability/inheritance', 4, + ('"virtual" is redundant since function is ' + 'already declared as "%s"' % match.group(1))) + + # Set end_col to check whole lines after we are done with the + # first line. + end_col = 0 + if Search(r'[^\w]\s*$', line): + break + + +def CheckRedundantOverrideOrFinal(filename, clean_lines, linenum, error): + """Check if line contains a redundant "override" or "final" virt-specifier. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + # Look for closing parenthesis nearby. We need one to confirm where + # the declarator ends and where the virt-specifier starts to avoid + # false positives. + line = clean_lines.elided[linenum] + declarator_end = line.rfind(')') + if declarator_end >= 0: + fragment = line[declarator_end:] + else: + if linenum > 1 and clean_lines.elided[linenum - 1].rfind(')') >= 0: + fragment = line + else: + return + + # Check that at most one of "override" or "final" is present, not both + if Search(r'\boverride\b', fragment) and Search(r'\bfinal\b', fragment): + error(filename, linenum, 'readability/inheritance', 4, + ('"override" is redundant since function is ' + 'already declared as "final"')) + + + + +# Returns true if we are at a new block, and it is directly +# inside of a namespace. +def IsBlockInNameSpace(nesting_state, is_forward_declaration): + """Checks that the new block is directly in a namespace. + + Args: + nesting_state: The _NestingState object that contains info about our state. + is_forward_declaration: If the class is a forward declared class. + Returns: + Whether or not the new block is directly in a namespace. + """ + if is_forward_declaration: + if len(nesting_state.stack) >= 1 and ( + isinstance(nesting_state.stack[-1], _NamespaceInfo)): + return True + else: + return False + + return (len(nesting_state.stack) > 1 and + nesting_state.stack[-1].check_namespace_indentation and + isinstance(nesting_state.stack[-2], _NamespaceInfo)) + + +def ShouldCheckNamespaceIndentation(nesting_state, is_namespace_indent_item, + raw_lines_no_comments, linenum): + """This method determines if we should apply our namespace indentation check. + + Args: + nesting_state: The current nesting state. + is_namespace_indent_item: If we just put a new class on the stack, True. + If the top of the stack is not a class, or we did not recently + add the class, False. + raw_lines_no_comments: The lines without the comments. + linenum: The current line number we are processing. + + Returns: + True if we should apply our namespace indentation check. Currently, it + only works for classes and namespaces inside of a namespace. + """ + + is_forward_declaration = IsForwardClassDeclaration(raw_lines_no_comments, + linenum) + + if not (is_namespace_indent_item or is_forward_declaration): + return False + + # If we are in a macro, we do not want to check the namespace indentation. + if IsMacroDefinition(raw_lines_no_comments, linenum): + return False + + return IsBlockInNameSpace(nesting_state, is_forward_declaration) + + +# Call this method if the line is directly inside of a namespace. +# If the line above is blank (excluding comments) or the start of +# an inner namespace, it cannot be indented. +def CheckItemIndentationInNamespace(filename, raw_lines_no_comments, linenum, + error): + line = raw_lines_no_comments[linenum] + if Match(r'^\s+', line): + error(filename, linenum, 'runtime/indentation_namespace', 4, + 'Do not indent within a namespace') + + +def ProcessLine(filename, file_extension, clean_lines, line, + include_state, function_state, nesting_state, error, + extra_check_functions=[]): + """Processes a single line in the file. + + Args: + filename: Filename of the file that is being processed. + file_extension: The extension (dot not included) of the file. + clean_lines: An array of strings, each representing a line of the file, + with comments stripped. + line: Number of line being processed. + include_state: An _IncludeState instance in which the headers are inserted. + function_state: A _FunctionState instance which counts function lines, etc. + nesting_state: A NestingState instance which maintains information about + the current stack of nested blocks being parsed. + error: A callable to which errors are reported, which takes 4 arguments: + filename, line number, error level, and message + extra_check_functions: An array of additional check functions that will be + run on each source line. Each function takes 4 + arguments: filename, clean_lines, line, error + """ + raw_lines = clean_lines.raw_lines + ParseNolintSuppressions(filename, raw_lines[line], line, error) + nesting_state.Update(filename, clean_lines, line, error) + CheckForNamespaceIndentation(filename, nesting_state, clean_lines, line, + error) + if nesting_state.InAsmBlock(): return + CheckForFunctionLengths(filename, clean_lines, line, function_state, error) + CheckForMultilineCommentsAndStrings(filename, clean_lines, line, error) + CheckStyle(filename, clean_lines, line, file_extension, nesting_state, error) + CheckLanguage(filename, clean_lines, line, file_extension, include_state, + nesting_state, error) + CheckForNonConstReference(filename, clean_lines, line, nesting_state, error) + CheckForNonStandardConstructs(filename, clean_lines, line, + nesting_state, error) + CheckVlogArguments(filename, clean_lines, line, error) + CheckPosixThreading(filename, clean_lines, line, error) + CheckInvalidIncrement(filename, clean_lines, line, error) + CheckMakePairUsesDeduction(filename, clean_lines, line, error) + CheckDefaultLambdaCaptures(filename, clean_lines, line, error) + CheckRedundantVirtual(filename, clean_lines, line, error) + CheckRedundantOverrideOrFinal(filename, clean_lines, line, error) + for check_fn in extra_check_functions: + check_fn(filename, clean_lines, line, error) + +def FlagCxx11Features(filename, clean_lines, linenum, error): + """Flag those c++11 features that we only allow in certain places. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Flag unapproved C++11 headers. + include = Match(r'\s*#\s*include\s+[<"]([^<"]+)[">]', line) + if include and include.group(1) in ('cfenv', + 'condition_variable', + 'fenv.h', + 'future', + 'mutex', + 'thread', + 'chrono', + 'ratio', + 'regex', + 'system_error', + ): + error(filename, linenum, 'build/c++11', 5, + ('<%s> is an unapproved C++11 header.') % include.group(1)) + + # The only place where we need to worry about C++11 keywords and library + # features in preprocessor directives is in macro definitions. + if Match(r'\s*#', line) and not Match(r'\s*#\s*define\b', line): return + + # These are classes and free functions. The classes are always + # mentioned as std::*, but we only catch the free functions if + # they're not found by ADL. They're alphabetical by header. + for top_name in ( + # type_traits + 'alignment_of', + 'aligned_union', + ): + if Search(r'\bstd::%s\b' % top_name, line): + error(filename, linenum, 'build/c++11', 5, + ('std::%s is an unapproved C++11 class or function. Send c-style ' + 'an example of where it would make your code more readable, and ' + 'they may let you use it.') % top_name) + + +def ProcessFileData(filename, file_extension, lines, error, + extra_check_functions=[]): + """Performs lint checks and reports any errors to the given error function. + + Args: + filename: Filename of the file that is being processed. + file_extension: The extension (dot not included) of the file. + lines: An array of strings, each representing a line of the file, with the + last element being empty if the file is terminated with a newline. + error: A callable to which errors are reported, which takes 4 arguments: + filename, line number, error level, and message + extra_check_functions: An array of additional check functions that will be + run on each source line. Each function takes 4 + arguments: filename, clean_lines, line, error + """ + lines = (['// marker so line numbers and indices both start at 1'] + lines + + ['// marker so line numbers end in a known way']) + + include_state = _IncludeState() + function_state = _FunctionState() + nesting_state = NestingState() + + ResetNolintSuppressions() + + CheckForCopyright(filename, lines, error) + + RemoveMultiLineComments(filename, lines, error) + clean_lines = CleansedLines(lines) + + if file_extension == 'h': + CheckForHeaderGuard(filename, clean_lines, error) + + for line in xrange(clean_lines.NumLines()): + ProcessLine(filename, file_extension, clean_lines, line, + include_state, function_state, nesting_state, error, + extra_check_functions) + FlagCxx11Features(filename, clean_lines, line, error) + nesting_state.CheckCompletedBlocks(filename, error) + + CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error) + + # Check that the .cc file has included its header if it exists. + if file_extension == 'cc': + CheckHeaderFileIncluded(filename, include_state, error) + + # We check here rather than inside ProcessLine so that we see raw + # lines rather than "cleaned" lines. + CheckForBadCharacters(filename, lines, error) + + CheckForNewlineAtEOF(filename, lines, error) + +def ProcessConfigOverrides(filename): + """ Loads the configuration files and processes the config overrides. + + Args: + filename: The name of the file being processed by the linter. + + Returns: + False if the current |filename| should not be processed further. + """ + + abs_filename = os.path.abspath(filename) + cfg_filters = [] + keep_looking = True + while keep_looking: + abs_path, base_name = os.path.split(abs_filename) + if not base_name: + break # Reached the root directory. + + cfg_file = os.path.join(abs_path, "CPPLINT.cfg") + abs_filename = abs_path + if not os.path.isfile(cfg_file): + continue + + try: + with open(cfg_file) as file_handle: + for line in file_handle: + line, _, _ = line.partition('#') # Remove comments. + if not line.strip(): + continue + + name, _, val = line.partition('=') + name = name.strip() + val = val.strip() + if name == 'set noparent': + keep_looking = False + elif name == 'filter': + cfg_filters.append(val) + elif name == 'exclude_files': + # When matching exclude_files pattern, use the base_name of + # the current file name or the directory name we are processing. + # For example, if we are checking for lint errors in /foo/bar/baz.cc + # and we found the .cfg file at /foo/CPPLINT.cfg, then the config + # file's "exclude_files" filter is meant to be checked against "bar" + # and not "baz" nor "bar/baz.cc". + if base_name: + pattern = re.compile(val) + if pattern.match(base_name): + sys.stderr.write('Ignoring "%s": file excluded by "%s". ' + 'File path component "%s" matches ' + 'pattern "%s"\n' % + (filename, cfg_file, base_name, val)) + return False + elif name == 'linelength': + global _line_length + try: + _line_length = int(val) + except ValueError: + sys.stderr.write('Line length must be numeric.') + else: + sys.stderr.write( + 'Invalid configuration option (%s) in file %s\n' % + (name, cfg_file)) + + except IOError: + sys.stderr.write( + "Skipping config file '%s': Can't open for reading\n" % cfg_file) + keep_looking = False + + # Apply all the accumulated filters in reverse order (top-level directory + # config options having the least priority). + for filter in reversed(cfg_filters): + _AddFilters(filter) + + return True + + +def ProcessFile(filename, vlevel, extra_check_functions=[]): + """Does google-lint on a single file. + + Args: + filename: The name of the file to parse. + + vlevel: The level of errors to report. Every error of confidence + >= verbose_level will be reported. 0 is a good default. + + extra_check_functions: An array of additional check functions that will be + run on each source line. Each function takes 4 + arguments: filename, clean_lines, line, error + """ + + _SetVerboseLevel(vlevel) + _BackupFilters() + + if not ProcessConfigOverrides(filename): + _RestoreFilters() + return + + lf_lines = [] + crlf_lines = [] + try: + # Support the UNIX convention of using "-" for stdin. Note that + # we are not opening the file with universal newline support + # (which codecs doesn't support anyway), so the resulting lines do + # contain trailing '\r' characters if we are reading a file that + # has CRLF endings. + # If after the split a trailing '\r' is present, it is removed + # below. + if filename == '-': + lines = codecs.StreamReaderWriter(sys.stdin, + codecs.getreader('utf8'), + codecs.getwriter('utf8'), + 'replace').read().split('\n') + else: + lines = codecs.open(filename, 'r', 'utf8', 'replace').read().split('\n') + + # Remove trailing '\r'. + # The -1 accounts for the extra trailing blank line we get from split() + for linenum in range(len(lines) - 1): + if lines[linenum].endswith('\r'): + lines[linenum] = lines[linenum].rstrip('\r') + crlf_lines.append(linenum + 1) + else: + lf_lines.append(linenum + 1) + + except IOError: + sys.stderr.write( + "Skipping input '%s': Can't open for reading\n" % filename) + _RestoreFilters() + return + + # Note, if no dot is found, this will give the entire filename as the ext. + file_extension = filename[filename.rfind('.') + 1:] + + # When reading from stdin, the extension is unknown, so no cpplint tests + # should rely on the extension. + if filename != '-' and file_extension not in _valid_extensions: + sys.stderr.write('Ignoring %s; not a valid file name ' + '(%s)\n' % (filename, ', '.join(_valid_extensions))) + else: + ProcessFileData(filename, file_extension, lines, Error, + extra_check_functions) + + # If end-of-line sequences are a mix of LF and CR-LF, issue + # warnings on the lines with CR. + # + # Don't issue any warnings if all lines are uniformly LF or CR-LF, + # since critique can handle these just fine, and the style guide + # doesn't dictate a particular end of line sequence. + # + # We can't depend on os.linesep to determine what the desired + # end-of-line sequence should be, since that will return the + # server-side end-of-line sequence. + if lf_lines and crlf_lines: + # Warn on every line with CR. An alternative approach might be to + # check whether the file is mostly CRLF or just LF, and warn on the + # minority, we bias toward LF here since most tools prefer LF. + for linenum in crlf_lines: + Error(filename, linenum, 'whitespace/newline', 1, + 'Unexpected \\r (^M) found; better to use only \\n') + + sys.stderr.write('Done processing %s\n' % filename) + _RestoreFilters() + + +def PrintUsage(message): + """Prints a brief usage string and exits, optionally with an error message. + + Args: + message: The optional error message. + """ + sys.stderr.write(_USAGE) + if message: + sys.exit('\nFATAL ERROR: ' + message) + else: + sys.exit(1) + + +def PrintCategories(): + """Prints a list of all the error-categories used by error messages. + + These are the categories used to filter messages via --filter. + """ + sys.stderr.write(''.join(' %s\n' % cat for cat in _ERROR_CATEGORIES)) + sys.exit(0) + + +def ParseArguments(args): + """Parses the command line arguments. + + This may set the output format and verbosity level as side-effects. + + Args: + args: The command line arguments: + + Returns: + The list of filenames to lint. + """ + try: + (opts, filenames) = getopt.getopt(args, '', ['help', 'output=', 'verbose=', + 'counting=', + 'filter=', + 'root=', + 'linelength=', + 'extensions=']) + except getopt.GetoptError: + PrintUsage('Invalid arguments.') + + verbosity = _VerboseLevel() + output_format = _OutputFormat() + filters = '' + counting_style = '' + + for (opt, val) in opts: + if opt == '--help': + PrintUsage(None) + elif opt == '--output': + if val not in ('emacs', 'vs7', 'eclipse'): + PrintUsage('The only allowed output formats are emacs, vs7 and eclipse.') + output_format = val + elif opt == '--verbose': + verbosity = int(val) + elif opt == '--filter': + filters = val + if not filters: + PrintCategories() + elif opt == '--counting': + if val not in ('total', 'toplevel', 'detailed'): + PrintUsage('Valid counting options are total, toplevel, and detailed') + counting_style = val + elif opt == '--root': + global _root + _root = val + elif opt == '--linelength': + global _line_length + try: + _line_length = int(val) + except ValueError: + PrintUsage('Line length must be digits.') + elif opt == '--extensions': + global _valid_extensions + try: + _valid_extensions = set(val.split(',')) + except ValueError: + PrintUsage('Extensions must be comma seperated list.') + + if not filenames: + PrintUsage('No files were specified.') + + _SetOutputFormat(output_format) + _SetVerboseLevel(verbosity) + _SetFilters(filters) + _SetCountingStyle(counting_style) + + return filenames + + +def main(): + filenames = ParseArguments(sys.argv[1:]) + + # Change stderr to write with replacement characters so we don't die + # if we try to print something containing non-ASCII characters. + sys.stderr = codecs.StreamReaderWriter(sys.stderr, + codecs.getreader('utf8'), + codecs.getwriter('utf8'), + 'replace') + + _cpplint_state.ResetErrorCounts() + for filename in filenames: + ProcessFile(filename, _cpplint_state.verbose_level) + _cpplint_state.PrintErrorCounts() + + sys.exit(_cpplint_state.error_count > 0) + + +if __name__ == '__main__': + main() diff --git a/3rdparty/tinygltf/examples.bat b/3rdparty/tinygltf/examples.bat new file mode 100644 index 0000000..11e35e7 --- /dev/null +++ b/3rdparty/tinygltf/examples.bat @@ -0,0 +1,3 @@ + cd examples\raytrace + ..\..\tools\windows\premake5.exe vs2015 + msbuild NanoSGSolution.sln /property:Configuration=Release diff --git a/3rdparty/tinygltf/examples/glview/README.md b/3rdparty/tinygltf/examples/glview/README.md new file mode 100644 index 0000000..34a0c3b --- /dev/null +++ b/3rdparty/tinygltf/examples/glview/README.md @@ -0,0 +1,34 @@ +Simple OpenGL viewer for glTF geometry. + +## Requirements + +* premake5 : Requires recent `premake5`(alpha12 or later) for macosx and linux. `premake5` for windows is included in `$tinygltf/tools/window` directory. +* GLEW + * Ubuntu 16.04: sudo apt install libglew-dev +* glfw3 + * Ubuntu 16.04: sudo apt install libglfw3-dev + +### MacOSX and Linux + + + # optional. set pkg-config path to find glfw3 + $ export PKG_CONFIG_PATH=/path/to/pkgconfig + + > premake4 gmake + $ make + +### Windows(not tested well) + +Edit glew and glfw path in `premake5.lua`, then + + > premake5.exe vs2013 + +Open .sln in Visual Studio 2013 + +When running .exe, glew and glfw dll must exist in the working directory. + +## TODO + +* [ ] PBR Material + * [ ] PBR Texture. +* [ ] Animation diff --git a/3rdparty/tinygltf/examples/glview/glview.cc b/3rdparty/tinygltf/examples/glview/glview.cc new file mode 100644 index 0000000..2b161cc --- /dev/null +++ b/3rdparty/tinygltf/examples/glview/glview.cc @@ -0,0 +1,861 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#define GLFW_INCLUDE_GLU +#include + +#include "trackball.h" + +#define TINYGLTF_IMPLEMENTATION +#define STB_IMAGE_IMPLEMENTATION +#include "tiny_gltf.h" + +#define BUFFER_OFFSET(i) ((char *)NULL + (i)) + +#define CheckGLErrors(desc) \ + { \ + GLenum e = glGetError(); \ + if (e != GL_NO_ERROR) { \ + printf("OpenGL error in \"%s\": %d (%d) %s:%d\n", desc, e, e, __FILE__, \ + __LINE__); \ + exit(20); \ + } \ + } + +#define CAM_Z (3.0f) +int width = 768; +int height = 768; + +double prevMouseX, prevMouseY; +bool mouseLeftPressed; +bool mouseMiddlePressed; +bool mouseRightPressed; +float curr_quat[4]; +float prev_quat[4]; +float eye[3], lookat[3], up[3]; + +GLFWwindow *window; + +typedef struct { GLuint vb; } GLBufferState; + +typedef struct { + std::vector diffuseTex; // for each primitive in mesh +} GLMeshState; + +typedef struct { + std::map attribs; + std::map uniforms; +} GLProgramState; + +typedef struct { + GLuint vb; // vertex buffer + size_t count; // byte count +} GLCurvesState; + +std::map gBufferState; +std::map gMeshState; +std::map gCurvesMesh; +GLProgramState gGLProgramState; + +void CheckErrors(std::string desc) { + GLenum e = glGetError(); + if (e != GL_NO_ERROR) { + fprintf(stderr, "OpenGL error in \"%s\": %d (%d)\n", desc.c_str(), e, e); + exit(20); + } +} + +static std::string GetFilePathExtension(const std::string &FileName) { + if (FileName.find_last_of(".") != std::string::npos) + return FileName.substr(FileName.find_last_of(".") + 1); + return ""; +} + +bool LoadShader(GLenum shaderType, // GL_VERTEX_SHADER or GL_FRAGMENT_SHADER(or + // maybe GL_COMPUTE_SHADER) + GLuint &shader, const char *shaderSourceFilename) { + GLint val = 0; + + // free old shader/program + if (shader != 0) { + glDeleteShader(shader); + } + + std::vector srcbuf; + FILE *fp = fopen(shaderSourceFilename, "rb"); + if (!fp) { + fprintf(stderr, "failed to load shader: %s\n", shaderSourceFilename); + return false; + } + fseek(fp, 0, SEEK_END); + size_t len = ftell(fp); + rewind(fp); + srcbuf.resize(len + 1); + len = fread(&srcbuf.at(0), 1, len, fp); + srcbuf[len] = 0; + fclose(fp); + + const GLchar *srcs[1]; + srcs[0] = &srcbuf.at(0); + + shader = glCreateShader(shaderType); + glShaderSource(shader, 1, srcs, NULL); + glCompileShader(shader); + glGetShaderiv(shader, GL_COMPILE_STATUS, &val); + if (val != GL_TRUE) { + char log[4096]; + GLsizei msglen; + glGetShaderInfoLog(shader, 4096, &msglen, log); + printf("%s\n", log); + // assert(val == GL_TRUE && "failed to compile shader"); + printf("ERR: Failed to load or compile shader [ %s ]\n", + shaderSourceFilename); + return false; + } + + printf("Load shader [ %s ] OK\n", shaderSourceFilename); + return true; +} + +bool LinkShader(GLuint &prog, GLuint &vertShader, GLuint &fragShader) { + GLint val = 0; + + if (prog != 0) { + glDeleteProgram(prog); + } + + prog = glCreateProgram(); + + glAttachShader(prog, vertShader); + glAttachShader(prog, fragShader); + glLinkProgram(prog); + + glGetProgramiv(prog, GL_LINK_STATUS, &val); + assert(val == GL_TRUE && "failed to link shader"); + + printf("Link shader OK\n"); + + return true; +} + +void reshapeFunc(GLFWwindow *window, int w, int h) { + (void)window; + int fb_w, fb_h; + glfwGetFramebufferSize(window, &fb_w, &fb_h); + glViewport(0, 0, fb_w, fb_h); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + gluPerspective(45.0, (float)w / (float)h, 0.1f, 1000.0f); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + width = w; + height = h; +} + +void keyboardFunc(GLFWwindow *window, int key, int scancode, int action, + int mods) { + (void)scancode; + (void)mods; + if (action == GLFW_PRESS || action == GLFW_REPEAT) { + // Close window + if (key == GLFW_KEY_Q || key == GLFW_KEY_ESCAPE) { + glfwSetWindowShouldClose(window, GL_TRUE); + } + } +} + +void clickFunc(GLFWwindow *window, int button, int action, int mods) { + double x, y; + glfwGetCursorPos(window, &x, &y); + + bool shiftPressed = (mods & GLFW_MOD_SHIFT); + bool ctrlPressed = (mods & GLFW_MOD_CONTROL); + + if ((button == GLFW_MOUSE_BUTTON_LEFT) && (!shiftPressed) && (!ctrlPressed)) { + mouseLeftPressed = true; + mouseMiddlePressed = false; + mouseRightPressed = false; + if (action == GLFW_PRESS) { + int id = -1; + // int id = ui.Proc(x, y); + if (id < 0) { // outside of UI + trackball(prev_quat, 0.0, 0.0, 0.0, 0.0); + } + } else if (action == GLFW_RELEASE) { + mouseLeftPressed = false; + } + } + if ((button == GLFW_MOUSE_BUTTON_RIGHT) || + ((button == GLFW_MOUSE_BUTTON_LEFT) && ctrlPressed)) { + if (action == GLFW_PRESS) { + mouseRightPressed = true; + mouseLeftPressed = false; + mouseMiddlePressed = false; + } else if (action == GLFW_RELEASE) { + mouseRightPressed = false; + } + } + if ((button == GLFW_MOUSE_BUTTON_MIDDLE) || + ((button == GLFW_MOUSE_BUTTON_LEFT) && shiftPressed)) { + if (action == GLFW_PRESS) { + mouseMiddlePressed = true; + mouseLeftPressed = false; + mouseRightPressed = false; + } else if (action == GLFW_RELEASE) { + mouseMiddlePressed = false; + } + } +} + +void motionFunc(GLFWwindow *window, double mouse_x, double mouse_y) { + (void)window; + float rotScale = 1.0f; + float transScale = 2.0f; + + if (mouseLeftPressed) { + trackball(prev_quat, rotScale * (2.0f * prevMouseX - width) / (float)width, + rotScale * (height - 2.0f * prevMouseY) / (float)height, + rotScale * (2.0f * mouse_x - width) / (float)width, + rotScale * (height - 2.0f * mouse_y) / (float)height); + + add_quats(prev_quat, curr_quat, curr_quat); + } else if (mouseMiddlePressed) { + eye[0] += -transScale * (mouse_x - prevMouseX) / (float)width; + lookat[0] += -transScale * (mouse_x - prevMouseX) / (float)width; + eye[1] += transScale * (mouse_y - prevMouseY) / (float)height; + lookat[1] += transScale * (mouse_y - prevMouseY) / (float)height; + } else if (mouseRightPressed) { + eye[2] += transScale * (mouse_y - prevMouseY) / (float)height; + lookat[2] += transScale * (mouse_y - prevMouseY) / (float)height; + } + + // Update mouse point + prevMouseX = mouse_x; + prevMouseY = mouse_y; +} + +static void SetupMeshState(tinygltf::Model &model, GLuint progId) { + // Buffer + { + for (size_t i = 0; i < model.bufferViews.size(); i++) { + const tinygltf::BufferView &bufferView = model.bufferViews[i]; + if (bufferView.target == 0) { + std::cout << "WARN: bufferView.target is zero" << std::endl; + continue; // Unsupported bufferView. + } + + const tinygltf::Buffer &buffer = model.buffers[bufferView.buffer]; + GLBufferState state; + glGenBuffers(1, &state.vb); + glBindBuffer(bufferView.target, state.vb); + std::cout << "buffer.size= " << buffer.data.size() + << ", byteOffset = " << bufferView.byteOffset << std::endl; + glBufferData(bufferView.target, bufferView.byteLength, + &buffer.data.at(0) + bufferView.byteOffset, GL_STATIC_DRAW); + glBindBuffer(bufferView.target, 0); + + gBufferState[i] = state; + } + } + +#if 0 // TODO(syoyo): Implement + // Texture + { + for (size_t i = 0; i < model.meshes.size(); i++) { + const tinygltf::Mesh &mesh = model.meshes[i]; + + gMeshState[mesh.name].diffuseTex.resize(mesh.primitives.size()); + for (size_t primId = 0; primId < mesh.primitives.size(); primId++) { + const tinygltf::Primitive &primitive = mesh.primitives[primId]; + + gMeshState[mesh.name].diffuseTex[primId] = 0; + + if (primitive.material < 0) { + continue; + } + tinygltf::Material &mat = model.materials[primitive.material]; + // printf("material.name = %s\n", mat.name.c_str()); + if (mat.values.find("diffuse") != mat.values.end()) { + std::string diffuseTexName = mat.values["diffuse"].string_value; + if (model.textures.find(diffuseTexName) != model.textures.end()) { + tinygltf::Texture &tex = model.textures[diffuseTexName]; + if (scene.images.find(tex.source) != model.images.end()) { + tinygltf::Image &image = model.images[tex.source]; + GLuint texId; + glGenTextures(1, &texId); + glBindTexture(tex.target, texId); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glTexParameterf(tex.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameterf(tex.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + // Ignore Texture.fomat. + GLenum format = GL_RGBA; + if (image.component == 3) { + format = GL_RGB; + } + glTexImage2D(tex.target, 0, tex.internalFormat, image.width, + image.height, 0, format, tex.type, + &image.image.at(0)); + + CheckErrors("texImage2D"); + glBindTexture(tex.target, 0); + + printf("TexId = %d\n", texId); + gMeshState[mesh.name].diffuseTex[primId] = texId; + } + } + } + } + } + } +#endif + + glUseProgram(progId); + GLint vtloc = glGetAttribLocation(progId, "in_vertex"); + GLint nrmloc = glGetAttribLocation(progId, "in_normal"); + GLint uvloc = glGetAttribLocation(progId, "in_texcoord"); + + // GLint diffuseTexLoc = glGetUniformLocation(progId, "diffuseTex"); + GLint isCurvesLoc = glGetUniformLocation(progId, "uIsCurves"); + + gGLProgramState.attribs["POSITION"] = vtloc; + gGLProgramState.attribs["NORMAL"] = nrmloc; + gGLProgramState.attribs["TEXCOORD_0"] = uvloc; + // gGLProgramState.uniforms["diffuseTex"] = diffuseTexLoc; + gGLProgramState.uniforms["isCurvesLoc"] = isCurvesLoc; +}; + +#if 0 // TODO(syoyo): Implement +// Setup curves geometry extension +static void SetupCurvesState(tinygltf::Scene &scene, GLuint progId) { + // Find curves primitive. + { + std::map::const_iterator it( + scene.meshes.begin()); + std::map::const_iterator itEnd( + scene.meshes.end()); + + for (; it != itEnd; it++) { + const tinygltf::Mesh &mesh = it->second; + + // Currently we only support one primitive per mesh. + if (mesh.primitives.size() > 1) { + continue; + } + + for (size_t primId = 0; primId < mesh.primitives.size(); primId++) { + const tinygltf::Primitive &primitive = mesh.primitives[primId]; + + gMeshState[mesh.name].diffuseTex[primId] = 0; + + if (primitive.material.empty()) { + continue; + } + + bool has_curves = false; + if (primitive.extras.IsObject()) { + if (primitive.extras.Has("ext_mode")) { + const tinygltf::Value::Object &o = + primitive.extras.Get(); + const tinygltf::Value &ext_mode = o.find("ext_mode")->second; + + if (ext_mode.IsString()) { + const std::string &str = ext_mode.Get(); + if (str.compare("curves") == 0) { + has_curves = true; + } + } + } + } + + if (!has_curves) { + continue; + } + + // Construct curves buffer + const tinygltf::Accessor &vtx_accessor = + scene.accessors[primitive.attributes.find("POSITION")->second]; + const tinygltf::Accessor &nverts_accessor = + scene.accessors[primitive.attributes.find("NVERTS")->second]; + const tinygltf::BufferView &vtx_bufferView = + scene.bufferViews[vtx_accessor.bufferView]; + const tinygltf::BufferView &nverts_bufferView = + scene.bufferViews[nverts_accessor.bufferView]; + const tinygltf::Buffer &vtx_buffer = + scene.buffers[vtx_bufferView.buffer]; + const tinygltf::Buffer &nverts_buffer = + scene.buffers[nverts_bufferView.buffer]; + + // std::cout << "vtx_bufferView = " << vtx_accessor.bufferView << + // std::endl; + // std::cout << "nverts_bufferView = " << nverts_accessor.bufferView << + // std::endl; + // std::cout << "vtx_buffer.size = " << vtx_buffer.data.size() << + // std::endl; + // std::cout << "nverts_buffer.size = " << nverts_buffer.data.size() << + // std::endl; + + const int *nverts = + reinterpret_cast(nverts_buffer.data.data()); + const float *vtx = + reinterpret_cast(vtx_buffer.data.data()); + + // Convert to GL_LINES data. + std::vector line_pts; + size_t vtx_offset = 0; + for (int k = 0; k < static_cast(nverts_accessor.count); k++) { + for (int n = 0; n < nverts[k] - 1; n++) { + + line_pts.push_back(vtx[3 * (vtx_offset + n) + 0]); + line_pts.push_back(vtx[3 * (vtx_offset + n) + 1]); + line_pts.push_back(vtx[3 * (vtx_offset + n) + 2]); + + line_pts.push_back(vtx[3 * (vtx_offset + n + 1) + 0]); + line_pts.push_back(vtx[3 * (vtx_offset + n + 1) + 1]); + line_pts.push_back(vtx[3 * (vtx_offset + n + 1) + 2]); + + // std::cout << "p0 " << vtx[3 * (vtx_offset + n) + 0] << ", " + // << vtx[3 * (vtx_offset + n) + 1] << ", " + // << vtx[3 * (vtx_offset + n) + 2] << std::endl; + + // std::cout << "p1 " << vtx[3 * (vtx_offset + n+1) + 0] << ", " + // << vtx[3 * (vtx_offset + n+1) + 1] << ", " + // << vtx[3 * (vtx_offset + n+1) + 2] << std::endl; + } + + vtx_offset += nverts[k]; + } + + GLCurvesState state; + glGenBuffers(1, &state.vb); + glBindBuffer(GL_ARRAY_BUFFER, state.vb); + glBufferData(GL_ARRAY_BUFFER, line_pts.size() * sizeof(float), + line_pts.data(), GL_STATIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER, 0); + + state.count = line_pts.size() / 3; + gCurvesMesh[mesh.name] = state; + + // Material + tinygltf::Material &mat = scene.materials[primitive.material]; + // printf("material.name = %s\n", mat.name.c_str()); + if (mat.values.find("diffuse") != mat.values.end()) { + std::string diffuseTexName = mat.values["diffuse"].string_value; + if (scene.textures.find(diffuseTexName) != scene.textures.end()) { + tinygltf::Texture &tex = scene.textures[diffuseTexName]; + if (scene.images.find(tex.source) != scene.images.end()) { + tinygltf::Image &image = scene.images[tex.source]; + GLuint texId; + glGenTextures(1, &texId); + glBindTexture(tex.target, texId); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glTexParameterf(tex.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameterf(tex.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + // Ignore Texture.fomat. + GLenum format = GL_RGBA; + if (image.component == 3) { + format = GL_RGB; + } + glTexImage2D(tex.target, 0, tex.internalFormat, image.width, + image.height, 0, format, tex.type, + &image.image.at(0)); + + CheckErrors("texImage2D"); + glBindTexture(tex.target, 0); + + printf("TexId = %d\n", texId); + gMeshState[mesh.name].diffuseTex[primId] = texId; + } + } + } + } + } + } + + glUseProgram(progId); + GLint vtloc = glGetAttribLocation(progId, "in_vertex"); + GLint nrmloc = glGetAttribLocation(progId, "in_normal"); + GLint uvloc = glGetAttribLocation(progId, "in_texcoord"); + + GLint diffuseTexLoc = glGetUniformLocation(progId, "diffuseTex"); + GLint isCurvesLoc = glGetUniformLocation(progId, "uIsCurves"); + + gGLProgramState.attribs["POSITION"] = vtloc; + gGLProgramState.attribs["NORMAL"] = nrmloc; + gGLProgramState.attribs["TEXCOORD_0"] = uvloc; + gGLProgramState.uniforms["diffuseTex"] = diffuseTexLoc; + gGLProgramState.uniforms["uIsCurves"] = isCurvesLoc; +}; +#endif + +static void DrawMesh(tinygltf::Model &model, const tinygltf::Mesh &mesh) { + //// Skip curves primitive. + // if (gCurvesMesh.find(mesh.name) != gCurvesMesh.end()) { + // return; + //} + + // if (gGLProgramState.uniforms["diffuseTex"] >= 0) { + // glUniform1i(gGLProgramState.uniforms["diffuseTex"], 0); // TEXTURE0 + //} + + if (gGLProgramState.uniforms["isCurvesLoc"] >= 0) { + glUniform1i(gGLProgramState.uniforms["isCurvesLoc"], 0); + } + + for (size_t i = 0; i < mesh.primitives.size(); i++) { + const tinygltf::Primitive &primitive = mesh.primitives[i]; + + if (primitive.indices < 0) return; + + // Assume TEXTURE_2D target for the texture object. + // glBindTexture(GL_TEXTURE_2D, gMeshState[mesh.name].diffuseTex[i]); + + std::map::const_iterator it(primitive.attributes.begin()); + std::map::const_iterator itEnd( + primitive.attributes.end()); + + for (; it != itEnd; it++) { + assert(it->second >= 0); + const tinygltf::Accessor &accessor = model.accessors[it->second]; + glBindBuffer(GL_ARRAY_BUFFER, gBufferState[accessor.bufferView].vb); + CheckErrors("bind buffer"); + int size = 1; + if (accessor.type == TINYGLTF_TYPE_SCALAR) { + size = 1; + } else if (accessor.type == TINYGLTF_TYPE_VEC2) { + size = 2; + } else if (accessor.type == TINYGLTF_TYPE_VEC3) { + size = 3; + } else if (accessor.type == TINYGLTF_TYPE_VEC4) { + size = 4; + } else { + assert(0); + } + // it->first would be "POSITION", "NORMAL", "TEXCOORD_0", ... + if ((it->first.compare("POSITION") == 0) || + (it->first.compare("NORMAL") == 0) || + (it->first.compare("TEXCOORD_0") == 0)) { + if (gGLProgramState.attribs[it->first] >= 0) { + // Compute byteStride from Accessor + BufferView combination. + int byteStride = accessor.ByteStride(model.bufferViews[accessor.bufferView]); + assert(byteStride != -1); + glVertexAttribPointer(gGLProgramState.attribs[it->first], size, + accessor.componentType, accessor.normalized ? GL_TRUE : GL_FALSE, + byteStride, + BUFFER_OFFSET(accessor.byteOffset)); + CheckErrors("vertex attrib pointer"); + glEnableVertexAttribArray(gGLProgramState.attribs[it->first]); + CheckErrors("enable vertex attrib array"); + } + } + } + + const tinygltf::Accessor &indexAccessor = + model.accessors[primitive.indices]; + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, + gBufferState[indexAccessor.bufferView].vb); + CheckErrors("bind buffer"); + int mode = -1; + if (primitive.mode == TINYGLTF_MODE_TRIANGLES) { + mode = GL_TRIANGLES; + } else if (primitive.mode == TINYGLTF_MODE_TRIANGLE_STRIP) { + mode = GL_TRIANGLE_STRIP; + } else if (primitive.mode == TINYGLTF_MODE_TRIANGLE_FAN) { + mode = GL_TRIANGLE_FAN; + } else if (primitive.mode == TINYGLTF_MODE_POINTS) { + mode = GL_POINTS; + } else if (primitive.mode == TINYGLTF_MODE_LINE) { + mode = GL_LINES; + } else if (primitive.mode == TINYGLTF_MODE_LINE_LOOP) { + mode = GL_LINE_LOOP; + } else { + assert(0); + } + glDrawElements(mode, indexAccessor.count, indexAccessor.componentType, + BUFFER_OFFSET(indexAccessor.byteOffset)); + CheckErrors("draw elements"); + + { + std::map::const_iterator it( + primitive.attributes.begin()); + std::map::const_iterator itEnd( + primitive.attributes.end()); + + for (; it != itEnd; it++) { + if ((it->first.compare("POSITION") == 0) || + (it->first.compare("NORMAL") == 0) || + (it->first.compare("TEXCOORD_0") == 0)) { + if (gGLProgramState.attribs[it->first] >= 0) { + glDisableVertexAttribArray(gGLProgramState.attribs[it->first]); + } + } + } + } + } +} + +#if 0 // TODO(syoyo): Implement +static void DrawCurves(tinygltf::Scene &scene, const tinygltf::Mesh &mesh) { + (void)scene; + + if (gCurvesMesh.find(mesh.name) == gCurvesMesh.end()) { + return; + } + + if (gGLProgramState.uniforms["isCurvesLoc"] >= 0) { + glUniform1i(gGLProgramState.uniforms["isCurvesLoc"], 1); + } + + GLCurvesState &state = gCurvesMesh[mesh.name]; + + if (gGLProgramState.attribs["POSITION"] >= 0) { + glBindBuffer(GL_ARRAY_BUFFER, state.vb); + glVertexAttribPointer(gGLProgramState.attribs["POSITION"], 3, GL_FLOAT, + GL_FALSE, /* stride */ 0, BUFFER_OFFSET(0)); + CheckErrors("curve: vertex attrib pointer"); + glEnableVertexAttribArray(gGLProgramState.attribs["POSITION"]); + CheckErrors("curve: enable vertex attrib array"); + } + + glDrawArrays(GL_LINES, 0, state.count); + + if (gGLProgramState.attribs["POSITION"] >= 0) { + glDisableVertexAttribArray(gGLProgramState.attribs["POSITION"]); + } +} +#endif + +// Hierarchically draw nodes +static void DrawNode(tinygltf::Model &model, const tinygltf::Node &node) { + // Apply xform + + glPushMatrix(); + if (node.matrix.size() == 16) { + // Use `matrix' attribute + glMultMatrixd(node.matrix.data()); + } else { + // Assume Trans x Rotate x Scale order + if (node.scale.size() == 3) { + glScaled(node.scale[0], node.scale[1], node.scale[2]); + } + + if (node.rotation.size() == 4) { + glRotated(node.rotation[0], node.rotation[1], node.rotation[2], + node.rotation[3]); + } + + if (node.translation.size() == 3) { + glTranslated(node.translation[0], node.translation[1], + node.translation[2]); + } + } + + // std::cout << "node " << node.name << ", Meshes " << node.meshes.size() << + // std::endl; + + // std::cout << it->first << std::endl; + // FIXME(syoyo): Refactor. + // DrawCurves(scene, it->second); + DrawMesh(model, model.meshes[node.mesh]); + + // Draw child nodes. + for (size_t i = 0; i < node.children.size(); i++) { + DrawNode(model, model.nodes[node.children[i]]); + } + + glPopMatrix(); +} + +static void DrawModel(tinygltf::Model &model) { +#if 0 + std::map::const_iterator it(scene.meshes.begin()); + std::map::const_iterator itEnd(scene.meshes.end()); + + for (; it != itEnd; it++) { + DrawMesh(scene, it->second); + DrawCurves(scene, it->second); + } +#else + + // TODO(syoyo): Support non-default scenes. + assert(model.defaultScene >= 0); + const tinygltf::Scene &scene = model.scenes[model.defaultScene]; + for (size_t i = 0; i < scene.nodes.size(); i++) { + DrawNode(model, model.nodes[scene.nodes[i]]); + } +#endif +} + +static void Init() { + trackball(curr_quat, 0, 0, 0, 0); + + eye[0] = 0.0f; + eye[1] = 0.0f; + eye[2] = CAM_Z; + + lookat[0] = 0.0f; + lookat[1] = 0.0f; + lookat[2] = 0.0f; + + up[0] = 0.0f; + up[1] = 1.0f; + up[2] = 0.0f; +} + +static void PrintNodes(const tinygltf::Scene &scene) { + for (size_t i = 0; i < scene.nodes.size(); i++) { + std::cout << "node.name : " << scene.nodes[i] << std::endl; + } +} + +int main(int argc, char **argv) { + if (argc < 2) { + std::cout << "glview input.gltf \n" << std::endl; + return 0; + } + + float scale = 1.0f; + if (argc > 2) { + scale = atof(argv[2]); + } + + tinygltf::Model model; + tinygltf::TinyGLTF loader; + std::string err; + std::string input_filename(argv[1]); + std::string ext = GetFilePathExtension(input_filename); + + bool ret = false; + if (ext.compare("glb") == 0) { + // assume binary glTF. + ret = loader.LoadBinaryFromFile(&model, &err, input_filename.c_str()); + } else { + // assume ascii glTF. + ret = loader.LoadASCIIFromFile(&model, &err, input_filename.c_str()); + } + + if (!err.empty()) { + printf("ERR: %s\n", err.c_str()); + } + if (!ret) { + printf("Failed to load .glTF : %s\n", argv[1]); + exit(-1); + } + + Init(); + + // DBG + PrintNodes(model.scenes[model.defaultScene]); + + if (!glfwInit()) { + std::cerr << "Failed to initialize GLFW." << std::endl; + return -1; + } + + char title[1024]; + sprintf(title, "Simple glTF viewer: %s", input_filename.c_str()); + + window = glfwCreateWindow(width, height, title, NULL, NULL); + if (window == NULL) { + std::cerr << "Failed to open GLFW window. " << std::endl; + glfwTerminate(); + return 1; + } + + glfwGetWindowSize(window, &width, &height); + + glfwMakeContextCurrent(window); + + // Callback + glfwSetWindowSizeCallback(window, reshapeFunc); + glfwSetKeyCallback(window, keyboardFunc); + glfwSetMouseButtonCallback(window, clickFunc); + glfwSetCursorPosCallback(window, motionFunc); + + glewExperimental = true; // This may be only true for linux environment. + if (glewInit() != GLEW_OK) { + std::cerr << "Failed to initialize GLEW." << std::endl; + return -1; + } + + reshapeFunc(window, width, height); + + GLuint vertId = 0, fragId = 0, progId = 0; + if (false == LoadShader(GL_VERTEX_SHADER, vertId, "shader.vert")) { + return -1; + } + CheckErrors("load vert shader"); + + if (false == LoadShader(GL_FRAGMENT_SHADER, fragId, "shader.frag")) { + return -1; + } + CheckErrors("load frag shader"); + + if (false == LinkShader(progId, vertId, fragId)) { + return -1; + } + + CheckErrors("link"); + + { + // At least `in_vertex` should be used in the shader. + GLint vtxLoc = glGetAttribLocation(progId, "in_vertex"); + if (vtxLoc < 0) { + printf("vertex loc not found.\n"); + exit(-1); + } + } + + glUseProgram(progId); + CheckErrors("useProgram"); + + SetupMeshState(model, progId); + // SetupCurvesState(model, progId); + CheckErrors("SetupGLState"); + + std::cout << "# of meshes = " << model.meshes.size() << std::endl; + + while (glfwWindowShouldClose(window) == GL_FALSE) { + glfwPollEvents(); + glClearColor(0.1f, 0.2f, 0.3f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glEnable(GL_DEPTH_TEST); + + GLfloat mat[4][4]; + build_rotmatrix(mat, curr_quat); + + // camera(define it in projection matrix) + glMatrixMode(GL_PROJECTION); + glPushMatrix(); + gluLookAt(eye[0], eye[1], eye[2], lookat[0], lookat[1], lookat[2], up[0], + up[1], up[2]); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glMultMatrixf(&mat[0][0]); + + glScalef(scale, scale, scale); + + DrawModel(model); + + glMatrixMode(GL_PROJECTION); + glPopMatrix(); + + glFlush(); + + glfwSwapBuffers(window); + } + + glfwTerminate(); +} diff --git a/3rdparty/tinygltf/examples/glview/premake5.lua b/3rdparty/tinygltf/examples/glview/premake5.lua new file mode 100644 index 0000000..98bffc8 --- /dev/null +++ b/3rdparty/tinygltf/examples/glview/premake5.lua @@ -0,0 +1,43 @@ +solution "glview" + -- location ( "build" ) + configurations { "Debug", "Release" } + platforms {"native", "x64", "x32"} + + project "glview" + + kind "ConsoleApp" + language "C++" + cppdialect "C++11" + files { "glview.cc", "trackball.cc" } + includedirs { "./" } + includedirs { "../../" } + + configuration { "linux" } + linkoptions { "`pkg-config --libs glfw3`" } + links { "GL", "GLU", "m", "GLEW", "X11", "Xrandr", "Xinerama", "Xi", "Xxf86vm", "Xcursor", "dl" } + + configuration { "windows" } + -- Edit path to glew and GLFW3 fit to your environment. + includedirs { "../../../../local/glew-1.13.0/include/" } + includedirs { "../../../../local/glfw-3.2.bin.WIN32/include/" } + libdirs { "../../../../local/glew-1.13.0/lib/Release/Win32/" } + libdirs { "../../../../local/glfw-3.2.bin.WIN32/lib-vc2013/" } + links { "glfw3", "gdi32", "winmm", "user32", "glew32", "glu32","opengl32", "kernel32" } + defines { "_CRT_SECURE_NO_WARNINGS" } + + configuration { "macosx" } + includedirs { "/usr/local/include" } + buildoptions { "-Wno-deprecated-declarations" } + libdirs { "/usr/local/lib" } + links { "glfw3", "GLEW" } + linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo" } + + configuration "Debug" + defines { "DEBUG" } + symbols "On" + warnings "Extra" + + configuration "Release" + defines { "NDEBUG" } + optimize "On" + warnings "Extra" diff --git a/3rdparty/tinygltf/examples/glview/shader.frag b/3rdparty/tinygltf/examples/glview/shader.frag new file mode 100644 index 0000000..05d28ce --- /dev/null +++ b/3rdparty/tinygltf/examples/glview/shader.frag @@ -0,0 +1,16 @@ +uniform sampler2D diffuseTex; +uniform int uIsCurve; + +varying vec3 normal; +varying vec2 texcoord; + +void main(void) +{ + //gl_FragColor = vec4(0.5 * normalize(normal) + 0.5, 1.0); + //gl_FragColor = vec4(texcoord, 0.0, 1.0); + if (uIsCurve > 0) { + gl_FragColor = texture2D(diffuseTex, texcoord); + } else { + gl_FragColor = vec4(0.5 * normalize(normal) + 0.5, 1.0); + } +} diff --git a/3rdparty/tinygltf/examples/glview/shader.vert b/3rdparty/tinygltf/examples/glview/shader.vert new file mode 100644 index 0000000..e21752d --- /dev/null +++ b/3rdparty/tinygltf/examples/glview/shader.vert @@ -0,0 +1,16 @@ +attribute vec3 in_vertex; +attribute vec3 in_normal; +attribute vec2 in_texcoord; + +varying vec3 normal; +varying vec2 texcoord; + +void main(void) +{ + vec4 p = gl_ModelViewProjectionMatrix * vec4(in_vertex, 1); + gl_Position = p; + vec4 nn = gl_ModelViewMatrixInverseTranspose * vec4(normalize(in_normal), 0); + normal = nn.xyz; + + texcoord = in_texcoord; +} diff --git a/3rdparty/tinygltf/examples/glview/trackball.cc b/3rdparty/tinygltf/examples/glview/trackball.cc new file mode 100644 index 0000000..86ff3b3 --- /dev/null +++ b/3rdparty/tinygltf/examples/glview/trackball.cc @@ -0,0 +1,292 @@ +/* + * (c) Copyright 1993, 1994, Silicon Graphics, Inc. + * ALL RIGHTS RESERVED + * Permission to use, copy, modify, and distribute this software for + * any purpose and without fee is hereby granted, provided that the above + * copyright notice appear in all copies and that both the copyright notice + * and this permission notice appear in supporting documentation, and that + * the name of Silicon Graphics, Inc. not be used in advertising + * or publicity pertaining to distribution of the software without specific, + * written prior permission. + * + * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS" + * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR + * FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON + * GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT, + * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY + * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION, + * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF + * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC. HAS BEEN + * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE + * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE. + * + * US Government Users Restricted Rights + * Use, duplication, or disclosure by the Government is subject to + * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph + * (c)(1)(ii) of the Rights in Technical Data and Computer Software + * clause at DFARS 252.227-7013 and/or in similar or successor + * clauses in the FAR or the DOD or NASA FAR Supplement. + * Unpublished-- rights reserved under the copyright laws of the + * United States. Contractor/manufacturer is Silicon Graphics, + * Inc., 2011 N. Shoreline Blvd., Mountain View, CA 94039-7311. + * + * OpenGL(TM) is a trademark of Silicon Graphics, Inc. + */ +/* + * Trackball code: + * + * Implementation of a virtual trackball. + * Implemented by Gavin Bell, lots of ideas from Thant Tessman and + * the August '88 issue of Siggraph's "Computer Graphics," pp. 121-129. + * + * Vector manip code: + * + * Original code from: + * David M. Ciemiewicz, Mark Grossman, Henry Moreton, and Paul Haeberli + * + * Much mucking with by: + * Gavin Bell + */ +#include +#include "trackball.h" + +/* + * This size should really be based on the distance from the center of + * rotation to the point on the object underneath the mouse. That + * point would then track the mouse as closely as possible. This is a + * simple example, though, so that is left as an Exercise for the + * Programmer. + */ +#define TRACKBALLSIZE (0.8) + +/* + * Local function prototypes (not defined in trackball.h) + */ +static float tb_project_to_sphere(float, float, float); +static void normalize_quat(float[4]); + +static void vzero(float *v) { + v[0] = 0.0; + v[1] = 0.0; + v[2] = 0.0; +} + +static void vset(float *v, float x, float y, float z) { + v[0] = x; + v[1] = y; + v[2] = z; +} + +static void vsub(const float *src1, const float *src2, float *dst) { + dst[0] = src1[0] - src2[0]; + dst[1] = src1[1] - src2[1]; + dst[2] = src1[2] - src2[2]; +} + +static void vcopy(const float *v1, float *v2) { + register int i; + for (i = 0; i < 3; i++) + v2[i] = v1[i]; +} + +static void vcross(const float *v1, const float *v2, float *cross) { + float temp[3]; + + temp[0] = (v1[1] * v2[2]) - (v1[2] * v2[1]); + temp[1] = (v1[2] * v2[0]) - (v1[0] * v2[2]); + temp[2] = (v1[0] * v2[1]) - (v1[1] * v2[0]); + vcopy(temp, cross); +} + +static float vlength(const float *v) { + return sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]); +} + +static void vscale(float *v, float div) { + v[0] *= div; + v[1] *= div; + v[2] *= div; +} + +static void vnormal(float *v) { vscale(v, 1.0 / vlength(v)); } + +static float vdot(const float *v1, const float *v2) { + return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]; +} + +static void vadd(const float *src1, const float *src2, float *dst) { + dst[0] = src1[0] + src2[0]; + dst[1] = src1[1] + src2[1]; + dst[2] = src1[2] + src2[2]; +} + +/* + * Ok, simulate a track-ball. Project the points onto the virtual + * trackball, then figure out the axis of rotation, which is the cross + * product of P1 P2 and O P1 (O is the center of the ball, 0,0,0) + * Note: This is a deformed trackball-- is a trackball in the center, + * but is deformed into a hyperbolic sheet of rotation away from the + * center. This particular function was chosen after trying out + * several variations. + * + * It is assumed that the arguments to this routine are in the range + * (-1.0 ... 1.0) + */ +void trackball(float q[4], float p1x, float p1y, float p2x, float p2y) { + float a[3]; /* Axis of rotation */ + float phi; /* how much to rotate about axis */ + float p1[3], p2[3], d[3]; + float t; + + if (p1x == p2x && p1y == p2y) { + /* Zero rotation */ + vzero(q); + q[3] = 1.0; + return; + } + + /* + * First, figure out z-coordinates for projection of P1 and P2 to + * deformed sphere + */ + vset(p1, p1x, p1y, tb_project_to_sphere(TRACKBALLSIZE, p1x, p1y)); + vset(p2, p2x, p2y, tb_project_to_sphere(TRACKBALLSIZE, p2x, p2y)); + + /* + * Now, we want the cross product of P1 and P2 + */ + vcross(p2, p1, a); + + /* + * Figure out how much to rotate around that axis. + */ + vsub(p1, p2, d); + t = vlength(d) / (2.0 * TRACKBALLSIZE); + + /* + * Avoid problems with out-of-control values... + */ + if (t > 1.0) + t = 1.0; + if (t < -1.0) + t = -1.0; + phi = 2.0 * asin(t); + + axis_to_quat(a, phi, q); +} + +/* + * Given an axis and angle, compute quaternion. + */ +void axis_to_quat(float a[3], float phi, float q[4]) { + vnormal(a); + vcopy(a, q); + vscale(q, sin(phi / 2.0)); + q[3] = cos(phi / 2.0); +} + +/* + * Project an x,y pair onto a sphere of radius r OR a hyperbolic sheet + * if we are away from the center of the sphere. + */ +static float tb_project_to_sphere(float r, float x, float y) { + float d, t, z; + + d = sqrt(x * x + y * y); + if (d < r * 0.70710678118654752440) { /* Inside sphere */ + z = sqrt(r * r - d * d); + } else { /* On hyperbola */ + t = r / 1.41421356237309504880; + z = t * t / d; + } + return z; +} + +/* + * Given two rotations, e1 and e2, expressed as quaternion rotations, + * figure out the equivalent single rotation and stuff it into dest. + * + * This routine also normalizes the result every RENORMCOUNT times it is + * called, to keep error from creeping in. + * + * NOTE: This routine is written so that q1 or q2 may be the same + * as dest (or each other). + */ + +#define RENORMCOUNT 97 + +void add_quats(float q1[4], float q2[4], float dest[4]) { + static int count = 0; + float t1[4], t2[4], t3[4]; + float tf[4]; + + vcopy(q1, t1); + vscale(t1, q2[3]); + + vcopy(q2, t2); + vscale(t2, q1[3]); + + vcross(q2, q1, t3); + vadd(t1, t2, tf); + vadd(t3, tf, tf); + tf[3] = q1[3] * q2[3] - vdot(q1, q2); + + dest[0] = tf[0]; + dest[1] = tf[1]; + dest[2] = tf[2]; + dest[3] = tf[3]; + + if (++count > RENORMCOUNT) { + count = 0; + normalize_quat(dest); + } +} + +/* + * Quaternions always obey: a^2 + b^2 + c^2 + d^2 = 1.0 + * If they don't add up to 1.0, dividing by their magnitued will + * renormalize them. + * + * Note: See the following for more information on quaternions: + * + * - Shoemake, K., Animating rotation with quaternion curves, Computer + * Graphics 19, No 3 (Proc. SIGGRAPH'85), 245-254, 1985. + * - Pletinckx, D., Quaternion calculus as a basic tool in computer + * graphics, The Visual Computer 5, 2-13, 1989. + */ +static void normalize_quat(float q[4]) { + int i; + float mag; + + mag = (q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3]); + for (i = 0; i < 4; i++) + q[i] /= mag; +} + +/* + * Build a rotation matrix, given a quaternion rotation. + * + */ +void build_rotmatrix(float m[4][4], const float q[4]) { + m[0][0] = 1.0 - 2.0 * (q[1] * q[1] + q[2] * q[2]); + m[0][1] = 2.0 * (q[0] * q[1] - q[2] * q[3]); + m[0][2] = 2.0 * (q[2] * q[0] + q[1] * q[3]); + m[0][3] = 0.0; + + m[1][0] = 2.0 * (q[0] * q[1] + q[2] * q[3]); + m[1][1] = 1.0 - 2.0 * (q[2] * q[2] + q[0] * q[0]); + m[1][2] = 2.0 * (q[1] * q[2] - q[0] * q[3]); + m[1][3] = 0.0; + + m[2][0] = 2.0 * (q[2] * q[0] - q[1] * q[3]); + m[2][1] = 2.0 * (q[1] * q[2] + q[0] * q[3]); + m[2][2] = 1.0 - 2.0 * (q[1] * q[1] + q[0] * q[0]); + m[2][3] = 0.0; + + m[3][0] = 0.0; + m[3][1] = 0.0; + m[3][2] = 0.0; + m[3][3] = 1.0; +} diff --git a/3rdparty/tinygltf/examples/glview/trackball.h b/3rdparty/tinygltf/examples/glview/trackball.h new file mode 100644 index 0000000..b1f9437 --- /dev/null +++ b/3rdparty/tinygltf/examples/glview/trackball.h @@ -0,0 +1,75 @@ +/* + * (c) Copyright 1993, 1994, Silicon Graphics, Inc. + * ALL RIGHTS RESERVED + * Permission to use, copy, modify, and distribute this software for + * any purpose and without fee is hereby granted, provided that the above + * copyright notice appear in all copies and that both the copyright notice + * and this permission notice appear in supporting documentation, and that + * the name of Silicon Graphics, Inc. not be used in advertising + * or publicity pertaining to distribution of the software without specific, + * written prior permission. + * + * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS" + * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR + * FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON + * GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT, + * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY + * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION, + * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF + * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC. HAS BEEN + * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE + * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE. + * + * US Government Users Restricted Rights + * Use, duplication, or disclosure by the Government is subject to + * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph + * (c)(1)(ii) of the Rights in Technical Data and Computer Software + * clause at DFARS 252.227-7013 and/or in similar or successor + * clauses in the FAR or the DOD or NASA FAR Supplement. + * Unpublished-- rights reserved under the copyright laws of the + * United States. Contractor/manufacturer is Silicon Graphics, + * Inc., 2011 N. Shoreline Blvd., Mountain View, CA 94039-7311. + * + * OpenGL(TM) is a trademark of Silicon Graphics, Inc. + */ +/* + * trackball.h + * A virtual trackball implementation + * Written by Gavin Bell for Silicon Graphics, November 1988. + */ + +/* + * Pass the x and y coordinates of the last and current positions of + * the mouse, scaled so they are from (-1.0 ... 1.0). + * + * The resulting rotation is returned as a quaternion rotation in the + * first paramater. + */ +void trackball(float q[4], float p1x, float p1y, float p2x, float p2y); + +void negate_quat(float *q, float *qn); + +/* + * Given two quaternions, add them together to get a third quaternion. + * Adding quaternions to get a compound rotation is analagous to adding + * translations to get a compound translation. When incrementally + * adding rotations, the first argument here should be the new + * rotation, the second and third the total rotation (which will be + * over-written with the resulting new total rotation). + */ +void add_quats(float *q1, float *q2, float *dest); + +/* + * A useful function, builds a rotation matrix in Matrix based on + * given quaternion. + */ +void build_rotmatrix(float m[4][4], const float q[4]); + +/* + * This function computes a quaternion based on an axis (defined by + * the given vector) and an angle about which to rotate. The angle is + * expressed in radians. The result is put into the third argument. + */ +void axis_to_quat(float a[3], float phi, float q[4]); diff --git a/3rdparty/tinygltf/examples/raytrace/README.md b/3rdparty/tinygltf/examples/raytrace/README.md new file mode 100644 index 0000000..477935d --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/README.md @@ -0,0 +1,130 @@ +# NanoSG + +Simple, minimal and header-only scene graph library for NanoRT. + +NanoSG itself shoud be compiled with C++-03 compiler, but demo code uses C++11 features. + +![screenshot of the demo program](images/nanosg-demo.png) + +![Animation showing node manipulation](https://media.giphy.com/media/l3JDO29fMFndyObHW/giphy.gif) + +## Build + +### Linux or macOS + +```bash +premake5 gmake +make +``` + +### Windows + +```bash +premake5 vs2015 +``` + +## Data structure + +### Node + +Node represents scene graph node. Tansformation node or Mesh(shape) node. +Node is interpreted as transformation node when passing `nullptr` to Node class constructure. + +Node can contain multiple children. + +### Scene + +Scene contains root nodes and provides the method to find an intersection of nodes. + +## User defined data structure + +Following are required in user application. + +### Mesh class + +Current example code assumes mesh is all composed of triangle meshes. + +Following method must be implemented for `Scene::Traversal`. + +```cpp +/// +/// Get the geometric normal and the shading normal at `face_idx' th face. +/// +template +void GetNormal(T Ng[3], T Ns[3], const unsigned int face_idx, const T u, const T v) const; +``` + +### Intersection class + +Represents intersection(hit) information. + +### Transform + +Transformation is done in the following procedure. + +`M' = parent_xform x local_xform x local_pivot` + +## Memory management + +`Scene` and `Node` does not create a copy of asset data(e.g. vertices, indices). Thus user must care about memory management of scene assets in user side. + +## API + +API is still subject to change. + +### Node + +```cpp +void Node::SetName(const std::string &name); +``` + +Set (unique) name for the node. + +```cpp +void Node::AddChild(const type &child); +``` + +Add node as child node. + +```cpp +void Node::SetLocalXform(const T xform[4][4]) { +``` + +Set local transformation matrix. Default is identity matrix. + +### Scene + +```cpp +bool Scene::AddNode(const Node &node); +``` + +Add a node to the scene. + +```cpp +bool Scene::Commit() { +``` + +Commit the scene. After adding nodes to the scene or changed transformation matrix, call this `Commit` before tracing rays. +`Commit` triggers BVH build in each nodes and updates node's transformation matrix. + +```cpp +template +bool Scene::Traverse(nanort::Ray &ray, H *isect, const bool cull_back_face = false) const; +``` + +Trace ray into the scene and find an intersection. +Returns `true` when there is an intersection and hit information is stored in `isect`. + +## TODO + +* [ ] Compute pivot point of each node(mesh). + +## Third party libraries and its icenses + +* picojson : BSD license. +* bt3gui : zlib license. +* glew : BSD/MIT license. +* tinyobjloader : MIT license. +* glm : The Happy Bunny License (Modified MIT License). Copyright (c) 2005 - 2017 G-Truc Creation +* ImGui : The MIT License (MIT). Copyright (c) 2014-2015 Omar Cornut and ImGui contributors +* ImGuizmo : The MIT License (MIT). Copyright (c) 2016 Cedric Guillemet diff --git a/3rdparty/tinygltf/examples/raytrace/config.json b/3rdparty/tinygltf/examples/raytrace/config.json new file mode 100644 index 0000000..e78c54c --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/config.json @@ -0,0 +1,23 @@ +{ + "commented_out_obj_filename": "cornellbox_suzanne.obj", + "gltf_filename": "../../models/Cube/Cube.gltf", + "scene_scale": 1.0, + "width": 512, + "height": 512, + "eye": [ + 0, + 2.5, + 15 + ], + "up": [ + 0, + 1, + 0 + ], + "look_at": [ + 0, + 0, + 0 + ], + "dummy": 0 +} diff --git a/3rdparty/tinygltf/examples/raytrace/gltf-loader.cc b/3rdparty/tinygltf/examples/raytrace/gltf-loader.cc new file mode 100644 index 0000000..8015913 --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/gltf-loader.cc @@ -0,0 +1,491 @@ +#include "gltf-loader.h" + +#include +#include // c++11 +#define TINYGLTF_IMPLEMENTATION +#include + +namespace example { +static std::string GetFilePathExtension(const std::string &FileName) { + if (FileName.find_last_of(".") != std::string::npos) + return FileName.substr(FileName.find_last_of(".") + 1); + return ""; +} + +/// +/// Loads glTF 2.0 mesh +/// +bool LoadGLTF(const std::string &filename, float scale, + std::vector > *meshes, + std::vector *materials, + std::vector *textures) { + // TODO(syoyo): Texture + // TODO(syoyo): Material + + tinygltf::Model model; + tinygltf::TinyGLTF loader; + std::string err; + const std::string ext = GetFilePathExtension(filename); + + bool ret = false; + if (ext.compare("glb") == 0) { + // assume binary glTF. + ret = loader.LoadBinaryFromFile(&model, &err, filename.c_str()); + } else { + // assume ascii glTF. + ret = loader.LoadASCIIFromFile(&model, &err, filename.c_str()); + } + + if (!err.empty()) { + std::cerr << "glTF parse error: " << err << std::endl; + } + if (!ret) { + std::cerr << "Failed to load glTF: " << filename << std::endl; + return false; + } + + std::cout << "loaded glTF file has:\n" + << model.accessors.size() << " accessors\n" + << model.animations.size() << " animations\n" + << model.buffers.size() << " buffers\n" + << model.bufferViews.size() << " bufferViews\n" + << model.materials.size() << " materials\n" + << model.meshes.size() << " meshes\n" + << model.nodes.size() << " nodes\n" + << model.textures.size() << " textures\n" + << model.images.size() << " images\n" + << model.skins.size() << " skins\n" + << model.samplers.size() << " samplers\n" + << model.cameras.size() << " cameras\n" + << model.scenes.size() << " scenes\n" + << model.lights.size() << " lights\n"; + + // Iterate through all the meshes in the glTF file + for (const auto &gltfMesh : model.meshes) { + std::cout << "Current mesh has " << gltfMesh.primitives.size() + << " primitives:\n"; + + // Create a mesh object + Mesh loadedMesh(sizeof(float) * 3); + + // To store the min and max of the buffer (as 3D vector of floats) + v3f pMin = {}, pMax = {}; + + // Store the name of the glTF mesh (if defined) + loadedMesh.name = gltfMesh.name; + + // For each primitive + for (const auto &meshPrimitive : gltfMesh.primitives) { + // Boolean used to check if we have converted the vertex buffer format + bool convertedToTriangleList = false; + // This permit to get a type agnostic way of reading the index buffer + std::unique_ptr indicesArrayPtr = nullptr; + { + const auto &indicesAccessor = model.accessors[meshPrimitive.indices]; + const auto &bufferView = model.bufferViews[indicesAccessor.bufferView]; + const auto &buffer = model.buffers[bufferView.buffer]; + const auto dataAddress = buffer.data.data() + bufferView.byteOffset + + indicesAccessor.byteOffset; + const auto byteStride = indicesAccessor.ByteStride(bufferView); + const auto count = indicesAccessor.count; + + // Allocate the index array in the pointer-to-base declared in the + // parent scope + switch (indicesAccessor.componentType) { + case TINYGLTF_COMPONENT_TYPE_BYTE: + indicesArrayPtr = + std::unique_ptr >(new intArray( + arrayAdapter(dataAddress, count, byteStride))); + break; + + case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE: + indicesArrayPtr = std::unique_ptr >( + new intArray(arrayAdapter( + dataAddress, count, byteStride))); + break; + + case TINYGLTF_COMPONENT_TYPE_SHORT: + indicesArrayPtr = + std::unique_ptr >(new intArray( + arrayAdapter(dataAddress, count, byteStride))); + break; + + case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT: + indicesArrayPtr = std::unique_ptr >( + new intArray(arrayAdapter( + dataAddress, count, byteStride))); + break; + + case TINYGLTF_COMPONENT_TYPE_INT: + indicesArrayPtr = std::unique_ptr >(new intArray( + arrayAdapter(dataAddress, count, byteStride))); + break; + + case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT: + indicesArrayPtr = std::unique_ptr >( + new intArray(arrayAdapter( + dataAddress, count, byteStride))); + break; + default: + break; + } + } + const auto &indices = *indicesArrayPtr; + + if (indicesArrayPtr) { + std::cout << "indices: "; + for (size_t i(0); i < indicesArrayPtr->size(); ++i) { + std::cout << indices[i] << " "; + loadedMesh.faces.push_back(indices[i]); + } + std::cout << '\n'; + } + + switch (meshPrimitive.mode) { + // We re-arrange the indices so that it describe a simple list of + // triangles + case TINYGLTF_MODE_TRIANGLE_FAN: + if (!convertedToTriangleList) { + std::cout << "TRIANGLE_FAN\n"; + // This only has to be done once per primitive + convertedToTriangleList = true; + + // We steal the guts of the vector + auto triangleFan = std::move(loadedMesh.faces); + loadedMesh.faces.clear(); + + // Push back the indices that describe just one triangle one by one + for (size_t i{2}; i < triangleFan.size(); ++i) { + loadedMesh.faces.push_back(triangleFan[0]); + loadedMesh.faces.push_back(triangleFan[i - 1]); + loadedMesh.faces.push_back(triangleFan[i]); + } + } + case TINYGLTF_MODE_TRIANGLE_STRIP: + if (!convertedToTriangleList) { + std::cout << "TRIANGLE_STRIP\n"; + // This only has to be done once per primitive + convertedToTriangleList = true; + + auto triangleStrip = std::move(loadedMesh.faces); + loadedMesh.faces.clear(); + + for (size_t i{2}; i < triangleStrip.size(); ++i) { + loadedMesh.faces.push_back(triangleStrip[i - 2]); + loadedMesh.faces.push_back(triangleStrip[i - 1]); + loadedMesh.faces.push_back(triangleStrip[i]); + } + } + case TINYGLTF_MODE_TRIANGLES: // this is the simpliest case to handle + + { + std::cout << "TRIANGLES\n"; + + for (const auto &attribute : meshPrimitive.attributes) { + const auto attribAccessor = model.accessors[attribute.second]; + const auto &bufferView = + model.bufferViews[attribAccessor.bufferView]; + const auto &buffer = model.buffers[bufferView.buffer]; + const auto dataPtr = buffer.data.data() + bufferView.byteOffset + + attribAccessor.byteOffset; + const auto byte_stride = attribAccessor.ByteStride(bufferView); + const auto count = attribAccessor.count; + + std::cout << "current attribute has count " << count + << " and stride " << byte_stride << " bytes\n"; + + std::cout << "attribute string is : " << attribute.first << '\n'; + if (attribute.first == "POSITION") { + std::cout << "found position attribute\n"; + + // get the position min/max for computing the boundingbox + pMin.x = attribAccessor.minValues[0]; + pMin.y = attribAccessor.minValues[1]; + pMin.z = attribAccessor.minValues[2]; + pMax.x = attribAccessor.maxValues[0]; + pMax.y = attribAccessor.maxValues[1]; + pMax.z = attribAccessor.maxValues[2]; + + switch (attribAccessor.type) { + case TINYGLTF_TYPE_VEC3: { + switch (attribAccessor.componentType) { + case TINYGLTF_COMPONENT_TYPE_FLOAT: + std::cout << "Type is FLOAT\n"; + // 3D vector of float + v3fArray positions( + arrayAdapter(dataPtr, count, byte_stride)); + + std::cout << "positions's size : " << positions.size() + << '\n'; + + for (size_t i{0}; i < positions.size(); ++i) { + const auto v = positions[i]; + std::cout << "positions[" << i << "]: (" << v.x << ", " + << v.y << ", " << v.z << ")\n"; + + loadedMesh.vertices.push_back(v.x * scale); + loadedMesh.vertices.push_back(v.y * scale); + loadedMesh.vertices.push_back(v.z * scale); + } + } + break; + case TINYGLTF_COMPONENT_TYPE_DOUBLE: { + std::cout << "Type is DOUBLE\n"; + switch (attribAccessor.type) { + case TINYGLTF_TYPE_VEC3: { + v3dArray positions( + arrayAdapter(dataPtr, count, byte_stride)); + for (size_t i{0}; i < positions.size(); ++i) { + const auto v = positions[i]; + std::cout << "positions[" << i << "]: (" << v.x + << ", " << v.y << ", " << v.z << ")\n"; + + loadedMesh.vertices.push_back(v.x * scale); + loadedMesh.vertices.push_back(v.y * scale); + loadedMesh.vertices.push_back(v.z * scale); + } + } break; + default: + // TODO Handle error + break; + } + break; + default: + break; + } + } break; + } + } + + if (attribute.first == "NORMAL") { + std::cout << "found normal attribute\n"; + + switch (attribAccessor.type) { + case TINYGLTF_TYPE_VEC3: { + std::cout << "Normal is VEC3\n"; + switch (attribAccessor.componentType) { + case TINYGLTF_COMPONENT_TYPE_FLOAT: { + std::cout << "Normal is FLOAT\n"; + v3fArray normals( + arrayAdapter(dataPtr, count, byte_stride)); + + // IMPORTANT: We need to reorder normals (and texture + // coordinates into "facevarying" order) for each face + + // For each triangle : + for (size_t i{0}; i < indices.size() / 3; ++i) { + // get the i'th triange's indexes + auto f0 = indices[3 * i + 0]; + auto f1 = indices[3 * i + 1]; + auto f2 = indices[3 * i + 2]; + + // get the 3 normal vectors for that face + v3f n0, n1, n2; + n0 = normals[f0]; + n1 = normals[f1]; + n2 = normals[f2]; + + // Put them in the array in the correct order + loadedMesh.facevarying_normals.push_back(n0.x); + loadedMesh.facevarying_normals.push_back(n0.y); + loadedMesh.facevarying_normals.push_back(n0.z); + + loadedMesh.facevarying_normals.push_back(n1.x); + loadedMesh.facevarying_normals.push_back(n1.y); + loadedMesh.facevarying_normals.push_back(n2.z); + + loadedMesh.facevarying_normals.push_back(n2.x); + loadedMesh.facevarying_normals.push_back(n2.y); + loadedMesh.facevarying_normals.push_back(n2.z); + } + } break; + case TINYGLTF_COMPONENT_TYPE_DOUBLE: { + std::cout << "Normal is DOUBLE\n"; + v3dArray normals( + arrayAdapter(dataPtr, count, byte_stride)); + + // IMPORTANT: We need to reorder normals (and texture + // coordinates into "facevarying" order) for each face + + // For each triangle : + for (size_t i{0}; i < indices.size() / 3; ++i) { + // get the i'th triange's indexes + auto f0 = indices[3 * i + 0]; + auto f1 = indices[3 * i + 1]; + auto f2 = indices[3 * i + 2]; + + // get the 3 normal vectors for that face + v3d n0, n1, n2; + n0 = normals[f0]; + n1 = normals[f1]; + n2 = normals[f2]; + + // Put them in the array in the correct order + loadedMesh.facevarying_normals.push_back(n0.x); + loadedMesh.facevarying_normals.push_back(n0.y); + loadedMesh.facevarying_normals.push_back(n0.z); + + loadedMesh.facevarying_normals.push_back(n1.x); + loadedMesh.facevarying_normals.push_back(n1.y); + loadedMesh.facevarying_normals.push_back(n2.z); + + loadedMesh.facevarying_normals.push_back(n2.x); + loadedMesh.facevarying_normals.push_back(n2.y); + loadedMesh.facevarying_normals.push_back(n2.z); + } + } break; + default: + std::cerr << "Unhandeled componant type for normal\n"; + } + } break; + default: + std::cerr << "Unhandeled vector type for normal\n"; + } + + // Face varying comment on the normals is also true for the UVs + if (attribute.first == "TEXCOORD_0") { + std::cout << "Found texture coordinates\n"; + + switch (attribAccessor.type) { + case TINYGLTF_TYPE_VEC2: { + std::cout << "TEXTCOORD is VEC2\n"; + switch (attribAccessor.componentType) { + case TINYGLTF_COMPONENT_TYPE_FLOAT: { + std::cout << "TEXTCOORD is FLOAT\n"; + v2fArray uvs( + arrayAdapter(dataPtr, count, byte_stride)); + + for (size_t i{0}; i < indices.size() / 3; ++i) { + // get the i'th triange's indexes + auto f0 = indices[3 * i + 0]; + auto f1 = indices[3 * i + 1]; + auto f2 = indices[3 * i + 2]; + + // get the texture coordinates for each triangle's + // vertices + v2f uv0, uv1, uv2; + uv0 = uvs[f0]; + uv1 = uvs[f1]; + uv2 = uvs[f2]; + + // push them in order into the mesh data + loadedMesh.facevarying_uvs.push_back(uv0.x); + loadedMesh.facevarying_uvs.push_back(uv0.y); + + loadedMesh.facevarying_uvs.push_back(uv1.x); + loadedMesh.facevarying_uvs.push_back(uv1.y); + + loadedMesh.facevarying_uvs.push_back(uv2.x); + loadedMesh.facevarying_uvs.push_back(uv2.y); + } + + } break; + case TINYGLTF_COMPONENT_TYPE_DOUBLE: { + std::cout << "TEXTCOORD is DOUBLE\n"; + v2dArray uvs( + arrayAdapter(dataPtr, count, byte_stride)); + + for (size_t i{0}; i < indices.size() / 3; ++i) { + // get the i'th triange's indexes + auto f0 = indices[3 * i + 0]; + auto f1 = indices[3 * i + 1]; + auto f2 = indices[3 * i + 2]; + + v2d uv0, uv1, uv2; + uv0 = uvs[f0]; + uv1 = uvs[f1]; + uv2 = uvs[f2]; + + loadedMesh.facevarying_uvs.push_back(uv0.x); + loadedMesh.facevarying_uvs.push_back(uv0.y); + + loadedMesh.facevarying_uvs.push_back(uv1.x); + loadedMesh.facevarying_uvs.push_back(uv1.y); + + loadedMesh.facevarying_uvs.push_back(uv2.x); + loadedMesh.facevarying_uvs.push_back(uv2.y); + } + } break; + default: + std::cerr << "unrecognized vector type for UV"; + } + } break; + default: + std::cerr << "unreconized componant type for UV"; + } + } + } + } + break; + + default: + std::cerr << "primitive mode not implemented"; + break; + + // These aren't triangles: + case TINYGLTF_MODE_POINTS: + case TINYGLTF_MODE_LINE: + case TINYGLTF_MODE_LINE_LOOP: + std::cerr << "primitive is not triangle based, ignoring"; + } + } + + // bbox : + v3f bCenter; + bCenter.x = 0.5f * (pMax.x - pMin.x) + pMin.x; + bCenter.y = 0.5f * (pMax.y - pMin.y) + pMin.y; + bCenter.z = 0.5f * (pMax.z - pMin.z) + pMin.z; + + for (size_t v = 0; v < loadedMesh.vertices.size() / 3; v++) { + loadedMesh.vertices[3 * v + 0] -= bCenter.x; + loadedMesh.vertices[3 * v + 1] -= bCenter.y; + loadedMesh.vertices[3 * v + 2] -= bCenter.z; + } + + loadedMesh.pivot_xform[0][0] = 1.0f; + loadedMesh.pivot_xform[0][1] = 0.0f; + loadedMesh.pivot_xform[0][2] = 0.0f; + loadedMesh.pivot_xform[0][3] = 0.0f; + + loadedMesh.pivot_xform[1][0] = 0.0f; + loadedMesh.pivot_xform[1][1] = 1.0f; + loadedMesh.pivot_xform[1][2] = 0.0f; + loadedMesh.pivot_xform[1][3] = 0.0f; + + loadedMesh.pivot_xform[2][0] = 0.0f; + loadedMesh.pivot_xform[2][1] = 0.0f; + loadedMesh.pivot_xform[2][2] = 1.0f; + loadedMesh.pivot_xform[2][3] = 0.0f; + + loadedMesh.pivot_xform[3][0] = bCenter.x; + loadedMesh.pivot_xform[3][1] = bCenter.y; + loadedMesh.pivot_xform[3][2] = bCenter.z; + loadedMesh.pivot_xform[3][3] = 1.0f; + + // TODO handle materials + for (size_t i{0}; i < loadedMesh.faces.size(); ++i) + loadedMesh.material_ids.push_back(materials->at(0).id); + + meshes->push_back(loadedMesh); + ret = true; + } + } + + // Iterate through all texture declaration in glTF file + for (const auto &gltfTexture : model.textures) { + std::cout << "Found texture!"; + Texture loadedTexture; + const auto &image = model.images[gltfTexture.source]; + loadedTexture.components = image.component; + loadedTexture.width = image.width; + loadedTexture.height = image.height; + + const auto size = + image.component * image.width * image.height * sizeof(unsigned char); + loadedTexture.image = new unsigned char[size]; + memcpy(loadedTexture.image, image.image.data(), size); + textures->push_back(loadedTexture); + } + return ret; +} +} // namespace example diff --git a/3rdparty/tinygltf/examples/raytrace/gltf-loader.h b/3rdparty/tinygltf/examples/raytrace/gltf-loader.h new file mode 100644 index 0000000..6f8b890 --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/gltf-loader.h @@ -0,0 +1,166 @@ +#ifndef EXAMPLE_GLTF_LOADER_H_ +#define EXAMPLE_GLTF_LOADER_H_ + +#include +#include +#include + +#include "material.h" +#include "mesh.h" + +namespace example { + +/// Adapts an array of bytes to an array of T. Will advace of byte_stride each +/// elements. +template +struct arrayAdapter { + /// Pointer to the bytes + const unsigned char *dataPtr; + /// Number of elements in the array + const size_t elemCount; + /// Stride in bytes between two elements + const size_t stride; + + /// Construct an array adapter. + /// \param ptr Pointer to the start of the data, with offset applied + /// \param count Number of elements in the array + /// \param byte_stride Stride betweens elements in the array + arrayAdapter(const unsigned char *ptr, size_t count, size_t byte_stride) + : dataPtr(ptr), elemCount(count), stride(byte_stride) {} + + /// Returns a *copy* of a single element. Can't be used to modify it. + T operator[](size_t pos) const { + if (pos >= elemCount) + throw std::out_of_range( + "Tried to access beyond the last element of an array adapter with " + "count " + + std::to_string(elemCount) + " while getting elemnet number " + + std::to_string(pos)); + return *(reinterpret_cast(dataPtr + pos * stride)); + } +}; + +/// Interface of any adapted array that returns ingeger data +struct intArrayBase { + virtual ~intArrayBase() = default; + virtual unsigned int operator[](size_t) const = 0; + virtual size_t size() const = 0; +}; + +/// Interface of any adapted array that returns float data +struct floatArrayBase { + virtual ~floatArrayBase() = default; + virtual float operator[](size_t) const = 0; + virtual size_t size() const = 0; +}; + +/// An array that loads interger types, returns them as int +template +struct intArray : public intArrayBase { + arrayAdapter adapter; + + intArray(const arrayAdapter &a) : adapter(a) {} + unsigned int operator[](size_t position) const override { + return static_cast(adapter[position]); + } + + size_t size() const override { return adapter.elemCount; } +}; + +template +struct floatArray : public floatArrayBase { + arrayAdapter adapter; + + floatArray(const arrayAdapter &a) : adapter(a) {} + float operator[](size_t position) const override { + return static_cast(adapter[position]); + } + + size_t size() const override { return adapter.elemCount; } +}; + +#pragma pack(push, 1) + +template +struct v2 { + T x, y; +}; +/// 3D vector of floats without padding +template +struct v3 { + T x, y, z; +}; + +/// 4D vector of floats without padding +template +struct v4 { + T x, y, z, w; +}; + +#pragma pack(pop) + +using v2f = v2; +using v3f = v3; +using v4f = v4; +using v2d = v2; +using v3d = v3; +using v4d = v4; + +struct v2fArray { + arrayAdapter adapter; + v2fArray(const arrayAdapter &a) : adapter(a) {} + + v2f operator[](size_t position) const { return adapter[position]; } + size_t size() const { return adapter.elemCount; } +}; + +struct v3fArray { + arrayAdapter adapter; + v3fArray(const arrayAdapter &a) : adapter(a) {} + + v3f operator[](size_t position) const { return adapter[position]; } + size_t size() const { return adapter.elemCount; } +}; + +struct v4fArray { + arrayAdapter adapter; + v4fArray(const arrayAdapter &a) : adapter(a) {} + + v4f operator[](size_t position) const { return adapter[position]; } + size_t size() const { return adapter.elemCount; } +}; + +struct v2dArray { + arrayAdapter adapter; + v2dArray(const arrayAdapter &a) : adapter(a) {} + + v2d operator[](size_t position) const { return adapter[position]; } + size_t size() const { return adapter.elemCount; } +}; + +struct v3dArray { + arrayAdapter adapter; + v3dArray(const arrayAdapter &a) : adapter(a) {} + + v3d operator[](size_t position) const { return adapter[position]; } + size_t size() const { return adapter.elemCount; } +}; + +struct v4dArray { + arrayAdapter adapter; + v4dArray(const arrayAdapter &a) : adapter(a) {} + + v4d operator[](size_t position) const { return adapter[position]; } + size_t size() const { return adapter.elemCount; } +}; + +/// +/// Loads glTF 2.0 mesh +/// +bool LoadGLTF(const std::string &filename, float scale, + std::vector > *meshes, + std::vector *materials, std::vector *textures); + +} // namespace example + +#endif // EXAMPLE_GLTF_LOADER_H_ diff --git a/3rdparty/tinygltf/examples/raytrace/images/nanosg-demo.png b/3rdparty/tinygltf/examples/raytrace/images/nanosg-demo.png new file mode 100644 index 0000000000000000000000000000000000000000..5715e5826d486c7edde719c8d22faeee27bdc59b GIT binary patch literal 124517 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

dBKaK27f3##_H9IUA zpa^nDWVs8Eq-YQP<<^fT7d)!H;L+_k zv4xK=xHbEzln63}1w)#V7wswtOomBHWM23(OyU%C6wJp4Q#oZd_(UU<10S2=7yKZf z$WM5X>vIkcIyyYvA-TP3_NcCgcZqgyY`DJ#98^8TSNC|;+UrXWGh;7N?k_32oO1K# zvK^(%2bX_8?!1V&DC-jTDIH7M<`r1flPe#5mhoTPChm9e(z2Mx22>u0j*yNzZff$` zX>MiP-rP8igvt1ds~22k-WiN{<&X4E4~b5@(~%VzCsL++GPtSIGFRzP=m^ZzSkknk znyC%rL-vsf*|7*+X_w*brrflqGiVG0GZs$>q4Z8q^}1?J1UF55b1#+V!+*-5SWY)j zkG(iL-7Y&(;$E60GvSdx!Om?l8R|MXEbBZq=sw*!-Pap7bzPU(l*Aa6emC$8Dv4r`LRHus3LuS+a=@<(NugT^ zv2W~^2!?Q{;6;T53av_yQB-}(8K8)#_?^SnZN!sc2%K<{bGtv!F&1W=I$^Oi+qUIy zx!M{OYt}MbGzZ+|hrV>KAHU(;s~=!eIWPxiE_#2v#^#F#Zr(FTmr{M2Un<;X34 zlwz$`B!ONJ*LJN7&|qZN0vYQR^?rW^GJdt_ycA8wYeB~AuEmLwlaMaEu7+Q^-eH>v z5?hQo$)0d+{qiGm7=~?Ym~lcab|a@ic3)6?!jQo-EL+WtTmDl0E=3dG_*9k⪙p6 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 z%0D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 literal 0 HcmV?d00001 diff --git a/3rdparty/tinygltf/examples/raytrace/main.cc b/3rdparty/tinygltf/examples/raytrace/main.cc new file mode 100644 index 0000000..ce4961f --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/main.cc @@ -0,0 +1,1073 @@ +/* +The MIT License (MIT) + +Copyright (c) 2015 - 2016 Light Transport Entertainment, Inc. + +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. +*/ + +#ifdef _MSC_VER +#pragma warning(disable : 4244) +#endif + +#define USE_OPENGL2 +#include "OpenGLWindow/OpenGLInclude.h" +#ifdef _WIN32 +#include "OpenGLWindow/Win32OpenGLWindow.h" +#elif defined __APPLE__ +#include "OpenGLWindow/MacOpenGLWindow.h" +#else +// assume linux +#include "OpenGLWindow/X11OpenGLWindow.h" +#endif + +#ifdef _WIN32 +#include +#include +#include +#else +#include +#include +#include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include // C++11 +#include // C++11 +#include // C++11 +#include // C++11 + +#include "imgui.h" +#include "imgui_impl_btgui.h" + +#include "ImGuizmo.h" + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable : 4201) +#endif + +#include "glm/gtc/matrix_transform.hpp" +#include "glm/gtc/quaternion.hpp" +#include "glm/gtc/type_ptr.hpp" +#include "glm/mat4x4.hpp" + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif + +#include "gltf-loader.h" +#include "nanosg.h" +#include "obj-loader.h" +#include "render-config.h" +#include "render.h" +#include "trackball.h" + +#ifdef WIN32 +#ifndef NOMINMAX +#define NOMINMAX +#endif +#endif + +b3gDefaultOpenGLWindow *window = 0; +int gWidth = 512; +int gHeight = 512; +int gMousePosX = -1, gMousePosY = -1; +bool gMouseLeftDown = false; + +// FIX issue when max passes is done - no modes is switched. pass must be set to +// 0 when mode is changed +int gShowBufferMode_prv = SHOW_BUFFER_COLOR; +int gShowBufferMode = SHOW_BUFFER_COLOR; + +bool gTabPressed = false; +bool gShiftPressed = false; +float gShowPositionScale = 1.0f; +float gShowDepthRange[2] = {10.0f, 20.f}; +bool gShowDepthPeseudoColor = true; +float gCurrQuat[4] = {0.0f, 0.0f, 0.0f, 0.0f}; +float gPrevQuat[4] = {0.0f, 0.0f, 0.0f, 0.0f}; + +static nanosg::Scene > gScene; +static example::Asset gAsset; +static std::vector > > gNodes; + +std::atomic gRenderQuit; +std::atomic gRenderRefresh; +std::atomic gRenderCancel; +std::atomic gSceneDirty; +example::RenderConfig gRenderConfig; +std::mutex gMutex; + +struct RenderLayer { + std::vector displayRGBA; // Accumurated image. + std::vector rgba; + std::vector auxRGBA; // Auxiliary buffer + std::vector sampleCounts; // Sample num counter for each pixel. + std::vector normalRGBA; // For visualizing normal + std::vector positionRGBA; // For visualizing position + std::vector depthRGBA; // For visualizing depth + std::vector texCoordRGBA; // For visualizing texcoord + std::vector varyCoordRGBA; // For visualizing varycentric coord +}; + +RenderLayer gRenderLayer; + +struct Camera { + glm::mat4 view; + glm::mat4 projection; +}; + +struct ManipConfig { + glm::vec3 snapTranslation; + glm::vec3 snapRotation; + glm::vec3 snapScale; +}; + +void RequestRender() { + { + std::lock_guard guard(gMutex); + gRenderConfig.pass = 0; + } + + gRenderRefresh = true; + gRenderCancel = true; +} + +void RenderThread() { + { + std::lock_guard guard(gMutex); + gRenderConfig.pass = 0; + } + + while (1) { + if (gRenderQuit) return; + + if (!gRenderRefresh || gRenderConfig.pass >= gRenderConfig.max_passes) { + // Give some cycles to this thread. + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + continue; + } + + auto startT = std::chrono::system_clock::now(); + + // Initialize display buffer for the first pass. + bool initial_pass = false; + { + std::lock_guard guard(gMutex); + if (gRenderConfig.pass == 0) { + initial_pass = true; + } + } + + if (gSceneDirty) { + gScene.Commit(); + gSceneDirty = false; + } + + gRenderCancel = false; + // gRenderCancel may be set to true in main loop. + // Render() will repeatedly check this flag inside the rendering loop. + + bool ret = example::Renderer::Render( + &gRenderLayer.rgba.at(0), &gRenderLayer.auxRGBA.at(0), + &gRenderLayer.sampleCounts.at(0), gCurrQuat, gScene, gAsset, + gRenderConfig, gRenderCancel, + gShowBufferMode // added mode passing + ); + + if (ret) { + std::lock_guard guard(gMutex); + + gRenderConfig.pass++; + } + + auto endT = std::chrono::system_clock::now(); + + std::chrono::duration ms = endT - startT; + + // std::cout << ms.count() << " [ms]\n"; + } +} + +void InitRender(example::RenderConfig *rc) { + rc->pass = 0; + + rc->max_passes = 128; + + gRenderLayer.sampleCounts.resize(rc->width * rc->height); + std::fill(gRenderLayer.sampleCounts.begin(), gRenderLayer.sampleCounts.end(), + 0.0); + + gRenderLayer.displayRGBA.resize(rc->width * rc->height * 4); + std::fill(gRenderLayer.displayRGBA.begin(), gRenderLayer.displayRGBA.end(), + 0.0); + + gRenderLayer.rgba.resize(rc->width * rc->height * 4); + std::fill(gRenderLayer.rgba.begin(), gRenderLayer.rgba.end(), 0.0); + + gRenderLayer.auxRGBA.resize(rc->width * rc->height * 4); + std::fill(gRenderLayer.auxRGBA.begin(), gRenderLayer.auxRGBA.end(), 0.0); + + gRenderLayer.normalRGBA.resize(rc->width * rc->height * 4); + std::fill(gRenderLayer.normalRGBA.begin(), gRenderLayer.normalRGBA.end(), + 0.0); + + gRenderLayer.positionRGBA.resize(rc->width * rc->height * 4); + std::fill(gRenderLayer.positionRGBA.begin(), gRenderLayer.positionRGBA.end(), + 0.0); + + gRenderLayer.depthRGBA.resize(rc->width * rc->height * 4); + std::fill(gRenderLayer.depthRGBA.begin(), gRenderLayer.depthRGBA.end(), 0.0); + + gRenderLayer.texCoordRGBA.resize(rc->width * rc->height * 4); + std::fill(gRenderLayer.texCoordRGBA.begin(), gRenderLayer.texCoordRGBA.end(), + 0.0); + + gRenderLayer.varyCoordRGBA.resize(rc->width * rc->height * 4); + std::fill(gRenderLayer.varyCoordRGBA.begin(), + gRenderLayer.varyCoordRGBA.end(), 0.0); + + rc->normalImage = &gRenderLayer.normalRGBA.at(0); + rc->positionImage = &gRenderLayer.positionRGBA.at(0); + rc->depthImage = &gRenderLayer.depthRGBA.at(0); + rc->texcoordImage = &gRenderLayer.texCoordRGBA.at(0); + rc->varycoordImage = &gRenderLayer.varyCoordRGBA.at(0); + + trackball(gCurrQuat, 0.0f, 0.0f, 0.0f, 0.0f); +} + +void checkErrors(std::string desc) { + GLenum e = glGetError(); + if (e != GL_NO_ERROR) { + fprintf(stderr, "OpenGL error in \"%s\": %d (%d)\n", desc.c_str(), e, e); + exit(20); + } +} + +static int CreateDisplayTextureGL(const float *data, int width, int height, + int components) { + GLuint id; + glGenTextures(1, &id); + + GLint last_texture; + glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture); + + glBindTexture(GL_TEXTURE_2D, id); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + GLenum format = GL_RGBA; + if (components == 1) { + format = GL_LUMINANCE; + } else if (components == 2) { + format = GL_LUMINANCE_ALPHA; + } else if (components == 3) { + format = GL_RGB; + } else if (components == 4) { + format = GL_RGBA; + } else { + assert(0); // "Invalid components" + } + + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, format, GL_FLOAT, + data); + + glBindTexture(GL_TEXTURE_2D, last_texture); + + return static_cast(id); +} + +void keyboardCallback(int keycode, int state) { + printf("hello key %d, state %d(ctrl %d)\n", keycode, state, + window->isModifierKeyPressed(B3G_CONTROL)); + // if (keycode == 'q' && window && window->isModifierKeyPressed(B3G_SHIFT)) { + if (keycode == 27) { + if (window) window->setRequestExit(); + } else if (keycode == ' ') { + // reset. + trackball(gCurrQuat, 0.0f, 0.0f, 0.0f, 0.0f); + // clear buffer. + memset(gRenderLayer.rgba.data(), 0, + sizeof(float) * gRenderConfig.width * gRenderConfig.height * 4); + memset(gRenderLayer.sampleCounts.data(), 0, + sizeof(int) * gRenderConfig.width * gRenderConfig.height); + } else if (keycode == 9) { + gTabPressed = (state == 1); + } else if (keycode == B3G_SHIFT) { + gShiftPressed = (state == 1); + } + + ImGui_ImplBtGui_SetKeyState(keycode, (state == 1)); + + if (keycode >= 32 && keycode <= 126) { + if (state == 1) { + ImGui_ImplBtGui_SetChar(keycode); + } + } +} + +void mouseMoveCallback(float x, float y) { + if (gMouseLeftDown) { + if (ImGuizmo::IsOver() || ImGuizmo::IsUsing()) { + gSceneDirty = true; + // RequestRender(); + } else { + float w = static_cast(gRenderConfig.width); + float h = static_cast(gRenderConfig.height); + + float y_offset = gHeight - h; + + if (gTabPressed) { + const float dolly_scale = 0.1f; + gRenderConfig.eye[2] += dolly_scale * (gMousePosY - y); + gRenderConfig.look_at[2] += dolly_scale * (gMousePosY - y); + } else if (gShiftPressed) { + const float trans_scale = 0.02f; + gRenderConfig.eye[0] += trans_scale * (gMousePosX - x); + gRenderConfig.eye[1] -= trans_scale * (gMousePosY - y); + gRenderConfig.look_at[0] += trans_scale * (gMousePosX - x); + gRenderConfig.look_at[1] -= trans_scale * (gMousePosY - y); + + } else { + // Adjust y. + trackball(gPrevQuat, (2.f * gMousePosX - w) / (float)w, + (h - 2.f * (gMousePosY - y_offset)) / (float)h, + (2.f * x - w) / (float)w, + (h - 2.f * (y - y_offset)) / (float)h); + add_quats(gPrevQuat, gCurrQuat, gCurrQuat); + } + RequestRender(); + } + } + + gMousePosX = (int)x; + gMousePosY = (int)y; +} + +void mouseButtonCallback(int button, int state, float x, float y) { + (void)x; + (void)y; + ImGui_ImplBtGui_SetMouseButtonState(button, (state == 1)); + + if (button == 0 && !state) + gMouseLeftDown = false; // prevent sticky trackball after using gizmo + + ImGuiIO &io = ImGui::GetIO(); + if (io.WantCaptureMouse || io.WantCaptureKeyboard) { + if (button == 0 && !state) { + if (ImGuizmo::IsUsing()) { + gSceneDirty = true; + RequestRender(); + } + } + } else { + // left button + if (button == 0) { + if (state) { + gMouseLeftDown = true; + if (ImGuizmo::IsOver() || ImGuizmo::IsUsing()) { + } else { + trackball(gPrevQuat, 0.0f, 0.0f, 0.0f, 0.0f); + } + } else { + } + } + } +} + +void resizeCallback(float width, float height) { + // GLfloat h = (GLfloat)height / (GLfloat)width; + GLfloat xmax, znear, zfar; + + znear = 1.0f; + zfar = 1000.0f; + xmax = znear * 0.5f; + + gWidth = static_cast(width); + gHeight = static_cast(height); +} + +inline float pseudoColor(float v, int ch) { + if (ch == 0) { // red + if (v <= 0.5f) + return 0.f; + else if (v < 0.75f) + return (v - 0.5f) / 0.25f; + else + return 1.f; + } else if (ch == 1) { // green + if (v <= 0.25f) + return v / 0.25f; + else if (v < 0.75f) + return 1.f; + else + return 1.f - (v - 0.75f) / 0.25f; + } else if (ch == 2) { // blue + if (v <= 0.25f) + return 1.f; + else if (v < 0.5f) + return 1.f - (v - 0.25f) / 0.25f; + else + return 0.f; + } else { // alpha + return 1.f; + } +} + +void UpdateDisplayTextureGL(GLint tex_id, int width, int height) { + if (tex_id < 0) { + // ??? + return; + } + + std::vector buf; + buf.resize(width * height * 4); + + if (gShowBufferMode == SHOW_BUFFER_COLOR) { + // normalize + for (size_t i = 0; i < buf.size() / 4; i++) { + buf[4 * i + 0] = gRenderLayer.rgba[4 * i + 0]; + buf[4 * i + 1] = gRenderLayer.rgba[4 * i + 1]; + buf[4 * i + 2] = gRenderLayer.rgba[4 * i + 2]; + buf[4 * i + 3] = gRenderLayer.rgba[4 * i + 3]; + if (gRenderLayer.sampleCounts[i] > 0) { + buf[4 * i + 0] /= static_cast(gRenderLayer.sampleCounts[i]); + buf[4 * i + 1] /= static_cast(gRenderLayer.sampleCounts[i]); + buf[4 * i + 2] /= static_cast(gRenderLayer.sampleCounts[i]); + buf[4 * i + 3] /= static_cast(gRenderLayer.sampleCounts[i]); + } + } + } else if (gShowBufferMode == SHOW_BUFFER_NORMAL) { + for (size_t i = 0; i < buf.size(); i++) { + buf[i] = gRenderLayer.normalRGBA[i]; + } + } else if (gShowBufferMode == SHOW_BUFFER_POSITION) { + for (size_t i = 0; i < buf.size(); i++) { + buf[i] = gRenderLayer.positionRGBA[i] * gShowPositionScale; + } + } else if (gShowBufferMode == SHOW_BUFFER_DEPTH) { + float d_min = std::min(gShowDepthRange[0], gShowDepthRange[1]); + float d_diff = fabsf(gShowDepthRange[1] - gShowDepthRange[0]); + d_diff = std::max(d_diff, std::numeric_limits::epsilon()); + for (size_t i = 0; i < buf.size(); i++) { + float v = (gRenderLayer.depthRGBA[i] - d_min) / d_diff; + if (gShowDepthPeseudoColor) { + buf[i] = pseudoColor(v, i % 4); + } else { + buf[i] = v; + } + } + } else if (gShowBufferMode == SHOW_BUFFER_TEXCOORD) { + for (size_t i = 0; i < buf.size(); i++) { + buf[i] = gRenderLayer.texCoordRGBA[i]; + } + } else if (gShowBufferMode == SHOW_BUFFER_VARYCOORD) { + for (size_t i = 0; i < buf.size(); i++) { + buf[i] = gRenderLayer.varyCoordRGBA[i]; + } + } + + // Flip Y + std::vector disp; + disp.resize(width * height * 4); + { + for (size_t y = 0; y < height; y++) { + memcpy(&disp[4 * (y * width)], &buf[4 * ((height - y - 1) * width)], + sizeof(float) * 4 * width); + } + } + + glBindTexture(GL_TEXTURE_2D, tex_id); + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_FLOAT, + disp.data()); + glBindTexture(GL_TEXTURE_2D, 0); + + // glRasterPos2i(-1, -1); + // glDrawPixels(width, height, GL_RGBA, GL_FLOAT, + // static_cast(&buf.at(0))); +} + +void EditTransform(const ManipConfig &config, const Camera &camera, + glm::mat4 &matrix) { + static ImGuizmo::OPERATION mCurrentGizmoOperation(ImGuizmo::ROTATE); + static ImGuizmo::MODE mCurrentGizmoMode(ImGuizmo::WORLD); + if (ImGui::IsKeyPressed(90)) mCurrentGizmoOperation = ImGuizmo::TRANSLATE; + if (ImGui::IsKeyPressed(69)) mCurrentGizmoOperation = ImGuizmo::ROTATE; + if (ImGui::IsKeyPressed(82)) // r Key + mCurrentGizmoOperation = ImGuizmo::SCALE; + if (ImGui::RadioButton("Translate", + mCurrentGizmoOperation == ImGuizmo::TRANSLATE)) + mCurrentGizmoOperation = ImGuizmo::TRANSLATE; + ImGui::SameLine(); + if (ImGui::RadioButton("Rotate", mCurrentGizmoOperation == ImGuizmo::ROTATE)) + mCurrentGizmoOperation = ImGuizmo::ROTATE; + ImGui::SameLine(); + if (ImGui::RadioButton("Scale", mCurrentGizmoOperation == ImGuizmo::SCALE)) + mCurrentGizmoOperation = ImGuizmo::SCALE; + float matrixTranslation[3], matrixRotation[3], matrixScale[3]; + ImGuizmo::DecomposeMatrixToComponents(&matrix[0][0], matrixTranslation, + matrixRotation, matrixScale); + ImGui::InputFloat3("Tr", matrixTranslation, 3); + ImGui::InputFloat3("Rt", matrixRotation, 3); + ImGui::InputFloat3("Sc", matrixScale, 3); + ImGuizmo::RecomposeMatrixFromComponents(matrixTranslation, matrixRotation, + matrixScale, &matrix[0][0]); + + if (mCurrentGizmoOperation != ImGuizmo::SCALE) { + if (ImGui::RadioButton("Local", mCurrentGizmoMode == ImGuizmo::LOCAL)) + mCurrentGizmoMode = ImGuizmo::LOCAL; + ImGui::SameLine(); + if (ImGui::RadioButton("World", mCurrentGizmoMode == ImGuizmo::WORLD)) + mCurrentGizmoMode = ImGuizmo::WORLD; + } + static bool useSnap(false); + if (ImGui::IsKeyPressed(83)) useSnap = !useSnap; + ImGui::Checkbox("", &useSnap); + ImGui::SameLine(); + glm::vec3 snap; + switch (mCurrentGizmoOperation) { + case ImGuizmo::TRANSLATE: + snap = config.snapTranslation; + ImGui::InputFloat3("Snap", &snap.x); + break; + case ImGuizmo::ROTATE: + snap = config.snapRotation; + ImGui::InputFloat("Angle Snap", &snap.x); + break; + case ImGuizmo::SCALE: + snap = config.snapScale; + ImGui::InputFloat("Scale Snap", &snap.x); + break; + } + ImGuiIO &io = ImGui::GetIO(); + ImGuizmo::SetRect(0, 0, io.DisplaySize.x, io.DisplaySize.y); + ImGuizmo::Manipulate(&camera.view[0][0], &camera.projection[0][0], + mCurrentGizmoOperation, mCurrentGizmoMode, &matrix[0][0], + NULL, useSnap ? &snap.x : NULL); +} + +void DrawMesh(const example::Mesh *mesh) { + // TODO(LTE): Use vertex array or use display list. + + glBegin(GL_TRIANGLES); + + if (!mesh->facevarying_normals.empty()) { + for (size_t i = 0; i < mesh->faces.size() / 3; i++) { + unsigned int f0 = mesh->faces[3 * i + 0]; + unsigned int f1 = mesh->faces[3 * i + 1]; + unsigned int f2 = mesh->faces[3 * i + 2]; + + glNormal3f(mesh->facevarying_normals[9 * i + 0], + mesh->facevarying_normals[9 * i + 1], + mesh->facevarying_normals[9 * i + 2]); + glVertex3f(mesh->vertices[3 * f0 + 0], mesh->vertices[3 * f0 + 1], + mesh->vertices[3 * f0 + 2]); + glNormal3f(mesh->facevarying_normals[9 * i + 3], + mesh->facevarying_normals[9 * i + 4], + mesh->facevarying_normals[9 * i + 5]); + glVertex3f(mesh->vertices[3 * f1 + 0], mesh->vertices[3 * f1 + 1], + mesh->vertices[3 * f1 + 2]); + glNormal3f(mesh->facevarying_normals[9 * i + 6], + mesh->facevarying_normals[9 * i + 7], + mesh->facevarying_normals[9 * i + 8]); + glVertex3f(mesh->vertices[3 * f2 + 0], mesh->vertices[3 * f2 + 1], + mesh->vertices[3 * f2 + 2]); + } + + } else { + for (size_t i = 0; i < mesh->faces.size() / 3; i++) { + unsigned int f0 = mesh->faces[3 * i + 0]; + unsigned int f1 = mesh->faces[3 * i + 1]; + unsigned int f2 = mesh->faces[3 * i + 2]; + + glVertex3f(mesh->vertices[3 * f0 + 0], mesh->vertices[3 * f0 + 1], + mesh->vertices[3 * f0 + 2]); + glVertex3f(mesh->vertices[3 * f1 + 0], mesh->vertices[3 * f1 + 1], + mesh->vertices[3 * f1 + 2]); + glVertex3f(mesh->vertices[3 * f2 + 0], mesh->vertices[3 * f2 + 1], + mesh->vertices[3 * f2 + 2]); + } + } + + glEnd(); +} + +void DrawNode(const nanosg::Node > &node) { + glPushMatrix(); + glMultMatrixf(node.GetLocalXformPtr()); + + if (node.GetMesh()) { + DrawMesh(node.GetMesh()); + } + + for (size_t i = 0; i < node.GetChildren().size(); i++) { + DrawNode(node.GetChildren()[i]); + } + + glPopMatrix(); +} + +// Draw scene with OpenGL +void DrawScene(const nanosg::Scene > &scene, + const Camera &camera) { + glEnable(GL_DEPTH_TEST); + + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glEnable(GL_LIGHT1); + + // FIXME(LTE): Use scene bounding box. + const float light0_pos[4] = {1000.0f, 1000.0f, 1000.0f, 0.0f}; + const float light1_pos[4] = {-1000.0f, -1000.0f, -1000.0f, 0.0f}; + + const float light_diffuse[4] = {0.5f, 0.5f, 0.5f, 1.0f}; + + glLightfv(GL_LIGHT0, GL_POSITION, &light0_pos[0]); + glLightfv(GL_LIGHT0, GL_DIFFUSE, &light_diffuse[0]); + glLightfv(GL_LIGHT1, GL_POSITION, &light1_pos[0]); + glLightfv(GL_LIGHT1, GL_DIFFUSE, &light_diffuse[0]); + + const std::vector > > &root_nodes = + scene.GetNodes(); + + glMatrixMode(GL_PROJECTION); + glPushMatrix(); + glLoadMatrixf(&camera.projection[0][0]); + glMatrixMode(GL_MODELVIEW); + glPushMatrix(); + glLoadMatrixf(&camera.view[0][0]); + + for (size_t i = 0; i < root_nodes.size(); i++) { + DrawNode(root_nodes[i]); + } + + glMatrixMode(GL_PROJECTION); + glPopMatrix(); + glMatrixMode(GL_MODELVIEW); + glPopMatrix(); + + glDisable(GL_LIGHT0); + glDisable(GL_LIGHT1); + glDisable(GL_LIGHTING); + glDisable(GL_DEPTH_TEST); +} + +void BuildSceneItems(std::vector *display_names, + std::vector *names, + const nanosg::Node > &node, + int indent) { + if (node.GetName().empty()) { + // Skip a node with empty name. + return; + } + + std::stringstream ss; + for (int i = 0; i < indent; i++) { + ss << " "; + } + + ss << node.GetName(); + std::string display_name = ss.str(); + + display_names->push_back(display_name); + names->push_back(node.GetName()); + + for (size_t i = 0; i < node.GetChildren().size(); i++) { + BuildSceneItems(display_names, names, node.GetChildren()[i], indent + 1); + } +} + +// tigra: add default material +example::Material default_material; + +int main(int argc, char **argv) { + std::string config_filename = "config.json"; + + if (argc > 1) { + config_filename = argv[1]; + } + + // load config + { + bool ret = + example::LoadRenderConfig(&gRenderConfig, config_filename.c_str()); + if (!ret) { + std::cerr << "Failed to load [ " << config_filename << " ]" << std::endl; + return -1; + } + } + + // construct the scene + { + std::vector > meshes; + std::vector materials; + std::vector textures; + + // tigra: set default material to 95% white diffuse + default_material.diffuse[0] = 0.95f; + default_material.diffuse[1] = 0.95f; + default_material.diffuse[2] = 0.95f; + + default_material.specular[0] = 0; + default_material.specular[1] = 0; + default_material.specular[2] = 0; + + // Material pushed as first material on the list + materials.push_back(default_material); + + if (!gRenderConfig.obj_filename.empty()) { + bool ret = LoadObj(gRenderConfig.obj_filename, gRenderConfig.scene_scale, + &meshes, &materials, &textures); + if (!ret) { + std::cerr << "Failed to load .obj [ " << gRenderConfig.obj_filename + << " ]" << std::endl; + return -1; + } + } + + if (!gRenderConfig.gltf_filename.empty()) { + std::cout << "Found gltf file : " << gRenderConfig.gltf_filename << "\n"; + + bool ret = + LoadGLTF(gRenderConfig.gltf_filename, gRenderConfig.scene_scale, + &meshes, &materials, &textures); + if (!ret) { + std::cerr << "Failed to load glTF file [ " + << gRenderConfig.gltf_filename << " ]" << std::endl; + return -1; + } + } + + if (textures.size() > 0) { + materials[0].diffuse_texid = 0; + } + + gAsset.materials = materials; + gAsset.default_material = default_material; + gAsset.textures = textures; + + for (size_t n = 0; n < meshes.size(); n++) { + size_t mesh_id = gAsset.meshes.size(); + gAsset.meshes.push_back(meshes[mesh_id]); + } + + for (size_t n = 0; n < gAsset.meshes.size(); n++) { + nanosg::Node > node(&gAsset.meshes[n]); + + // case where the name of a mesh isn't defined in the loaded file + if (gAsset.meshes[n].name.empty()) { + std::string generatedName = "unnamed_" + std::to_string(n); + gAsset.meshes[n].name = generatedName; + meshes[n].name = generatedName; + } + + node.SetName(meshes[n].name); + node.SetLocalXform(meshes[n].pivot_xform); // Use mesh's pivot transform + // as node's local transform. + gNodes.push_back(node); + + gScene.AddNode(node); + } + + if (!gScene.Commit()) { + std::cerr << "Failed to commit the scene." << std::endl; + return -1; + } + + float bmin[3], bmax[3]; + gScene.GetBoundingBox(bmin, bmax); + printf(" # of nodes : %d\n", int(gNodes.size())); + printf(" Scene Bmin : %f, %f, %f\n", bmin[0], bmin[1], + bmin[2]); + printf(" Scene Bmax : %f, %f, %f\n", bmax[0], bmax[1], + bmax[2]); + } + + std::vector imgui_node_names; + std::vector display_node_names; + std::vector node_names; + std::map > *> node_map; + + { + for (size_t i = 0; i < gScene.GetNodes().size(); i++) { + BuildSceneItems(&display_node_names, &node_names, gScene.GetNodes()[i], + /* indent */ 0); + } + + // List of strings for imgui. + // Assume nodes in the scene does not change. + for (size_t i = 0; i < display_node_names.size(); i++) { + // std::cout << "name : " << display_node_names[i] << std::endl; + imgui_node_names.push_back(display_node_names[i].c_str()); + } + + // Construct list index <-> Node ptr map. + for (size_t i = 0; i < node_names.size(); i++) { + nanosg::Node > *node; + + if (gScene.FindNode(node_names[i], &node)) { + // std::cout << "id : " << i << ", name : " << node_names[i] << + // std::endl; + node_map[i] = node; + } + } + } + + window = new b3gDefaultOpenGLWindow; + b3gWindowConstructionInfo ci; +#ifdef USE_OPENGL2 + ci.m_openglVersion = 2; +#endif + ci.m_width = 1024; + ci.m_height = 800; + window->createWindow(ci); + + window->setWindowTitle("view"); + +#ifndef __APPLE__ +#ifndef _WIN32 + // some Linux implementations need the 'glewExperimental' to be true + glewExperimental = GL_TRUE; +#endif + if (glewInit() != GLEW_OK) { + fprintf(stderr, "Failed to initialize GLEW\n"); + exit(-1); + } + + if (!GLEW_VERSION_2_1) { + fprintf(stderr, "OpenGL 2.1 is not available\n"); + exit(-1); + } +#endif + + InitRender(&gRenderConfig); + + checkErrors("init"); + + window->setMouseButtonCallback(mouseButtonCallback); + window->setMouseMoveCallback(mouseMoveCallback); + checkErrors("mouse"); + window->setKeyboardCallback(keyboardCallback); + checkErrors("keyboard"); + window->setResizeCallback(resizeCallback); + checkErrors("resize"); + + ImGui::CreateContext(); + ImGui_ImplBtGui_Init(window); + + ImGuiIO &io = ImGui::GetIO(); + io.Fonts->AddFontDefault(); + // io.Fonts->AddFontFromFileTTF("./DroidSans.ttf", 15.0f); + + glm::mat4 projection(1.0f); + glm::mat4 view(1.0f); + glm::mat4 matrix(1.0f); + + Camera camera; + + std::thread renderThread(RenderThread); + + // Trigger initial rendering request + RequestRender(); + + while (!window->requestedExit()) { + window->startRendering(); + + checkErrors("begin frame"); + + ImGui_ImplBtGui_NewFrame(gMousePosX, gMousePosY); + + ImGuizmo::BeginFrame(); + ImGuizmo::Enable(true); + + // ImGuiIO &io = ImGui::GetIO(); + ImGuizmo::SetRect(0, 0, io.DisplaySize.x, io.DisplaySize.y); + + ImGui::Begin("UI"); + { + static float col[3] = {0, 0, 0}; + static float f = 0.0f; + // if (ImGui::ColorEdit3("color", col)) { + // RequestRender(); + //} + // ImGui::InputFloat("intensity", &f); + if (ImGui::InputFloat3("eye", gRenderConfig.eye)) { + RequestRender(); + } + if (ImGui::InputFloat3("up", gRenderConfig.up)) { + RequestRender(); + } + if (ImGui::InputFloat3("look_at", gRenderConfig.look_at)) { + RequestRender(); + } + + ImGui::RadioButton("color", &gShowBufferMode, SHOW_BUFFER_COLOR); + ImGui::SameLine(); + ImGui::RadioButton("normal", &gShowBufferMode, SHOW_BUFFER_NORMAL); + ImGui::SameLine(); + ImGui::RadioButton("position", &gShowBufferMode, SHOW_BUFFER_POSITION); + ImGui::SameLine(); + ImGui::RadioButton("depth", &gShowBufferMode, SHOW_BUFFER_DEPTH); + ImGui::SameLine(); + ImGui::RadioButton("texcoord", &gShowBufferMode, SHOW_BUFFER_TEXCOORD); + ImGui::SameLine(); + ImGui::RadioButton("varycoord", &gShowBufferMode, SHOW_BUFFER_VARYCOORD); + + ImGui::InputFloat("show pos scale", &gShowPositionScale); + + ImGui::InputFloat2("show depth range", gShowDepthRange); + ImGui::Checkbox("show depth pseudo color", &gShowDepthPeseudoColor); + } + + ImGui::End(); + + glViewport(0, 0, window->getWidth(), window->getHeight()); + glClearColor(0.0f, 0.1f, 0.2f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); + + checkErrors("clear"); + + // fix max passes issue + if (gShowBufferMode_prv != gShowBufferMode) { + gRenderConfig.pass = 0; + gShowBufferMode_prv = gShowBufferMode; + } + + // Render display window + { + static GLint gl_texid = -1; + if (gl_texid < 0) { + gl_texid = CreateDisplayTextureGL(NULL, gRenderConfig.width, + gRenderConfig.height, 4); + } + + // Refresh texture until rendering finishes. + if (gRenderConfig.pass < gRenderConfig.max_passes) { + // FIXME(LTE): Do not update GL texture frequently. + UpdateDisplayTextureGL(gl_texid, gRenderConfig.width, + gRenderConfig.height); + } + + ImGui::Begin("Render"); + ImTextureID tex_id = + reinterpret_cast(static_cast(gl_texid)); + ImGui::Image(tex_id, ImVec2(256, 256), ImVec2(0, 0), + ImVec2(1, 1)); // Setup camera and draw imguizomo + + ImGui::End(); + } + + // scene graph tree + glm::mat4 node_matrix; + static int node_selected_index = 0; + { + ImGui::Begin("Scene"); + + ImGui::ListBox("Node list", &node_selected_index, imgui_node_names.data(), + imgui_node_names.size(), 16); + + auto node_selected = node_map.at(node_selected_index); + node_matrix = glm::make_mat4(node_selected->GetLocalXformPtr()); + + ImGui::End(); + } + + { + ImGui::Begin("Transform"); + + static ImGuizmo::OPERATION guizmo_op(ImGuizmo::ROTATE); + static ImGuizmo::MODE guizmo_mode(ImGuizmo::WORLD); + + glm::vec3 eye, lookat, up; + eye[0] = gRenderConfig.eye[0]; + eye[1] = gRenderConfig.eye[1]; + eye[2] = gRenderConfig.eye[2]; + + lookat[0] = gRenderConfig.look_at[0]; + lookat[1] = gRenderConfig.look_at[1]; + lookat[2] = gRenderConfig.look_at[2]; + + up[0] = gRenderConfig.up[0]; + up[1] = gRenderConfig.up[1]; + up[2] = gRenderConfig.up[2]; + + // NOTE(LTE): w, then (x,y,z) for glm::quat. + glm::quat rot = + glm::quat(gCurrQuat[3], gCurrQuat[0], gCurrQuat[1], gCurrQuat[2]); + glm::mat4 rm = glm::mat4_cast(rot); + + view = glm::lookAt(eye, lookat, up) * glm::inverse(glm::mat4_cast(rot)); + projection = glm::perspective( + 45.0f, float(window->getWidth()) / float(window->getHeight()), 0.01f, + 1000.0f); + + camera.view = view; + camera.projection = projection; + ManipConfig manip_config; + + EditTransform(manip_config, camera, node_matrix); + + float mat[4][4]; + memcpy(mat, &node_matrix[0][0], sizeof(float) * 16); + node_map[node_selected_index]->SetLocalXform(mat); + + checkErrors("edit_transform"); + + ImGui::End(); + } + + // Draw scene in OpenGL + DrawScene(gScene, camera); + + // Draw imgui + ImGui::Render(); + + checkErrors("im render"); + + window->endRendering(); + + // Give some cycles to this thread. + std::this_thread::sleep_for(std::chrono::milliseconds(16)); + } + + { + gRenderCancel = true; + gRenderQuit = true; + renderThread.join(); + } + + ImGui_ImplBtGui_Shutdown(); + delete window; + + return EXIT_SUCCESS; +} diff --git a/3rdparty/tinygltf/examples/raytrace/material.h b/3rdparty/tinygltf/examples/raytrace/material.h new file mode 100644 index 0000000..c11b953 --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/material.h @@ -0,0 +1,75 @@ +#ifndef EXAMPLE_MATERIAL_H_ +#define EXAMPLE_MATERIAL_H_ + +#include + +#ifdef __clang__ +#pragma clang diagnostic push +#if __has_warning("-Wzero-as-null-pointer-constant") +#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" +#endif +#endif + +namespace example { + +struct Material { + // float ambient[3]; + float diffuse[3]; + float specular[3]; + // float reflection[3]; + // float refraction[3]; + int id; + int diffuse_texid; + int specular_texid; + // int reflection_texid; + // int transparency_texid; + // int bump_texid; + // int normal_texid; // normal map + // int alpha_texid; // alpha map + + Material() { + // ambient[0] = 0.0; + // ambient[1] = 0.0; + // ambient[2] = 0.0; + diffuse[0] = 0.5; + diffuse[1] = 0.5; + diffuse[2] = 0.5; + specular[0] = 0.5; + specular[1] = 0.5; + specular[2] = 0.5; + // reflection[0] = 0.0; + // reflection[1] = 0.0; + // reflection[2] = 0.0; + // refraction[0] = 0.0; + // refraction[1] = 0.0; + // refraction[2] = 0.0; + id = -1; + diffuse_texid = -1; + specular_texid = -1; + // reflection_texid = -1; + // transparency_texid = -1; + // bump_texid = -1; + // normal_texid = -1; + // alpha_texid = -1; + } +}; + +struct Texture { + int width; + int height; + int components; + int _pad_; + unsigned char* image; + + Texture() { + width = -1; + height = -1; + components = -1; + image = NULL; + } +}; + +} // namespace example + + +#endif // EXAMPLE_MATERIAL_H_ diff --git a/3rdparty/tinygltf/examples/raytrace/matrix.cc b/3rdparty/tinygltf/examples/raytrace/matrix.cc new file mode 100644 index 0000000..b6670a9 --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/matrix.cc @@ -0,0 +1,216 @@ +#include +#include + +#include "matrix.h" + +//using namespace mallie; + +static inline float vdot(float a[3], float b[3]) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; +} + +static inline void vcross(float c[3], float a[3], float b[3]) { + c[0] = a[1] * b[2] - a[2] * b[1]; + c[1] = a[2] * b[0] - a[0] * b[2]; + c[2] = a[0] * b[1] - a[1] * b[0]; +} + +static inline float vlength(float v[3]) { + float len2 = vdot(v, v); + if (std::abs(len2) > 1.0e-30) { + return sqrt(len2); + } + return 0.0f; +} + +static void vnormalize(float v[3]) { + float len = vlength(v); + if (std::abs(len) > 1.0e-30) { + float inv_len = 1.0f / len; + v[0] *= inv_len; + v[1] *= inv_len; + v[2] *= inv_len; + } +} + +void Matrix::Print(float m[4][4]) { + for (int i = 0; i < 4; i++) { + printf("m[%d] = %f, %f, %f, %f\n", i, m[i][0], m[i][1], m[i][2], m[i][3]); + } +} + +void Matrix::LookAt(float m[4][4], float eye[3], float lookat[3], + float up[3]) { + + float u[3], v[3]; + float look[3]; + look[0] = lookat[0] - eye[0]; + look[1] = lookat[1] - eye[1]; + look[2] = lookat[2] - eye[2]; + vnormalize(look); + + vcross(u, look, up); + vnormalize(u); + + vcross(v, u, look); + vnormalize(v); + +#if 0 + m[0][0] = u[0]; + m[0][1] = v[0]; + m[0][2] = -look[0]; + m[0][3] = 0.0; + + m[1][0] = u[1]; + m[1][1] = v[1]; + m[1][2] = -look[1]; + m[1][3] = 0.0; + + m[2][0] = u[2]; + m[2][1] = v[2]; + m[2][2] = -look[2]; + m[2][3] = 0.0; + + m[3][0] = eye[0]; + m[3][1] = eye[1]; + m[3][2] = eye[2]; + m[3][3] = 1.0; +#else + m[0][0] = u[0]; + m[1][0] = v[0]; + m[2][0] = -look[0]; + m[3][0] = eye[0]; + + m[0][1] = u[1]; + m[1][1] = v[1]; + m[2][1] = -look[1]; + m[3][1] = eye[1]; + + m[0][2] = u[2]; + m[1][2] = v[2]; + m[2][2] = -look[2]; + m[3][2] = eye[2]; + + m[0][3] = 0.0; + m[1][3] = 0.0; + m[2][3] = 0.0; + m[3][3] = 1.0; + +#endif +} + +void Matrix::Inverse(float m[4][4]) { + /* + * codes from intel web + * cramer's rule version + */ + int i, j; + float tmp[12]; /* tmp array for pairs */ + float tsrc[16]; /* array of transpose source matrix */ + float det; /* determinant */ + + /* transpose matrix */ + for (i = 0; i < 4; i++) { + tsrc[i] = m[i][0]; + tsrc[i + 4] = m[i][1]; + tsrc[i + 8] = m[i][2]; + tsrc[i + 12] = m[i][3]; + } + + /* calculate pair for first 8 elements(cofactors) */ + tmp[0] = tsrc[10] * tsrc[15]; + tmp[1] = tsrc[11] * tsrc[14]; + tmp[2] = tsrc[9] * tsrc[15]; + tmp[3] = tsrc[11] * tsrc[13]; + tmp[4] = tsrc[9] * tsrc[14]; + tmp[5] = tsrc[10] * tsrc[13]; + tmp[6] = tsrc[8] * tsrc[15]; + tmp[7] = tsrc[11] * tsrc[12]; + tmp[8] = tsrc[8] * tsrc[14]; + tmp[9] = tsrc[10] * tsrc[12]; + tmp[10] = tsrc[8] * tsrc[13]; + tmp[11] = tsrc[9] * tsrc[12]; + + /* calculate first 8 elements(cofactors) */ + m[0][0] = tmp[0] * tsrc[5] + tmp[3] * tsrc[6] + tmp[4] * tsrc[7]; + m[0][0] -= tmp[1] * tsrc[5] + tmp[2] * tsrc[6] + tmp[5] * tsrc[7]; + m[0][1] = tmp[1] * tsrc[4] + tmp[6] * tsrc[6] + tmp[9] * tsrc[7]; + m[0][1] -= tmp[0] * tsrc[4] + tmp[7] * tsrc[6] + tmp[8] * tsrc[7]; + m[0][2] = tmp[2] * tsrc[4] + tmp[7] * tsrc[5] + tmp[10] * tsrc[7]; + m[0][2] -= tmp[3] * tsrc[4] + tmp[6] * tsrc[5] + tmp[11] * tsrc[7]; + m[0][3] = tmp[5] * tsrc[4] + tmp[8] * tsrc[5] + tmp[11] * tsrc[6]; + m[0][3] -= tmp[4] * tsrc[4] + tmp[9] * tsrc[5] + tmp[10] * tsrc[6]; + m[1][0] = tmp[1] * tsrc[1] + tmp[2] * tsrc[2] + tmp[5] * tsrc[3]; + m[1][0] -= tmp[0] * tsrc[1] + tmp[3] * tsrc[2] + tmp[4] * tsrc[3]; + m[1][1] = tmp[0] * tsrc[0] + tmp[7] * tsrc[2] + tmp[8] * tsrc[3]; + m[1][1] -= tmp[1] * tsrc[0] + tmp[6] * tsrc[2] + tmp[9] * tsrc[3]; + m[1][2] = tmp[3] * tsrc[0] + tmp[6] * tsrc[1] + tmp[11] * tsrc[3]; + m[1][2] -= tmp[2] * tsrc[0] + tmp[7] * tsrc[1] + tmp[10] * tsrc[3]; + m[1][3] = tmp[4] * tsrc[0] + tmp[9] * tsrc[1] + tmp[10] * tsrc[2]; + m[1][3] -= tmp[5] * tsrc[0] + tmp[8] * tsrc[1] + tmp[11] * tsrc[2]; + + /* calculate pairs for second 8 elements(cofactors) */ + tmp[0] = tsrc[2] * tsrc[7]; + tmp[1] = tsrc[3] * tsrc[6]; + tmp[2] = tsrc[1] * tsrc[7]; + tmp[3] = tsrc[3] * tsrc[5]; + tmp[4] = tsrc[1] * tsrc[6]; + tmp[5] = tsrc[2] * tsrc[5]; + tmp[6] = tsrc[0] * tsrc[7]; + tmp[7] = tsrc[3] * tsrc[4]; + tmp[8] = tsrc[0] * tsrc[6]; + tmp[9] = tsrc[2] * tsrc[4]; + tmp[10] = tsrc[0] * tsrc[5]; + tmp[11] = tsrc[1] * tsrc[4]; + + /* calculate second 8 elements(cofactors) */ + m[2][0] = tmp[0] * tsrc[13] + tmp[3] * tsrc[14] + tmp[4] * tsrc[15]; + m[2][0] -= tmp[1] * tsrc[13] + tmp[2] * tsrc[14] + tmp[5] * tsrc[15]; + m[2][1] = tmp[1] * tsrc[12] + tmp[6] * tsrc[14] + tmp[9] * tsrc[15]; + m[2][1] -= tmp[0] * tsrc[12] + tmp[7] * tsrc[14] + tmp[8] * tsrc[15]; + m[2][2] = tmp[2] * tsrc[12] + tmp[7] * tsrc[13] + tmp[10] * tsrc[15]; + m[2][2] -= tmp[3] * tsrc[12] + tmp[6] * tsrc[13] + tmp[11] * tsrc[15]; + m[2][3] = tmp[5] * tsrc[12] + tmp[8] * tsrc[13] + tmp[11] * tsrc[14]; + m[2][3] -= tmp[4] * tsrc[12] + tmp[9] * tsrc[13] + tmp[10] * tsrc[14]; + m[3][0] = tmp[2] * tsrc[10] + tmp[5] * tsrc[11] + tmp[1] * tsrc[9]; + m[3][0] -= tmp[4] * tsrc[11] + tmp[0] * tsrc[9] + tmp[3] * tsrc[10]; + m[3][1] = tmp[8] * tsrc[11] + tmp[0] * tsrc[8] + tmp[7] * tsrc[10]; + m[3][1] -= tmp[6] * tsrc[10] + tmp[9] * tsrc[11] + tmp[1] * tsrc[8]; + m[3][2] = tmp[6] * tsrc[9] + tmp[11] * tsrc[11] + tmp[3] * tsrc[8]; + m[3][2] -= tmp[10] * tsrc[11] + tmp[2] * tsrc[8] + tmp[7] * tsrc[9]; + m[3][3] = tmp[10] * tsrc[10] + tmp[4] * tsrc[8] + tmp[9] * tsrc[9]; + m[3][3] -= tmp[8] * tsrc[9] + tmp[11] * tsrc[0] + tmp[5] * tsrc[8]; + + /* calculate determinant */ + det = tsrc[0] * m[0][0] + tsrc[1] * m[0][1] + tsrc[2] * m[0][2] + + tsrc[3] * m[0][3]; + + /* calculate matrix inverse */ + det = 1.0f / det; + + for (j = 0; j < 4; j++) { + for (i = 0; i < 4; i++) { + m[j][i] *= det; + } + } +} + +void Matrix::Mult(float dst[4][4], float m0[4][4], float m1[4][4]) { + for (int i = 0; i < 4; ++i) { + for (int j = 0; j < 4; ++j) { + dst[i][j] = 0; + for (int k = 0; k < 4; ++k) { + dst[i][j] += m0[k][j] * m1[i][k]; + } + } + } +} + +void Matrix::MultV(float dst[3], float m[4][4], float v[3]) { + // printf("v = %f, %f, %f\n", v[0], v[1], v[2]); + dst[0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0]; + dst[1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1]; + dst[2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2]; + // printf("m = %f, %f, %f\n", m[3][0], m[3][1], m[3][2]); + // printf("dst = %f, %f, %f\n", dst[0], dst[1], dst[2]); +} diff --git a/3rdparty/tinygltf/examples/raytrace/mesh.h b/3rdparty/tinygltf/examples/raytrace/mesh.h new file mode 100644 index 0000000..4261673 --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/mesh.h @@ -0,0 +1,188 @@ +#ifndef EXAMPLE_MESH_H_ +#define EXAMPLE_MESH_H_ + +#include +#include +#include +#include + +namespace example { + + +template +inline void lerp(T dst[3], const T v0[3], const T v1[3], const T v2[3], float u, float v) { + dst[0] = (static_cast(1.0) - u - v) * v0[0] + u * v1[0] + v * v2[0]; + dst[1] = (static_cast(1.0) - u - v) * v0[1] + u * v1[1] + v * v2[1]; + dst[2] = (static_cast(1.0) - u - v) * v0[2] + u * v1[2] + v * v2[2]; +} + +template +inline T vlength(const T v[3]) { + const T d = v[0] * v[0] + v[1] * v[1] + v[2] * v[2]; + if (std::fabs(d) > std::numeric_limits::epsilon()) { + return std::sqrt(d); + } else { + return static_cast(0.0); + } +} + +template +inline void vnormalize(T dst[3], const T v[3]) { + dst[0] = v[0]; + dst[1] = v[1]; + dst[2] = v[2]; + const T len = vlength(v); + if (std::fabs(len) > std::numeric_limits::epsilon()) { + const T inv_len = static_cast(1.0) / len; + dst[0] *= inv_len; + dst[1] *= inv_len; + dst[2] *= inv_len; + } +} + +template +inline void vcross(T dst[3], const T a[3], const T b[3]) { + dst[0] = a[1] * b[2] - a[2] * b[1]; + dst[1] = a[2] * b[0] - a[0] * b[2]; + dst[2] = a[0] * b[1] - a[1] * b[0]; +} + +template +inline void vsub(T dst[3], const T a[3], const T b[3]) { + dst[0] = a[0] - b[0]; + dst[1] = a[1] - b[1]; + dst[2] = a[2] - b[2]; +} + +template +inline void calculate_normal(T Nn[3], const T v0[3], const T v1[3], const T v2[3]) { + T v10[3]; + T v20[3]; + + vsub(v10, v1, v0); + vsub(v20, v2, v0); + + T N[3]; + vcross(N, v20, v10); + vnormalize(Nn, N); +} + +template +class Mesh { + public: + explicit Mesh(const size_t vertex_stride) : + stride(vertex_stride) { + } + + std::string name; + + std::vector vertices; /// stride * num_vertices + std::vector facevarying_normals; /// [xyz] * 3(triangle) * num_faces + std::vector facevarying_tangents; /// [xyz] * 3(triangle) * num_faces + std::vector facevarying_binormals; /// [xyz] * 3(triangle) * num_faces + std::vector facevarying_uvs; /// [xy] * 3(triangle) * num_faces + std::vector + facevarying_vertex_colors; /// [xyz] * 3(triangle) * num_faces + std::vector faces; /// triangle x num_faces + std::vector material_ids; /// index x num_faces + + T pivot_xform[4][4]; + size_t stride; /// stride for vertex data. + + // --- Required methods in Scene::Traversal. --- + + /// + /// Get the geometric normal and the shading normal at `face_idx' th face. + /// + void GetNormal(T Ng[3], T Ns[3], const unsigned int face_idx, const T u, const T v) const { + // Compute geometric normal. + unsigned int f0, f1, f2; + T v0[3], v1[3], v2[3]; + + f0 = faces[3 * face_idx + 0]; + f1 = faces[3 * face_idx + 1]; + f2 = faces[3 * face_idx + 2]; + + v0[0] = vertices[3 * f0 + 0]; + v0[1] = vertices[3 * f0 + 1]; + v0[2] = vertices[3 * f0 + 2]; + + v1[0] = vertices[3 * f1 + 0]; + v1[1] = vertices[3 * f1 + 1]; + v1[2] = vertices[3 * f1 + 2]; + + v2[0] = vertices[3 * f2 + 0]; + v2[1] = vertices[3 * f2 + 1]; + v2[2] = vertices[3 * f2 + 2]; + + calculate_normal(Ng, v0, v1, v2); + + if (facevarying_normals.size() > 0) { + + T n0[3], n1[3], n2[3]; + + n0[0] = facevarying_normals[9 * face_idx + 0]; + n0[1] = facevarying_normals[9 * face_idx + 1]; + n0[2] = facevarying_normals[9 * face_idx + 2]; + + n1[0] = facevarying_normals[9 * face_idx + 3]; + n1[1] = facevarying_normals[9 * face_idx + 4]; + n1[2] = facevarying_normals[9 * face_idx + 5]; + + n2[0] = facevarying_normals[9 * face_idx + 6]; + n2[1] = facevarying_normals[9 * face_idx + 7]; + n2[2] = facevarying_normals[9 * face_idx + 8]; + + lerp(Ns, n0, n1, n2, u, v); + + } else { + + // Use geometric normal. + Ns[0] = Ng[0]; + Ns[1] = Ng[1]; + Ns[2] = Ng[2]; + + } + + } + + // --- end of required methods in Scene::Traversal. --- + + /// + /// Get texture coordinate at `face_idx' th face. + /// + void GetTexCoord(T tcoord[3], const unsigned int face_idx, const T u, const T v) { + + if (facevarying_uvs.size() > 0) { + + T t0[3], t1[3], t2[3]; + + t0[0] = facevarying_uvs[6 * face_idx + 0]; + t0[1] = facevarying_uvs[6 * face_idx + 1]; + t0[2] = static_cast(0.0); + + t1[0] = facevarying_uvs[6 * face_idx + 2]; + t1[1] = facevarying_uvs[6 * face_idx + 3]; + t1[2] = static_cast(0.0); + + t2[0] = facevarying_uvs[6 * face_idx + 4]; + t2[1] = facevarying_uvs[6 * face_idx + 5]; + t2[2] = static_cast(0.0); + + lerp(tcoord, t0, t1, t2, u, v); + + } else { + + tcoord[0] = static_cast(0.0); + tcoord[1] = static_cast(0.0); + tcoord[2] = static_cast(0.0); + + } + + } + +}; + +} // namespace example + +#endif // EXAMPLE_MESH_H_ diff --git a/3rdparty/tinygltf/examples/raytrace/nanort.cc b/3rdparty/tinygltf/examples/raytrace/nanort.cc new file mode 100644 index 0000000..0877ad6 --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/nanort.cc @@ -0,0 +1 @@ +#include "nanort.h" diff --git a/3rdparty/tinygltf/examples/raytrace/nanort.h b/3rdparty/tinygltf/examples/raytrace/nanort.h new file mode 100644 index 0000000..169e464 --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/nanort.h @@ -0,0 +1,2313 @@ +// +// NanoRT, single header only modern ray tracing kernel. +// + +/* +The MIT License (MIT) + +Copyright (c) 2015 - 2016 Light Transport Entertainment, Inc. + +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 NANORT_H_ +#define NANORT_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace nanort { + +#ifdef __clang__ +#pragma clang diagnostic push +#if __has_warning("-Wzero-as-null-pointer-constant") +#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" +#endif +#endif + +// Parallelized BVH build is not yet fully tested, +// thus turn off if you face a problem when building BVH. +#define NANORT_ENABLE_PARALLEL_BUILD (1) + +// ---------------------------------------------------------------------------- +// Small vector class useful for multi-threaded environment. +// +// stack_container.h +// +// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// This allocator can be used with STL containers to provide a stack buffer +// from which to allocate memory and overflows onto the heap. This stack buffer +// would be allocated on the stack and allows us to avoid heap operations in +// some situations. +// +// STL likes to make copies of allocators, so the allocator itself can't hold +// the data. Instead, we make the creator responsible for creating a +// StackAllocator::Source which contains the data. Copying the allocator +// merely copies the pointer to this shared source, so all allocators created +// based on our allocator will share the same stack buffer. +// +// This stack buffer implementation is very simple. The first allocation that +// fits in the stack buffer will use the stack buffer. Any subsequent +// allocations will not use the stack buffer, even if there is unused room. +// This makes it appropriate for array-like containers, but the caller should +// be sure to reserve() in the container up to the stack buffer size. Otherwise +// the container will allocate a small array which will "use up" the stack +// buffer. +template +class StackAllocator : public std::allocator { + public: + typedef typename std::allocator::pointer pointer; + typedef typename std::allocator::size_type size_type; + + // Backing store for the allocator. The container owner is responsible for + // maintaining this for as long as any containers using this allocator are + // live. + struct Source { + Source() : used_stack_buffer_(false) {} + + // Casts the buffer in its right type. + T *stack_buffer() { return reinterpret_cast(stack_buffer_); } + const T *stack_buffer() const { + return reinterpret_cast(stack_buffer_); + } + + // + // IMPORTANT: Take care to ensure that stack_buffer_ is aligned + // since it is used to mimic an array of T. + // Be careful while declaring any unaligned types (like bool) + // before stack_buffer_. + // + + // The buffer itself. It is not of type T because we don't want the + // constructors and destructors to be automatically called. Define a POD + // buffer of the right size instead. + char stack_buffer_[sizeof(T[stack_capacity])]; + + // Set when the stack buffer is used for an allocation. We do not track + // how much of the buffer is used, only that somebody is using it. + bool used_stack_buffer_; + }; + + // Used by containers when they want to refer to an allocator of type U. + template + struct rebind { + typedef StackAllocator other; + }; + + // For the straight up copy c-tor, we can share storage. + StackAllocator(const StackAllocator &rhs) + : source_(rhs.source_) {} + + // ISO C++ requires the following constructor to be defined, + // and std::vector in VC++2008SP1 Release fails with an error + // in the class _Container_base_aux_alloc_real (from ) + // if the constructor does not exist. + // For this constructor, we cannot share storage; there's + // no guarantee that the Source buffer of Ts is large enough + // for Us. + // TODO(Google): If we were fancy pants, perhaps we could share storage + // iff sizeof(T) == sizeof(U). + template + StackAllocator(const StackAllocator &other) + : source_(NULL) { + (void)other; + } + + explicit StackAllocator(Source *source) : source_(source) {} + + // Actually do the allocation. Use the stack buffer if nobody has used it yet + // and the size requested fits. Otherwise, fall through to the standard + // allocator. + pointer allocate(size_type n, void *hint = 0) { + if (source_ != NULL && !source_->used_stack_buffer_ && + n <= stack_capacity) { + source_->used_stack_buffer_ = true; + return source_->stack_buffer(); + } else { + return std::allocator::allocate(n, hint); + } + } + + // Free: when trying to free the stack buffer, just mark it as free. For + // non-stack-buffer pointers, just fall though to the standard allocator. + void deallocate(pointer p, size_type n) { + if (source_ != NULL && p == source_->stack_buffer()) + source_->used_stack_buffer_ = false; + else + std::allocator::deallocate(p, n); + } + + private: + Source *source_; +}; + +// A wrapper around STL containers that maintains a stack-sized buffer that the +// initial capacity of the vector is based on. Growing the container beyond the +// stack capacity will transparently overflow onto the heap. The container must +// support reserve(). +// +// WATCH OUT: the ContainerType MUST use the proper StackAllocator for this +// type. This object is really intended to be used only internally. You'll want +// to use the wrappers below for different types. +template +class StackContainer { + public: + typedef TContainerType ContainerType; + typedef typename ContainerType::value_type ContainedType; + typedef StackAllocator Allocator; + + // Allocator must be constructed before the container! + StackContainer() : allocator_(&stack_data_), container_(allocator_) { + // Make the container use the stack allocation by reserving our buffer size + // before doing anything else. + container_.reserve(stack_capacity); + } + + // Getters for the actual container. + // + // Danger: any copies of this made using the copy constructor must have + // shorter lifetimes than the source. The copy will share the same allocator + // and therefore the same stack buffer as the original. Use std::copy to + // copy into a "real" container for longer-lived objects. + ContainerType &container() { return container_; } + const ContainerType &container() const { return container_; } + + // Support operator-> to get to the container. This allows nicer syntax like: + // StackContainer<...> foo; + // std::sort(foo->begin(), foo->end()); + ContainerType *operator->() { return &container_; } + const ContainerType *operator->() const { return &container_; } + +#ifdef UNIT_TEST + // Retrieves the stack source so that that unit tests can verify that the + // buffer is being used properly. + const typename Allocator::Source &stack_data() const { return stack_data_; } +#endif + + protected: + typename Allocator::Source stack_data_; + unsigned char pad_[7]; + Allocator allocator_; + ContainerType container_; + + // DISALLOW_EVIL_CONSTRUCTORS(StackContainer); + StackContainer(const StackContainer &); + void operator=(const StackContainer &); +}; + +// StackVector +// +// Example: +// StackVector foo; +// foo->push_back(22); // we have overloaded operator-> +// foo[0] = 10; // as well as operator[] +template +class StackVector + : public StackContainer >, + stack_capacity> { + public: + StackVector() + : StackContainer >, + stack_capacity>() {} + + // We need to put this in STL containers sometimes, which requires a copy + // constructor. We can't call the regular copy constructor because that will + // take the stack buffer from the original. Here, we create an empty object + // and make a stack buffer of its own. + StackVector(const StackVector &other) + : StackContainer >, + stack_capacity>() { + this->container().assign(other->begin(), other->end()); + } + + StackVector &operator=( + const StackVector &other) { + this->container().assign(other->begin(), other->end()); + return *this; + } + + // Vectors are commonly indexed, which isn't very convenient even with + // operator-> (using "->at()" does exception stuff we don't want). + T &operator[](size_t i) { return this->container().operator[](i); } + const T &operator[](size_t i) const { + return this->container().operator[](i); + } +}; + +// ---------------------------------------------------------------------------- + +template +class real3 { + public: + real3() {} + real3(T x) { + v[0] = x; + v[1] = x; + v[2] = x; + } + real3(T xx, T yy, T zz) { + v[0] = xx; + v[1] = yy; + v[2] = zz; + } + explicit real3(const T *p) { + v[0] = p[0]; + v[1] = p[1]; + v[2] = p[2]; + } + + inline T x() const { return v[0]; } + inline T y() const { return v[1]; } + inline T z() const { return v[2]; } + + real3 operator*(T f) const { return real3(x() * f, y() * f, z() * f); } + real3 operator-(const real3 &f2) const { + return real3(x() - f2.x(), y() - f2.y(), z() - f2.z()); + } + real3 operator*(const real3 &f2) const { + return real3(x() * f2.x(), y() * f2.y(), z() * f2.z()); + } + real3 operator+(const real3 &f2) const { + return real3(x() + f2.x(), y() + f2.y(), z() + f2.z()); + } + real3 &operator+=(const real3 &f2) { + v[0] += f2.x(); + v[1] += f2.y(); + v[2] += f2.z(); + return (*this); + } + real3 operator/(const real3 &f2) const { + return real3(x() / f2.x(), y() / f2.y(), z() / f2.z()); + } + real3 operator-() const { return real3(-x(), -y(), -z()); } + T operator[](int i) const { return v[i]; } + T &operator[](int i) { return v[i]; } + + T v[3]; + // T pad; // for alignment(when T = float) +}; + +template +inline real3 operator*(T f, const real3 &v) { + return real3(v.x() * f, v.y() * f, v.z() * f); +} + +template +inline real3 vneg(const real3 &rhs) { + return real3(-rhs.x(), -rhs.y(), -rhs.z()); +} + +template +inline T vlength(const real3 &rhs) { + return std::sqrt(rhs.x() * rhs.x() + rhs.y() * rhs.y() + rhs.z() * rhs.z()); +} + +template +inline real3 vnormalize(const real3 &rhs) { + real3 v = rhs; + T len = vlength(rhs); + if (std::fabs(len) > static_cast(1.0e-6)) { + T inv_len = static_cast(1.0) / len; + v.v[0] *= inv_len; + v.v[1] *= inv_len; + v.v[2] *= inv_len; + } + return v; +} + +template +inline real3 vcross(real3 a, real3 b) { + real3 c; + c[0] = a[1] * b[2] - a[2] * b[1]; + c[1] = a[2] * b[0] - a[0] * b[2]; + c[2] = a[0] * b[1] - a[1] * b[0]; + return c; +} + +template +inline T vdot(real3 a, real3 b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; +} + +template +inline const real *get_vertex_addr(const real *p, const size_t idx, + const size_t stride_bytes) { + return reinterpret_cast( + reinterpret_cast(p) + idx * stride_bytes); +} + +template +class Ray { + public: + Ray() : min_t(static_cast(0.0)), max_t(std::numeric_limits::max()) { + org[0] = static_cast(0.0); + org[1] = static_cast(0.0); + org[2] = static_cast(0.0); + dir[0] = static_cast(0.0); + dir[1] = static_cast(0.0); + dir[2] = static_cast(-1.0); + } + + T org[3]; // must set + T dir[3]; // must set + T min_t; // minimum ray hit distance. + T max_t; // maximum ray hit distance. + T inv_dir[3]; // filled internally + int dir_sign[3]; // filled internally +}; + +template +class BVHNode { + public: + BVHNode() {} + BVHNode(const BVHNode &rhs) { + bmin[0] = rhs.bmin[0]; + bmin[1] = rhs.bmin[1]; + bmin[2] = rhs.bmin[2]; + flag = rhs.flag; + + bmax[0] = rhs.bmax[0]; + bmax[1] = rhs.bmax[1]; + bmax[2] = rhs.bmax[2]; + axis = rhs.axis; + + data[0] = rhs.data[0]; + data[1] = rhs.data[1]; + } + + BVHNode &operator=(const BVHNode &rhs) { + bmin[0] = rhs.bmin[0]; + bmin[1] = rhs.bmin[1]; + bmin[2] = rhs.bmin[2]; + flag = rhs.flag; + + bmax[0] = rhs.bmax[0]; + bmax[1] = rhs.bmax[1]; + bmax[2] = rhs.bmax[2]; + axis = rhs.axis; + + data[0] = rhs.data[0]; + data[1] = rhs.data[1]; + + return (*this); + } + + ~BVHNode() {} + + T bmin[3]; + T bmax[3]; + + int flag; // 1 = leaf node, 0 = branch node + int axis; + + // leaf + // data[0] = npoints + // data[1] = index + // + // branch + // data[0] = child[0] + // data[1] = child[1] + unsigned int data[2]; +}; + +template +class IntersectComparator { + public: + bool operator()(const H &a, const H &b) const { return a.t < b.t; } +}; + +/// BVH build option. +template +struct BVHBuildOptions { + T cost_t_aabb; + unsigned int min_leaf_primitives; + unsigned int max_tree_depth; + unsigned int bin_size; + unsigned int shallow_depth; + unsigned int min_primitives_for_parallel_build; + + // Cache bounding box computation. + // Requires more memory, but BVHbuild can be faster. + bool cache_bbox; + unsigned char pad[3]; + + // Set default value: Taabb = 0.2 + BVHBuildOptions() + : cost_t_aabb(0.2f), + min_leaf_primitives(4), + max_tree_depth(256), + bin_size(64), + shallow_depth(3), + min_primitives_for_parallel_build(1024 * 128), + cache_bbox(false) {} +}; + +/// BVH build statistics. +class BVHBuildStatistics { + public: + unsigned int max_tree_depth; + unsigned int num_leaf_nodes; + unsigned int num_branch_nodes; + float build_secs; + + // Set default value: Taabb = 0.2 + BVHBuildStatistics() + : max_tree_depth(0), + num_leaf_nodes(0), + num_branch_nodes(0), + build_secs(0.0f) {} +}; + +/// BVH trace option. +class BVHTraceOptions { + public: + // Hit only for face IDs in indexRange. + // This feature is good to mimic something like glDrawArrays() + unsigned int prim_ids_range[2]; + bool cull_back_face; + unsigned char pad[3]; ///< Padding(not used) + + BVHTraceOptions() { + prim_ids_range[0] = 0; + prim_ids_range[1] = 0x7FFFFFFF; // Up to 2G face IDs. + cull_back_face = false; + } +}; + +template +class BBox { + public: + real3 bmin; + real3 bmax; + + BBox() { + bmin[0] = bmin[1] = bmin[2] = std::numeric_limits::max(); + bmax[0] = bmax[1] = bmax[2] = -std::numeric_limits::max(); + } +}; + +template +class NodeHit { + public: + NodeHit() + : t_min(std::numeric_limits::max()), + t_max(-std::numeric_limits::max()), + node_id(static_cast(-1)) {} + + NodeHit(const NodeHit &rhs) { + t_min = rhs.t_min; + t_max = rhs.t_max; + node_id = rhs.node_id; + } + + NodeHit &operator=(const NodeHit &rhs) { + t_min = rhs.t_min; + t_max = rhs.t_max; + node_id = rhs.node_id; + + return (*this); + } + + ~NodeHit() {} + + T t_min; + T t_max; + unsigned int node_id; +}; + +template +class NodeHitComparator { + public: + inline bool operator()(const NodeHit &a, const NodeHit &b) { + return a.t_min < b.t_min; + } +}; + +template +class BVHAccel { + public: + BVHAccel() : pad0_(0) { (void)pad0_; } + ~BVHAccel() {} + + /// + /// Build BVH for input primitives. + /// + template + bool Build(const unsigned int num_primitives, const P &p, const Pred &pred, + const BVHBuildOptions &options = BVHBuildOptions()); + + /// + /// Get statistics of built BVH tree. Valid after Build() + /// + BVHBuildStatistics GetStatistics() const { return stats_; } + + /// + /// Dump built BVH to the file. + /// + bool Dump(const char *filename); + + /// + /// Load BVH binary + /// + bool Load(const char *filename); + + void Debug(); + + /// + /// Traverse into BVH along ray and find closest hit point & primitive if + /// found + /// + template + bool Traverse(const Ray &ray, const I &intersector, H *isect, + const BVHTraceOptions &options = BVHTraceOptions()) const; + +#if 0 + /// Multi-hit ray traversal + /// Returns `max_intersections` frontmost intersections + template + bool MultiHitTraverse(const Ray &ray, + int max_intersections, + const I &intersector, + StackVector *isects, + const BVHTraceOptions &options = BVHTraceOptions()) const; +#endif + + /// + /// List up nodes which intersects along the ray. + /// This function is useful for two-level BVH traversal. + /// + template + bool ListNodeIntersections(const Ray &ray, int max_intersections, + const I &intersector, + StackVector, 128> *hits) const; + + const std::vector > &GetNodes() const { return nodes_; } + const std::vector &GetIndices() const { return indices_; } + + /// + /// Returns bounding box of built BVH. + /// + void BoundingBox(T bmin[3], T bmax[3]) const { + if (nodes_.empty()) { + bmin[0] = bmin[1] = bmin[2] = std::numeric_limits::max(); + bmax[0] = bmax[1] = bmax[2] = -std::numeric_limits::max(); + } else { + bmin[0] = nodes_[0].bmin[0]; + bmin[1] = nodes_[0].bmin[1]; + bmin[2] = nodes_[0].bmin[2]; + bmax[0] = nodes_[0].bmax[0]; + bmax[1] = nodes_[0].bmax[1]; + bmax[2] = nodes_[0].bmax[2]; + } + } + + bool IsValid() const { return nodes_.size() > 0; } + + private: +#if NANORT_ENABLE_PARALLEL_BUILD + typedef struct { + unsigned int left_idx; + unsigned int right_idx; + unsigned int offset; + } ShallowNodeInfo; + + // Used only during BVH construction + std::vector shallow_node_infos_; + + /// Builds shallow BVH tree recursively. + template + unsigned int BuildShallowTree(std::vector > *out_nodes, + unsigned int left_idx, unsigned int right_idx, + unsigned int depth, + unsigned int max_shallow_depth, const P &p, + const Pred &pred); +#endif + + /// Builds BVH tree recursively. + template + unsigned int BuildTree(BVHBuildStatistics *out_stat, + std::vector > *out_nodes, + unsigned int left_idx, unsigned int right_idx, + unsigned int depth, const P &p, const Pred &pred); + + template + bool TestLeafNode(const BVHNode &node, const Ray &ray, + const I &intersector) const; + + template + bool TestLeafNodeIntersections( + const BVHNode &node, const Ray &ray, const int max_intersections, + const I &intersector, + std::priority_queue, std::vector >, + NodeHitComparator > *isect_pq) const; + +#if 0 + template + bool MultiHitTestLeafNode(std::priority_queue, Comp> *isect_pq, + int max_intersections, + const BVHNode &node, const Ray &ray, + const I &intersector) const; +#endif + + std::vector > nodes_; + std::vector indices_; // max 4G triangles. + std::vector > bboxes_; + BVHBuildOptions options_; + BVHBuildStatistics stats_; + unsigned int pad0_; +}; + +// Predefined SAH predicator for triangle. +template +class TriangleSAHPred { + public: + TriangleSAHPred( + const T *vertices, const unsigned int *faces, + size_t vertex_stride_bytes) // e.g. 12 for sizeof(float) * XYZ + : axis_(0), + pos_(0.0f), + vertices_(vertices), + faces_(faces), + vertex_stride_bytes_(vertex_stride_bytes) {} + + void Set(int axis, T pos) const { + axis_ = axis; + pos_ = pos; + } + + bool operator()(unsigned int i) const { + int axis = axis_; + T pos = pos_; + + unsigned int i0 = faces_[3 * i + 0]; + unsigned int i1 = faces_[3 * i + 1]; + unsigned int i2 = faces_[3 * i + 2]; + + real3 p0(get_vertex_addr(vertices_, i0, vertex_stride_bytes_)); + real3 p1(get_vertex_addr(vertices_, i1, vertex_stride_bytes_)); + real3 p2(get_vertex_addr(vertices_, i2, vertex_stride_bytes_)); + + T center = p0[axis] + p1[axis] + p2[axis]; + + return (center < pos * static_cast(3.0)); + } + + private: + mutable int axis_; + mutable T pos_; + const T *vertices_; + const unsigned int *faces_; + const size_t vertex_stride_bytes_; +}; + +// Predefined Triangle mesh geometry. +template +class TriangleMesh { + public: + TriangleMesh( + const T *vertices, const unsigned int *faces, + const size_t vertex_stride_bytes) // e.g. 12 for sizeof(float) * XYZ + : vertices_(vertices), + faces_(faces), + vertex_stride_bytes_(vertex_stride_bytes) {} + + /// Compute bounding box for `prim_index`th triangle. + /// This function is called for each primitive in BVH build. + void BoundingBox(real3 *bmin, real3 *bmax, + unsigned int prim_index) const { + (*bmin)[0] = get_vertex_addr(vertices_, faces_[3 * prim_index + 0], + vertex_stride_bytes_)[0]; + (*bmin)[1] = get_vertex_addr(vertices_, faces_[3 * prim_index + 0], + vertex_stride_bytes_)[1]; + (*bmin)[2] = get_vertex_addr(vertices_, faces_[3 * prim_index + 0], + vertex_stride_bytes_)[2]; + (*bmax)[0] = get_vertex_addr(vertices_, faces_[3 * prim_index + 0], + vertex_stride_bytes_)[0]; + (*bmax)[1] = get_vertex_addr(vertices_, faces_[3 * prim_index + 0], + vertex_stride_bytes_)[1]; + (*bmax)[2] = get_vertex_addr(vertices_, faces_[3 * prim_index + 0], + vertex_stride_bytes_)[2]; + + for (unsigned int i = 1; i < 3; i++) { + for (unsigned int k = 0; k < 3; k++) { + if ((*bmin)[static_cast(k)] > + get_vertex_addr(vertices_, faces_[3 * prim_index + i], + vertex_stride_bytes_)[k]) { + (*bmin)[static_cast(k)] = get_vertex_addr( + vertices_, faces_[3 * prim_index + i], vertex_stride_bytes_)[k]; + } + if ((*bmax)[static_cast(k)] < + get_vertex_addr(vertices_, faces_[3 * prim_index + i], + vertex_stride_bytes_)[k]) { + (*bmax)[static_cast(k)] = get_vertex_addr( + vertices_, faces_[3 * prim_index + i], vertex_stride_bytes_)[k]; + } + } + } + } + + const T *vertices_; + const unsigned int *faces_; + const size_t vertex_stride_bytes_; +}; + +template +class TriangleIntersection { + public: + T u; + T v; + + // Required member variables. + T t; + unsigned int prim_id; +}; + +template > +class TriangleIntersector { + public: + TriangleIntersector(const T *vertices, const unsigned int *faces, + const size_t vertex_stride_bytes) // e.g. + // vertex_stride_bytes + // = 12 = sizeof(float) + // * 3 + : vertices_(vertices), + faces_(faces), + vertex_stride_bytes_(vertex_stride_bytes) {} + + // For Watertight Ray/Triangle Intersection. + typedef struct { + T Sx; + T Sy; + T Sz; + int kx; + int ky; + int kz; + } RayCoeff; + + /// Do ray interesection stuff for `prim_index` th primitive and return hit + /// distance `t`, + /// varycentric coordinate `u` and `v`. + /// Returns true if there's intersection. + bool Intersect(T *t_inout, const unsigned int prim_index) const { + if ((prim_index < trace_options_.prim_ids_range[0]) || + (prim_index >= trace_options_.prim_ids_range[1])) { + return false; + } + + const unsigned int f0 = faces_[3 * prim_index + 0]; + const unsigned int f1 = faces_[3 * prim_index + 1]; + const unsigned int f2 = faces_[3 * prim_index + 2]; + + const real3 p0(get_vertex_addr(vertices_, f0 + 0, vertex_stride_bytes_)); + const real3 p1(get_vertex_addr(vertices_, f1 + 0, vertex_stride_bytes_)); + const real3 p2(get_vertex_addr(vertices_, f2 + 0, vertex_stride_bytes_)); + + const real3 A = p0 - ray_org_; + const real3 B = p1 - ray_org_; + const real3 C = p2 - ray_org_; + + const T Ax = A[ray_coeff_.kx] - ray_coeff_.Sx * A[ray_coeff_.kz]; + const T Ay = A[ray_coeff_.ky] - ray_coeff_.Sy * A[ray_coeff_.kz]; + const T Bx = B[ray_coeff_.kx] - ray_coeff_.Sx * B[ray_coeff_.kz]; + const T By = B[ray_coeff_.ky] - ray_coeff_.Sy * B[ray_coeff_.kz]; + const T Cx = C[ray_coeff_.kx] - ray_coeff_.Sx * C[ray_coeff_.kz]; + const T Cy = C[ray_coeff_.ky] - ray_coeff_.Sy * C[ray_coeff_.kz]; + + T U = Cx * By - Cy * Bx; + T V = Ax * Cy - Ay * Cx; + T W = Bx * Ay - By * Ax; + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wfloat-equal" +#endif + + // Fall back to test against edges using double precision. + if (U == static_cast(0.0) || V == static_cast(0.0) || W == static_cast(0.0)) { + double CxBy = static_cast(Cx) * static_cast(By); + double CyBx = static_cast(Cy) * static_cast(Bx); + U = static_cast(CxBy - CyBx); + + double AxCy = static_cast(Ax) * static_cast(Cy); + double AyCx = static_cast(Ay) * static_cast(Cx); + V = static_cast(AxCy - AyCx); + + double BxAy = static_cast(Bx) * static_cast(Ay); + double ByAx = static_cast(By) * static_cast(Ax); + W = static_cast(BxAy - ByAx); + } + + if (trace_options_.cull_back_face) { + if (U < static_cast(0.0) || V < static_cast(0.0) || W < static_cast(0.0)) return false; + } else { + if ((U < static_cast(0.0) || V < static_cast(0.0) || W < static_cast(0.0)) && (U > static_cast(0.0) || V > static_cast(0.0) || W > static_cast(0.0))) { + return false; + } + } + + T det = U + V + W; + if (det == static_cast(0.0)) return false; + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + + const T Az = ray_coeff_.Sz * A[ray_coeff_.kz]; + const T Bz = ray_coeff_.Sz * B[ray_coeff_.kz]; + const T Cz = ray_coeff_.Sz * C[ray_coeff_.kz]; + const T D = U * Az + V * Bz + W * Cz; + + const T rcpDet = static_cast(1.0) / det; + T tt = D * rcpDet; + + if (tt > (*t_inout)) { + return false; + } + + if (tt < t_min_) { + return false; + } + + (*t_inout) = tt; + // Use Thomas-Mueller style barycentric coord. + // U + V + W = 1.0 and interp(p) = U * p0 + V * p1 + W * p2 + // We want interp(p) = (1 - u - v) * p0 + u * v1 + v * p2; + // => u = V, v = W. + u_ = V * rcpDet; + v_ = W * rcpDet; + + return true; + } + + /// Returns the nearest hit distance. + T GetT() const { return t_; } + + /// Update is called when initializing intesection and nearest hit is found. + void Update(T t, unsigned int prim_idx) const { + t_ = t; + prim_id_ = prim_idx; + } + + /// Prepare BVH traversal(e.g. compute inverse ray direction) + /// This function is called only once in BVH traversal. + void PrepareTraversal(const Ray &ray, + const BVHTraceOptions &trace_options) const { + ray_org_[0] = ray.org[0]; + ray_org_[1] = ray.org[1]; + ray_org_[2] = ray.org[2]; + + // Calculate dimension where the ray direction is maximal. + ray_coeff_.kz = 0; + T absDir = std::fabs(ray.dir[0]); + if (absDir < std::fabs(ray.dir[1])) { + ray_coeff_.kz = 1; + absDir = std::fabs(ray.dir[1]); + } + if (absDir < std::fabs(ray.dir[2])) { + ray_coeff_.kz = 2; + absDir = std::fabs(ray.dir[2]); + } + + ray_coeff_.kx = ray_coeff_.kz + 1; + if (ray_coeff_.kx == 3) ray_coeff_.kx = 0; + ray_coeff_.ky = ray_coeff_.kx + 1; + if (ray_coeff_.ky == 3) ray_coeff_.ky = 0; + + // Swap kx and ky dimention to preserve widing direction of triangles. + if (ray.dir[ray_coeff_.kz] < 0.0f) std::swap(ray_coeff_.kx, ray_coeff_.ky); + + // Claculate shear constants. + ray_coeff_.Sx = ray.dir[ray_coeff_.kx] / ray.dir[ray_coeff_.kz]; + ray_coeff_.Sy = ray.dir[ray_coeff_.ky] / ray.dir[ray_coeff_.kz]; + ray_coeff_.Sz = 1.0f / ray.dir[ray_coeff_.kz]; + + trace_options_ = trace_options; + + t_min_ = ray.min_t; + + u_ = 0.0f; + v_ = 0.0f; + } + + /// Post BVH traversal stuff. + /// Fill `isect` if there is a hit. + void PostTraversal(const Ray &ray, bool hit, H *isect) const { + if (hit && isect) { + (*isect).t = t_; + (*isect).u = u_; + (*isect).v = v_; + (*isect).prim_id = prim_id_; + } + (void)ray; + } + + private: + const T *vertices_; + const unsigned int *faces_; + const size_t vertex_stride_bytes_; + + mutable real3 ray_org_; + mutable RayCoeff ray_coeff_; + mutable BVHTraceOptions trace_options_; + mutable T t_min_; + + mutable T t_; + mutable T u_; + mutable T v_; + mutable unsigned int prim_id_; + int _pad_; +}; + +// +// Robust BVH Ray Traversal : http://jcgt.org/published/0002/02/02/paper.pdf +// + +// NaN-safe min and max function. +template +const T &safemin(const T &a, const T &b) { + return (a < b) ? a : b; +} +template +const T &safemax(const T &a, const T &b) { + return (a > b) ? a : b; +} + +// +// SAH functions +// +struct BinBuffer { + explicit BinBuffer(unsigned int size) { + bin_size = size; + bin.resize(2 * 3 * size); + clear(); + } + + void clear() { memset(&bin[0], 0, sizeof(size_t) * 2 * 3 * bin_size); } + + std::vector bin; // (min, max) * xyz * binsize + unsigned int bin_size; + unsigned int pad0; +}; + +template +inline T CalculateSurfaceArea(const real3 &min, const real3 &max) { + real3 box = max - min; + return static_cast(2.0) * + (box[0] * box[1] + box[1] * box[2] + box[2] * box[0]); +} + +template +inline void GetBoundingBoxOfTriangle(real3 *bmin, real3 *bmax, + const T *vertices, + const unsigned int *faces, + unsigned int index) { + unsigned int f0 = faces[3 * index + 0]; + unsigned int f1 = faces[3 * index + 1]; + unsigned int f2 = faces[3 * index + 2]; + + real3 p[3]; + + p[0] = real3(&vertices[3 * f0]); + p[1] = real3(&vertices[3 * f1]); + p[2] = real3(&vertices[3 * f2]); + + (*bmin) = p[0]; + (*bmax) = p[0]; + + for (int i = 1; i < 3; i++) { + (*bmin)[0] = std::min((*bmin)[0], p[i][0]); + (*bmin)[1] = std::min((*bmin)[1], p[i][1]); + (*bmin)[2] = std::min((*bmin)[2], p[i][2]); + + (*bmax)[0] = std::max((*bmax)[0], p[i][0]); + (*bmax)[1] = std::max((*bmax)[1], p[i][1]); + (*bmax)[2] = std::max((*bmax)[2], p[i][2]); + } +} + +template +inline void ContributeBinBuffer(BinBuffer *bins, // [out] + const real3 &scene_min, + const real3 &scene_max, + unsigned int *indices, unsigned int left_idx, + unsigned int right_idx, const P &p) { + T bin_size = static_cast(bins->bin_size); + + // Calculate extent + real3 scene_size, scene_inv_size; + scene_size = scene_max - scene_min; + for (int i = 0; i < 3; ++i) { + assert(scene_size[i] >= static_cast(0.0)); + + if (scene_size[i] > static_cast(0.0)) { + scene_inv_size[i] = bin_size / scene_size[i]; + } else { + scene_inv_size[i] = static_cast(0.0); + } + } + + // Clear bin data + std::fill(bins->bin.begin(), bins->bin.end(), 0); + // memset(&bins->bin[0], 0, sizeof(2 * 3 * bins->bin_size)); + + size_t idx_bmin[3]; + size_t idx_bmax[3]; + + for (size_t i = left_idx; i < right_idx; i++) { + // + // Quantize the position into [0, BIN_SIZE) + // + // q[i] = (int)(p[i] - scene_bmin) / scene_size + // + real3 bmin; + real3 bmax; + + p.BoundingBox(&bmin, &bmax, indices[i]); + // GetBoundingBoxOfTriangle(&bmin, &bmax, vertices, faces, indices[i]); + + real3 quantized_bmin = (bmin - scene_min) * scene_inv_size; + real3 quantized_bmax = (bmax - scene_min) * scene_inv_size; + + // idx is now in [0, BIN_SIZE) + for (int j = 0; j < 3; ++j) { + int q0 = static_cast(quantized_bmin[j]); + if (q0 < 0) q0 = 0; + int q1 = static_cast(quantized_bmax[j]); + if (q1 < 0) q1 = 0; + + idx_bmin[j] = static_cast(q0); + idx_bmax[j] = static_cast(q1); + + if (idx_bmin[j] >= bin_size) + idx_bmin[j] = static_cast(bin_size) - 1; + if (idx_bmax[j] >= bin_size) + idx_bmax[j] = static_cast(bin_size) - 1; + + assert(idx_bmin[j] < bin_size); + assert(idx_bmax[j] < bin_size); + + // Increment bin counter + bins->bin[0 * (bins->bin_size * 3) + + static_cast(j) * bins->bin_size + idx_bmin[j]] += 1; + bins->bin[1 * (bins->bin_size * 3) + + static_cast(j) * bins->bin_size + idx_bmax[j]] += 1; + } + } +} + +template +inline T SAH(size_t ns1, T leftArea, size_t ns2, T rightArea, T invS, T Taabb, + T Ttri) { + T sah; + + sah = static_cast(2.0) * Taabb + + (leftArea * invS) * static_cast(ns1) * Ttri + + (rightArea * invS) * static_cast(ns2) * Ttri; + + return sah; +} + +template +inline bool FindCutFromBinBuffer(T *cut_pos, // [out] xyz + int *minCostAxis, // [out] + const BinBuffer *bins, const real3 &bmin, + const real3 &bmax, size_t num_primitives, + T costTaabb) { // should be in [0.0, 1.0] + const T kEPS = std::numeric_limits::epsilon(); // * epsScale; + + size_t left, right; + real3 bsize, bstep; + real3 bminLeft, bmaxLeft; + real3 bminRight, bmaxRight; + T saLeft, saRight, saTotal; + T pos; + T minCost[3]; + + T costTtri = static_cast(1.0) - costTaabb; + + (*minCostAxis) = 0; + + bsize = bmax - bmin; + bstep = bsize * (static_cast(1.0) / bins->bin_size); + saTotal = CalculateSurfaceArea(bmin, bmax); + + T invSaTotal = static_cast(0.0); + if (saTotal > kEPS) { + invSaTotal = static_cast(1.0) / saTotal; + } + + for (int j = 0; j < 3; ++j) { + // + // Compute SAH cost for the right side of each cell of the bbox. + // Exclude both extreme side of the bbox. + // + // i: 0 1 2 3 + // +----+----+----+----+----+ + // | | | | | | + // +----+----+----+----+----+ + // + + T minCostPos = bmin[j] + static_cast(1.0) * bstep[j]; + minCost[j] = std::numeric_limits::max(); + + left = 0; + right = num_primitives; + bminLeft = bminRight = bmin; + bmaxLeft = bmaxRight = bmax; + + for (int i = 0; i < static_cast(bins->bin_size) - 1; ++i) { + left += bins->bin[0 * (3 * bins->bin_size) + + static_cast(j) * bins->bin_size + + static_cast(i)]; + right -= bins->bin[1 * (3 * bins->bin_size) + + static_cast(j) * bins->bin_size + + static_cast(i)]; + + assert(left <= num_primitives); + assert(right <= num_primitives); + + // + // Split pos bmin + (i + 1) * (bsize / BIN_SIZE) + // +1 for i since we want a position on right side of the cell. + // + + pos = bmin[j] + (i + static_cast(1.0)) * bstep[j]; + bmaxLeft[j] = pos; + bminRight[j] = pos; + + saLeft = CalculateSurfaceArea(bminLeft, bmaxLeft); + saRight = CalculateSurfaceArea(bminRight, bmaxRight); + + T cost = + SAH(left, saLeft, right, saRight, invSaTotal, costTaabb, costTtri); + if (cost < minCost[j]) { + // + // Update the min cost + // + minCost[j] = cost; + minCostPos = pos; + // minCostAxis = j; + } + } + + cut_pos[j] = minCostPos; + } + + // cut_axis = minCostAxis; + // cut_pos = minCostPos; + + // Find min cost axis + T cost = minCost[0]; + (*minCostAxis) = 0; + if (cost > minCost[1]) { + (*minCostAxis) = 1; + cost = minCost[1]; + } + if (cost > minCost[2]) { + (*minCostAxis) = 2; + cost = minCost[2]; + } + + return true; +} + +#ifdef _OPENMP +template +void ComputeBoundingBoxOMP(real3 *bmin, real3 *bmax, + const unsigned int *indices, unsigned int left_index, + unsigned int right_index, const P &p) { + { p.BoundingBox(bmin, bmax, indices[left_index]); } + + T local_bmin[3] = {(*bmin)[0], (*bmin)[1], (*bmin)[2]}; + T local_bmax[3] = {(*bmax)[0], (*bmax)[1], (*bmax)[2]}; + + unsigned int n = right_index - left_index; + +#pragma omp parallel firstprivate(local_bmin, local_bmax) if (n > (1024 * 128)) + { +#pragma omp for + for (int i = left_index; i < right_index; i++) { // for each faces + unsigned int idx = indices[i]; + + real3 bbox_min, bbox_max; + p.BoundingBox(&bbox_min, &bbox_max, idx); + for (int k = 0; k < 3; k++) { // xyz + if ((*bmin)[k] > bbox_min[k]) (*bmin)[k] = bbox_min[k]; + if ((*bmax)[k] < bbox_max[k]) (*bmax)[k] = bbox_max[k]; + } + } + +#pragma omp critical + { + for (int k = 0; k < 3; k++) { + if (local_bmin[k] < (*bmin)[k]) { + { + if (local_bmin[k] < (*bmin)[k]) (*bmin)[k] = local_bmin[k]; + } + } + + if (local_bmax[k] > (*bmax)[k]) { + { + if (local_bmax[k] > (*bmax)[k]) (*bmax)[k] = local_bmax[k]; + } + } + } + } + } +} +#endif + +template +inline void ComputeBoundingBox(real3 *bmin, real3 *bmax, + const unsigned int *indices, + unsigned int left_index, + unsigned int right_index, const P &p) { + { + unsigned int idx = indices[left_index]; + p.BoundingBox(bmin, bmax, idx); + } + + { + for (unsigned int i = left_index + 1; i < right_index; + i++) { // for each primitives + unsigned int idx = indices[i]; + real3 bbox_min, bbox_max; + p.BoundingBox(&bbox_min, &bbox_max, idx); + for (int k = 0; k < 3; k++) { // xyz + if ((*bmin)[k] > bbox_min[k]) (*bmin)[k] = bbox_min[k]; + if ((*bmax)[k] < bbox_max[k]) (*bmax)[k] = bbox_max[k]; + } + } + } +} + +template +inline void GetBoundingBox(real3 *bmin, real3 *bmax, + const std::vector > &bboxes, + unsigned int *indices, unsigned int left_index, + unsigned int right_index) { + { + unsigned int i = left_index; + unsigned int idx = indices[i]; + (*bmin)[0] = bboxes[idx].bmin[0]; + (*bmin)[1] = bboxes[idx].bmin[1]; + (*bmin)[2] = bboxes[idx].bmin[2]; + (*bmax)[0] = bboxes[idx].bmax[0]; + (*bmax)[1] = bboxes[idx].bmax[1]; + (*bmax)[2] = bboxes[idx].bmax[2]; + } + + T local_bmin[3] = {(*bmin)[0], (*bmin)[1], (*bmin)[2]}; + T local_bmax[3] = {(*bmax)[0], (*bmax)[1], (*bmax)[2]}; + + { + for (unsigned int i = left_index; i < right_index; i++) { // for each faces + unsigned int idx = indices[i]; + + for (int k = 0; k < 3; k++) { // xyz + T minval = bboxes[idx].bmin[k]; + T maxval = bboxes[idx].bmax[k]; + if (local_bmin[k] > minval) local_bmin[k] = minval; + if (local_bmax[k] < maxval) local_bmax[k] = maxval; + } + } + + for (int k = 0; k < 3; k++) { + (*bmin)[k] = local_bmin[k]; + (*bmax)[k] = local_bmax[k]; + } + } +} + +// +// -- +// + +#if NANORT_ENABLE_PARALLEL_BUILD +template +template +unsigned int BVHAccel::BuildShallowTree(std::vector > *out_nodes, + unsigned int left_idx, + unsigned int right_idx, + unsigned int depth, + unsigned int max_shallow_depth, + const P &p, const Pred &pred) { + assert(left_idx <= right_idx); + + unsigned int offset = static_cast(out_nodes->size()); + + if (stats_.max_tree_depth < depth) { + stats_.max_tree_depth = depth; + } + + real3 bmin, bmax; + ComputeBoundingBox(&bmin, &bmax, &indices_.at(0), left_idx, right_idx, p); + + unsigned int n = right_idx - left_idx; + if ((n <= options_.min_leaf_primitives) || + (depth >= options_.max_tree_depth)) { + // Create leaf node. + BVHNode leaf; + + leaf.bmin[0] = bmin[0]; + leaf.bmin[1] = bmin[1]; + leaf.bmin[2] = bmin[2]; + + leaf.bmax[0] = bmax[0]; + leaf.bmax[1] = bmax[1]; + leaf.bmax[2] = bmax[2]; + + assert(left_idx < std::numeric_limits::max()); + + leaf.flag = 1; // leaf + leaf.data[0] = n; + leaf.data[1] = left_idx; + + out_nodes->push_back(leaf); // atomic update + + stats_.num_leaf_nodes++; + + return offset; + } + + // + // Create branch node. + // + if (depth >= max_shallow_depth) { + // Delay to build tree + ShallowNodeInfo info; + info.left_idx = left_idx; + info.right_idx = right_idx; + info.offset = offset; + shallow_node_infos_.push_back(info); + + // Add dummy node. + BVHNode node; + node.axis = -1; + node.flag = -1; + out_nodes->push_back(node); + + return offset; + + } else { + // + // Compute SAH and find best split axis and position + // + int min_cut_axis = 0; + T cut_pos[3] = {0.0, 0.0, 0.0}; + + BinBuffer bins(options_.bin_size); + ContributeBinBuffer(&bins, bmin, bmax, &indices_.at(0), left_idx, right_idx, + p); + FindCutFromBinBuffer(cut_pos, &min_cut_axis, &bins, bmin, bmax, n, + options_.cost_t_aabb); + + // Try all 3 axis until good cut position avaiable. + unsigned int mid_idx = left_idx; + int cut_axis = min_cut_axis; + for (int axis_try = 0; axis_try < 3; axis_try++) { + unsigned int *begin = &indices_[left_idx]; + unsigned int *end = + &indices_[right_idx - 1] + 1; // mimics end() iterator. + unsigned int *mid = 0; + + // try min_cut_axis first. + cut_axis = (min_cut_axis + axis_try) % 3; + + // @fixme { We want some thing like: std::partition(begin, end, + // pred(cut_axis, cut_pos[cut_axis])); } + pred.Set(cut_axis, cut_pos[cut_axis]); + // + // Split at (cut_axis, cut_pos) + // indices_ will be modified. + // + mid = std::partition(begin, end, pred); + + mid_idx = left_idx + static_cast((mid - begin)); + if ((mid_idx == left_idx) || (mid_idx == right_idx)) { + // Can't split well. + // Switch to object median(which may create unoptimized tree, but + // stable) + mid_idx = left_idx + (n >> 1); + + // Try another axis if there's axis to try. + + } else { + // Found good cut. exit loop. + break; + } + } + + BVHNode node; + node.axis = cut_axis; + node.flag = 0; // 0 = branch + + out_nodes->push_back(node); + + unsigned int left_child_index = 0; + unsigned int right_child_index = 0; + + left_child_index = BuildShallowTree(out_nodes, left_idx, mid_idx, depth + 1, + max_shallow_depth, p, pred); + + right_child_index = BuildShallowTree(out_nodes, mid_idx, right_idx, + depth + 1, max_shallow_depth, p, pred); + + (*out_nodes)[offset].data[0] = left_child_index; + (*out_nodes)[offset].data[1] = right_child_index; + + (*out_nodes)[offset].bmin[0] = bmin[0]; + (*out_nodes)[offset].bmin[1] = bmin[1]; + (*out_nodes)[offset].bmin[2] = bmin[2]; + + (*out_nodes)[offset].bmax[0] = bmax[0]; + (*out_nodes)[offset].bmax[1] = bmax[1]; + (*out_nodes)[offset].bmax[2] = bmax[2]; + } + + stats_.num_branch_nodes++; + + return offset; +} +#endif + +template +template +unsigned int BVHAccel::BuildTree(BVHBuildStatistics *out_stat, + std::vector > *out_nodes, + unsigned int left_idx, + unsigned int right_idx, unsigned int depth, + const P &p, const Pred &pred) { + assert(left_idx <= right_idx); + + unsigned int offset = static_cast(out_nodes->size()); + + if (out_stat->max_tree_depth < depth) { + out_stat->max_tree_depth = depth; + } + + real3 bmin, bmax; + if (!bboxes_.empty()) { + GetBoundingBox(&bmin, &bmax, bboxes_, &indices_.at(0), left_idx, right_idx); + } else { + ComputeBoundingBox(&bmin, &bmax, &indices_.at(0), left_idx, right_idx, p); + } + + unsigned int n = right_idx - left_idx; + if ((n <= options_.min_leaf_primitives) || + (depth >= options_.max_tree_depth)) { + // Create leaf node. + BVHNode leaf; + + leaf.bmin[0] = bmin[0]; + leaf.bmin[1] = bmin[1]; + leaf.bmin[2] = bmin[2]; + + leaf.bmax[0] = bmax[0]; + leaf.bmax[1] = bmax[1]; + leaf.bmax[2] = bmax[2]; + + assert(left_idx < std::numeric_limits::max()); + + leaf.flag = 1; // leaf + leaf.data[0] = n; + leaf.data[1] = left_idx; + + out_nodes->push_back(leaf); // atomic update + + out_stat->num_leaf_nodes++; + + return offset; + } + + // + // Create branch node. + // + + // + // Compute SAH and find best split axis and position + // + int min_cut_axis = 0; + T cut_pos[3] = {0.0, 0.0, 0.0}; + + BinBuffer bins(options_.bin_size); + ContributeBinBuffer(&bins, bmin, bmax, &indices_.at(0), left_idx, right_idx, + p); + FindCutFromBinBuffer(cut_pos, &min_cut_axis, &bins, bmin, bmax, n, + options_.cost_t_aabb); + + // Try all 3 axis until good cut position avaiable. + unsigned int mid_idx = left_idx; + int cut_axis = min_cut_axis; + for (int axis_try = 0; axis_try < 3; axis_try++) { + unsigned int *begin = &indices_[left_idx]; + unsigned int *end = &indices_[right_idx - 1] + 1; // mimics end() iterator. + unsigned int *mid = 0; + + // try min_cut_axis first. + cut_axis = (min_cut_axis + axis_try) % 3; + + pred.Set(cut_axis, cut_pos[cut_axis]); + + // + // Split at (cut_axis, cut_pos) + // indices_ will be modified. + // + mid = std::partition(begin, end, pred); + + mid_idx = left_idx + static_cast((mid - begin)); + if ((mid_idx == left_idx) || (mid_idx == right_idx)) { + // Can't split well. + // Switch to object median(which may create unoptimized tree, but + // stable) + mid_idx = left_idx + (n >> 1); + + // Try another axis to find better cut. + + } else { + // Found good cut. exit loop. + break; + } + } + + BVHNode node; + node.axis = cut_axis; + node.flag = 0; // 0 = branch + + out_nodes->push_back(node); + + unsigned int left_child_index = 0; + unsigned int right_child_index = 0; + + left_child_index = + BuildTree(out_stat, out_nodes, left_idx, mid_idx, depth + 1, p, pred); + + right_child_index = + BuildTree(out_stat, out_nodes, mid_idx, right_idx, depth + 1, p, pred); + + { + (*out_nodes)[offset].data[0] = left_child_index; + (*out_nodes)[offset].data[1] = right_child_index; + + (*out_nodes)[offset].bmin[0] = bmin[0]; + (*out_nodes)[offset].bmin[1] = bmin[1]; + (*out_nodes)[offset].bmin[2] = bmin[2]; + + (*out_nodes)[offset].bmax[0] = bmax[0]; + (*out_nodes)[offset].bmax[1] = bmax[1]; + (*out_nodes)[offset].bmax[2] = bmax[2]; + } + + out_stat->num_branch_nodes++; + + return offset; +} + +template +template +bool BVHAccel::Build(unsigned int num_primitives, const P &p, + const Pred &pred, const BVHBuildOptions &options) { + options_ = options; + stats_ = BVHBuildStatistics(); + + nodes_.clear(); + bboxes_.clear(); + + assert(options_.bin_size > 1); + + if (num_primitives == 0) { + return false; + } + + unsigned int n = num_primitives; + + // + // 1. Create triangle indices(this will be permutated in BuildTree) + // + indices_.resize(n); + +#ifdef _OPENMP +#pragma omp parallel for +#endif + for (int i = 0; i < static_cast(n); i++) { + indices_[static_cast(i)] = static_cast(i); + } + + // + // 2. Compute bounding box(optional). + // + real3 bmin, bmax; + if (options.cache_bbox) { + bmin[0] = bmin[1] = bmin[2] = std::numeric_limits::max(); + bmax[0] = bmax[1] = bmax[2] = -std::numeric_limits::max(); + + bboxes_.resize(n); + for (size_t i = 0; i < n; i++) { // for each primitived + unsigned int idx = indices_[i]; + + BBox bbox; + p.BoundingBox(&(bbox.bmin), &(bbox.bmax), static_cast(i)); + bboxes_[idx] = bbox; + + for (int k = 0; k < 3; k++) { // xyz + if (bmin[k] > bbox.bmin[k]) { + bmin[k] = bbox.bmin[k]; + } + if (bmax[k] < bbox.bmax[k]) { + bmax[k] = bbox.bmax[k]; + } + } + } + + } else { +#ifdef _OPENMP + ComputeBoundingBoxOMP(&bmin, &bmax, &indices_.at(0), 0, n, p); +#else + ComputeBoundingBox(&bmin, &bmax, &indices_.at(0), 0, n, p); +#endif + } + +// +// 3. Build tree +// +#ifdef _OPENMP +#if NANORT_ENABLE_PARALLEL_BUILD + + // Do parallel build for enoughly large dataset. + if (n > options.min_primitives_for_parallel_build) { + BuildShallowTree(&nodes_, 0, n, /* root depth */ 0, options.shallow_depth, + p, pred); // [0, n) + + assert(shallow_node_infos_.size() > 0); + + // Build deeper tree in parallel + std::vector > > local_nodes( + shallow_node_infos_.size()); + std::vector local_stats(shallow_node_infos_.size()); + +#pragma omp parallel for + for (int i = 0; i < static_cast(shallow_node_infos_.size()); i++) { + unsigned int left_idx = shallow_node_infos_[i].left_idx; + unsigned int right_idx = shallow_node_infos_[i].right_idx; + BuildTree(&(local_stats[i]), &(local_nodes[i]), left_idx, right_idx, + options.shallow_depth, p, pred); + } + + // Join local nodes + for (int i = 0; i < static_cast(local_nodes.size()); i++) { + assert(!local_nodes[i].empty()); + size_t offset = nodes_.size(); + + // Add offset to child index(for branch node). + for (size_t j = 0; j < local_nodes[i].size(); j++) { + if (local_nodes[i][j].flag == 0) { // branch + local_nodes[i][j].data[0] += offset - 1; + local_nodes[i][j].data[1] += offset - 1; + } + } + + // replace + nodes_[shallow_node_infos_[i].offset] = local_nodes[i][0]; + + // Skip root element of the local node. + nodes_.insert(nodes_.end(), local_nodes[i].begin() + 1, + local_nodes[i].end()); + } + + // Join statistics + for (int i = 0; i < static_cast(local_nodes.size()); i++) { + stats_.max_tree_depth = + std::max(stats_.max_tree_depth, local_stats[i].max_tree_depth); + stats_.num_leaf_nodes += local_stats[i].num_leaf_nodes; + stats_.num_branch_nodes += local_stats[i].num_branch_nodes; + } + + } else { + BuildTree(&stats_, &nodes_, 0, n, + /* root depth */ 0, p, pred); // [0, n) + } + +#else // !NANORT_ENABLE_PARALLEL_BUILD + { + BuildTree(&stats_, &nodes_, 0, n, + /* root depth */ 0, p, pred); // [0, n) + } +#endif +#else // !_OPENMP + { + BuildTree(&stats_, &nodes_, 0, n, + /* root depth */ 0, p, pred); // [0, n) + } +#endif + + return true; +} + +template +void BVHAccel::Debug() { + for (size_t i = 0; i < indices_.size(); i++) { + printf("index[%d] = %d\n", int(i), int(indices_[i])); + } + + for (size_t i = 0; i < nodes_.size(); i++) { + printf("node[%d] : bmin %f, %f, %f, bmax %f, %f, %f\n", int(i), + nodes_[i].bmin[0], nodes_[i].bmin[1], nodes_[i].bmin[1], + nodes_[i].bmax[0], nodes_[i].bmax[1], nodes_[i].bmax[1]); + } +} + +template +bool BVHAccel::Dump(const char *filename) { + FILE *fp = fopen(filename, "wb"); + if (!fp) { + // fprintf(stderr, "[BVHAccel] Cannot write a file: %s\n", filename); + return false; + } + + size_t numNodes = nodes_.size(); + assert(nodes_.size() > 0); + + size_t numIndices = indices_.size(); + + size_t r = 0; + r = fwrite(&numNodes, sizeof(size_t), 1, fp); + assert(r == 1); + + r = fwrite(&nodes_.at(0), sizeof(BVHNode), numNodes, fp); + assert(r == numNodes); + + r = fwrite(&numIndices, sizeof(size_t), 1, fp); + assert(r == 1); + + r = fwrite(&indices_.at(0), sizeof(unsigned int), numIndices, fp); + assert(r == numIndices); + + fclose(fp); + + return true; +} + +template +bool BVHAccel::Load(const char *filename) { + FILE *fp = fopen(filename, "rb"); + if (!fp) { + // fprintf(stderr, "Cannot open file: %s\n", filename); + return false; + } + + size_t numNodes; + size_t numIndices; + + size_t r = 0; + r = fread(&numNodes, sizeof(size_t), 1, fp); + assert(r == 1); + assert(numNodes > 0); + + nodes_.resize(numNodes); + r = fread(&nodes_.at(0), sizeof(BVHNode), numNodes, fp); + assert(r == numNodes); + + r = fread(&numIndices, sizeof(size_t), 1, fp); + assert(r == 1); + + indices_.resize(numIndices); + + r = fread(&indices_.at(0), sizeof(unsigned int), numIndices, fp); + assert(r == numIndices); + + fclose(fp); + + return true; +} + +template +inline bool IntersectRayAABB(T *tminOut, // [out] + T *tmaxOut, // [out] + T min_t, T max_t, const T bmin[3], const T bmax[3], + real3 ray_org, real3 ray_inv_dir, + int ray_dir_sign[3]) { + T tmin, tmax; + + const T min_x = ray_dir_sign[0] ? bmax[0] : bmin[0]; + const T min_y = ray_dir_sign[1] ? bmax[1] : bmin[1]; + const T min_z = ray_dir_sign[2] ? bmax[2] : bmin[2]; + const T max_x = ray_dir_sign[0] ? bmin[0] : bmax[0]; + const T max_y = ray_dir_sign[1] ? bmin[1] : bmax[1]; + const T max_z = ray_dir_sign[2] ? bmin[2] : bmax[2]; + + // X + const T tmin_x = (min_x - ray_org[0]) * ray_inv_dir[0]; + // MaxMult robust BVH traversal(up to 4 ulp). + // 1.0000000000000004 for double precision. + const T tmax_x = (max_x - ray_org[0]) * ray_inv_dir[0] * 1.00000024f; + + // Y + const T tmin_y = (min_y - ray_org[1]) * ray_inv_dir[1]; + const T tmax_y = (max_y - ray_org[1]) * ray_inv_dir[1] * 1.00000024f; + + // Z + const T tmin_z = (min_z - ray_org[2]) * ray_inv_dir[2]; + const T tmax_z = (max_z - ray_org[2]) * ray_inv_dir[2] * 1.00000024f; + + tmin = safemax(tmin_z, safemax(tmin_y, safemax(tmin_x, min_t))); + tmax = safemin(tmax_z, safemin(tmax_y, safemin(tmax_x, max_t))); + + if (tmin <= tmax) { + (*tminOut) = tmin; + (*tmaxOut) = tmax; + + return true; + } + + return false; // no hit +} + +template +template +inline bool BVHAccel::TestLeafNode(const BVHNode &node, const Ray &ray, + const I &intersector) const { + bool hit = false; + + unsigned int num_primitives = node.data[0]; + unsigned int offset = node.data[1]; + + T t = intersector.GetT(); // current hit distance + + real3 ray_org; + ray_org[0] = ray.org[0]; + ray_org[1] = ray.org[1]; + ray_org[2] = ray.org[2]; + + real3 ray_dir; + ray_dir[0] = ray.dir[0]; + ray_dir[1] = ray.dir[1]; + ray_dir[2] = ray.dir[2]; + + for (unsigned int i = 0; i < num_primitives; i++) { + unsigned int prim_idx = indices_[i + offset]; + + T local_t = t; + if (intersector.Intersect(&local_t, prim_idx)) { + // Update isect state + t = local_t; + + intersector.Update(t, prim_idx); + hit = true; + } + } + + return hit; +} + +#if 0 // TODO(LTE): Implement +template template +bool BVHAccel::MultiHitTestLeafNode( + std::priority_queue, Comp> *isect_pq, + int max_intersections, + const BVHNode &node, + const Ray &ray, + const I &intersector) const { + bool hit = false; + + unsigned int num_primitives = node.data[0]; + unsigned int offset = node.data[1]; + + T t = std::numeric_limits::max(); + if (isect_pq->size() >= static_cast(max_intersections)) { + t = isect_pq->top().t; // current furthest hit distance + } + + real3 ray_org; + ray_org[0] = ray.org[0]; + ray_org[1] = ray.org[1]; + ray_org[2] = ray.org[2]; + + real3 ray_dir; + ray_dir[0] = ray.dir[0]; + ray_dir[1] = ray.dir[1]; + ray_dir[2] = ray.dir[2]; + + for (unsigned int i = 0; i < num_primitives; i++) { + unsigned int prim_idx = indices_[i + offset]; + + T local_t = t, u = 0.0f, v = 0.0f; + if (intersector.Intersect(&local_t, &u, &v, prim_idx)) { + // Update isect state + if ((local_t > ray.min_t)) { + if (isect_pq->size() < static_cast(max_intersections)) { + H isect; + t = local_t; + isect.t = t; + isect.u = u; + isect.v = v; + isect.prim_id = prim_idx; + isect_pq->push(isect); + + // Update t to furthest distance. + t = ray.max_t; + + hit = true; + } else { + if (local_t < isect_pq->top().t) { + // delete furthest intersection and add new intersection. + isect_pq->pop(); + + H hit; + hit.t = local_t; + hit.u = u; + hit.v = v; + hit.prim_id = prim_idx; + isect_pq->push(hit); + + // Update furthest hit distance + t = isect_pq->top().t; + + hit = true; + } + } + } + } + } + + return hit; +} +#endif + +template +template +bool BVHAccel::Traverse(const Ray &ray, const I &intersector, H *isect, + const BVHTraceOptions &options) const { + const int kMaxStackDepth = 512; + + T hit_t = ray.max_t; + + int node_stack_index = 0; + unsigned int node_stack[512]; + node_stack[0] = 0; + + // Init isect info as no hit + intersector.Update(hit_t, static_cast(-1)); + + intersector.PrepareTraversal(ray, options); + + int dir_sign[3]; + dir_sign[0] = ray.dir[0] < 0.0f ? 1 : 0; + dir_sign[1] = ray.dir[1] < 0.0f ? 1 : 0; + dir_sign[2] = ray.dir[2] < 0.0f ? 1 : 0; + + // @fixme { Check edge case; i.e., 1/0 } + real3 ray_inv_dir; + ray_inv_dir[0] = 1.0f / (ray.dir[0] + 1.0e-12f); + ray_inv_dir[1] = 1.0f / (ray.dir[1] + 1.0e-12f); + ray_inv_dir[2] = 1.0f / (ray.dir[2] + 1.0e-12f); + + real3 ray_org; + ray_org[0] = ray.org[0]; + ray_org[1] = ray.org[1]; + ray_org[2] = ray.org[2]; + + T min_t = std::numeric_limits::max(); + T max_t = -std::numeric_limits::max(); + + while (node_stack_index >= 0) { + unsigned int index = node_stack[node_stack_index]; + const BVHNode &node = nodes_[index]; + + node_stack_index--; + + bool hit = IntersectRayAABB(&min_t, &max_t, ray.min_t, hit_t, node.bmin, + node.bmax, ray_org, ray_inv_dir, dir_sign); + + if (node.flag == 0) { // branch node + if (hit) { + int order_near = dir_sign[node.axis]; + int order_far = 1 - order_near; + + // Traverse near first. + node_stack[++node_stack_index] = node.data[order_far]; + node_stack[++node_stack_index] = node.data[order_near]; + } + } else { // leaf node + if (hit) { + if (TestLeafNode(node, ray, intersector)) { + hit_t = intersector.GetT(); + } + } + } + } + + assert(node_stack_index < kMaxStackDepth); + + bool hit = (intersector.GetT() < ray.max_t); + intersector.PostTraversal(ray, hit, isect); + + return hit; +} + +template +template +inline bool BVHAccel::TestLeafNodeIntersections( + const BVHNode &node, const Ray &ray, const int max_intersections, + const I &intersector, + std::priority_queue, std::vector >, + NodeHitComparator > *isect_pq) const { + bool hit = false; + + unsigned int num_primitives = node.data[0]; + unsigned int offset = node.data[1]; + + real3 ray_org; + ray_org[0] = ray.org[0]; + ray_org[1] = ray.org[1]; + ray_org[2] = ray.org[2]; + + real3 ray_dir; + ray_dir[0] = ray.dir[0]; + ray_dir[1] = ray.dir[1]; + ray_dir[2] = ray.dir[2]; + + intersector.PrepareTraversal(ray); + + for (unsigned int i = 0; i < num_primitives; i++) { + unsigned int prim_idx = indices_[i + offset]; + + T min_t, max_t; + if (intersector.Intersect(&min_t, &max_t, prim_idx)) { + // Always add to isect lists. + NodeHit isect; + isect.t_min = min_t; + isect.t_max = max_t; + isect.node_id = prim_idx; + + if (isect_pq->size() < static_cast(max_intersections)) { + isect_pq->push(isect); + + } else { + if (min_t < isect_pq->top().t_min) { + // delete the furthest intersection and add a new intersection. + isect_pq->pop(); + + isect_pq->push(isect); + } + } + } + } + + return hit; +} + +template +template +bool BVHAccel::ListNodeIntersections( + const Ray &ray, int max_intersections, const I &intersector, + StackVector, 128> *hits) const { + const int kMaxStackDepth = 512; + + T hit_t = ray.max_t; + + int node_stack_index = 0; + unsigned int node_stack[512]; + node_stack[0] = 0; + + // Stores furthest intersection at top + std::priority_queue, std::vector >, + NodeHitComparator > + isect_pq; + + (*hits)->clear(); + + int dir_sign[3]; + dir_sign[0] = + ray.dir[0] < static_cast(0.0) ? 1 : 0; + dir_sign[1] = + ray.dir[1] < static_cast(0.0) ? 1 : 0; + dir_sign[2] = + ray.dir[2] < static_cast(0.0) ? 1 : 0; + + // @fixme { Check edge case; i.e., 1/0 } + real3 ray_inv_dir; + ray_inv_dir[0] = static_cast(1.0) / ray.dir[0]; + ray_inv_dir[1] = static_cast(1.0) / ray.dir[1]; + ray_inv_dir[2] = static_cast(1.0) / ray.dir[2]; + + real3 ray_org; + ray_org[0] = ray.org[0]; + ray_org[1] = ray.org[1]; + ray_org[2] = ray.org[2]; + + T min_t, max_t; + while (node_stack_index >= 0) { + unsigned int index = node_stack[node_stack_index]; + const BVHNode &node = nodes_[static_cast(index)]; + + node_stack_index--; + + bool hit = IntersectRayAABB(&min_t, &max_t, ray.min_t, hit_t, node.bmin, + node.bmax, ray_org, ray_inv_dir, dir_sign); + + if (node.flag == 0) { // branch node + if (hit) { + int order_near = dir_sign[node.axis]; + int order_far = 1 - order_near; + + // Traverse near first. + node_stack[++node_stack_index] = node.data[order_far]; + node_stack[++node_stack_index] = node.data[order_near]; + } + + } else { // leaf node + if (hit) { + TestLeafNodeIntersections(node, ray, max_intersections, intersector, + &isect_pq); + } + } + } + + assert(node_stack_index < kMaxStackDepth); + (void)kMaxStackDepth; + + if (!isect_pq.empty()) { + // Store intesection in reverse order(make it frontmost order) + size_t n = isect_pq.size(); + (*hits)->resize(n); + for (size_t i = 0; i < n; i++) { + const NodeHit &isect = isect_pq.top(); + (*hits)[n - i - 1] = isect; + isect_pq.pop(); + } + + return true; + } + + return false; +} + +#if 0 // TODO(LTE): Implement +template template +bool BVHAccel::MultiHitTraverse(const Ray &ray, + int max_intersections, + const I &intersector, + StackVector *hits, + const BVHTraceOptions& options) const { + const int kMaxStackDepth = 512; + + T hit_t = ray.max_t; + + int node_stack_index = 0; + unsigned int node_stack[512]; + node_stack[0] = 0; + + // Stores furthest intersection at top + std::priority_queue, Comp> isect_pq; + + (*hits)->clear(); + + // Init isect info as no hit + intersector.Update(hit_t, static_cast(-1)); + + intersector.PrepareTraversal(ray, options); + + int dir_sign[3]; + dir_sign[0] = ray.dir[0] < static_cast(0.0) ? static_cast(1) : static_cast(0); + dir_sign[1] = ray.dir[1] < static_cast(0.0) ? static_cast(1) : static_cast(0); + dir_sign[2] = ray.dir[2] < static_cast(0.0) ? static_cast(1) : static_cast(0); + + // @fixme { Check edge case; i.e., 1/0 } + real3 ray_inv_dir; + ray_inv_dir[0] = static_cast(1.0) / ray.dir[0]; + ray_inv_dir[1] = static_cast(1.0) / ray.dir[1]; + ray_inv_dir[2] = static_cast(1.0) / ray.dir[2]; + + real3 ray_org; + ray_org[0] = ray.org[0]; + ray_org[1] = ray.org[1]; + ray_org[2] = ray.org[2]; + + T min_t, max_t; + while (node_stack_index >= 0) { + unsigned int index = node_stack[node_stack_index]; + const BVHNode &node = nodes_[static_cast(index)]; + + node_stack_index--; + + bool hit = IntersectRayAABB(&min_t, &max_t, ray.min_t, hit_t, node.bmin, + node.bmax, ray_org, ray_inv_dir, dir_sign); + + if (node.flag == 0) { // branch node + if (hit) { + int order_near = dir_sign[node.axis]; + int order_far = 1 - order_near; + + // Traverse near first. + node_stack[++node_stack_index] = node.data[order_far]; + node_stack[++node_stack_index] = node.data[order_near]; + } + + } else { // leaf node + if (hit) { + if (MultiHitTestLeafNode(&isect_pq, max_intersections, node, ray, intersector)) { + // Only update `hit_t` when queue is full. + if (isect_pq.size() >= static_cast(max_intersections)) { + hit_t = isect_pq.top().t; + } + } + } + } + } + + assert(node_stack_index < kMaxStackDepth); + (void)kMaxStackDepth; + + if (!isect_pq.empty()) { + // Store intesection in reverse order(make it frontmost order) + size_t n = isect_pq.size(); + (*hits)->resize(n); + for (size_t i = 0; i < n; i++) { + const H &isect = isect_pq.top(); + (*hits)[n - i - 1] = isect; + isect_pq.pop(); + } + + return true; + } + + return false; +} +#endif + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +} // namespace nanort + +#endif // NANORT_H_ diff --git a/3rdparty/tinygltf/examples/raytrace/nanosg.h b/3rdparty/tinygltf/examples/raytrace/nanosg.h new file mode 100644 index 0000000..7b47c3b --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/nanosg.h @@ -0,0 +1,882 @@ +/* +The MIT License (MIT) + +Copyright (c) 2017 Light Transport Entertainment, Inc. + +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 NANOSG_H_ +#define NANOSG_H_ + +#ifdef _WIN32 +#ifndef NOMINMAX +#define NOMINMAX +#endif +#endif + +#include +#include +#include + +#include "nanort.h" + +namespace nanosg { + +template +class PrimitiveInterface; + +template +class PrimitiveInterface { + public: + void print() { static_cast(this)->print(); } +}; + +class SpherePrimitive : PrimitiveInterface { + public: + void print() { std::cout << "Sphere" << std::endl; } +}; + +// 4x4 matrix +template +class Matrix { + public: + Matrix(); + ~Matrix(); + + static void Print(const T m[4][4]) { + for (int i = 0; i < 4; i++) { + printf("m[%d] = %f, %f, %f, %f\n", i, m[i][0], m[i][1], m[i][2], m[i][3]); + } + } + + static void Identity(T m[4][4]) { + m[0][0] = static_cast(1); + m[0][1] = static_cast(0); + m[0][2] = static_cast(0); + m[0][3] = static_cast(0); + m[1][0] = static_cast(0); + m[1][1] = static_cast(1); + m[1][2] = static_cast(0); + m[1][3] = static_cast(0); + m[2][0] = static_cast(0); + m[2][1] = static_cast(0); + m[2][2] = static_cast(1); + m[2][3] = static_cast(0); + m[3][0] = static_cast(0); + m[3][1] = static_cast(0); + m[3][2] = static_cast(0); + m[3][3] = static_cast(1); + } + + static void Copy(T dst[4][4], const T src[4][4]) { + memcpy(dst, src, sizeof(T) * 16); + } + + static void Inverse(T m[4][4]) { + /* + * codes from intel web + * cramer's rule version + */ + int i, j; + T tmp[12]; /* tmp array for pairs */ + T tsrc[16]; /* array of transpose source matrix */ + T det; /* determinant */ + + /* transpose matrix */ + for (i = 0; i < 4; i++) { + tsrc[i] = m[i][0]; + tsrc[i + 4] = m[i][1]; + tsrc[i + 8] = m[i][2]; + tsrc[i + 12] = m[i][3]; + } + + /* calculate pair for first 8 elements(cofactors) */ + tmp[0] = tsrc[10] * tsrc[15]; + tmp[1] = tsrc[11] * tsrc[14]; + tmp[2] = tsrc[9] * tsrc[15]; + tmp[3] = tsrc[11] * tsrc[13]; + tmp[4] = tsrc[9] * tsrc[14]; + tmp[5] = tsrc[10] * tsrc[13]; + tmp[6] = tsrc[8] * tsrc[15]; + tmp[7] = tsrc[11] * tsrc[12]; + tmp[8] = tsrc[8] * tsrc[14]; + tmp[9] = tsrc[10] * tsrc[12]; + tmp[10] = tsrc[8] * tsrc[13]; + tmp[11] = tsrc[9] * tsrc[12]; + + /* calculate first 8 elements(cofactors) */ + m[0][0] = tmp[0] * tsrc[5] + tmp[3] * tsrc[6] + tmp[4] * tsrc[7]; + m[0][0] -= tmp[1] * tsrc[5] + tmp[2] * tsrc[6] + tmp[5] * tsrc[7]; + m[0][1] = tmp[1] * tsrc[4] + tmp[6] * tsrc[6] + tmp[9] * tsrc[7]; + m[0][1] -= tmp[0] * tsrc[4] + tmp[7] * tsrc[6] + tmp[8] * tsrc[7]; + m[0][2] = tmp[2] * tsrc[4] + tmp[7] * tsrc[5] + tmp[10] * tsrc[7]; + m[0][2] -= tmp[3] * tsrc[4] + tmp[6] * tsrc[5] + tmp[11] * tsrc[7]; + m[0][3] = tmp[5] * tsrc[4] + tmp[8] * tsrc[5] + tmp[11] * tsrc[6]; + m[0][3] -= tmp[4] * tsrc[4] + tmp[9] * tsrc[5] + tmp[10] * tsrc[6]; + m[1][0] = tmp[1] * tsrc[1] + tmp[2] * tsrc[2] + tmp[5] * tsrc[3]; + m[1][0] -= tmp[0] * tsrc[1] + tmp[3] * tsrc[2] + tmp[4] * tsrc[3]; + m[1][1] = tmp[0] * tsrc[0] + tmp[7] * tsrc[2] + tmp[8] * tsrc[3]; + m[1][1] -= tmp[1] * tsrc[0] + tmp[6] * tsrc[2] + tmp[9] * tsrc[3]; + m[1][2] = tmp[3] * tsrc[0] + tmp[6] * tsrc[1] + tmp[11] * tsrc[3]; + m[1][2] -= tmp[2] * tsrc[0] + tmp[7] * tsrc[1] + tmp[10] * tsrc[3]; + m[1][3] = tmp[4] * tsrc[0] + tmp[9] * tsrc[1] + tmp[10] * tsrc[2]; + m[1][3] -= tmp[5] * tsrc[0] + tmp[8] * tsrc[1] + tmp[11] * tsrc[2]; + + /* calculate pairs for second 8 elements(cofactors) */ + tmp[0] = tsrc[2] * tsrc[7]; + tmp[1] = tsrc[3] * tsrc[6]; + tmp[2] = tsrc[1] * tsrc[7]; + tmp[3] = tsrc[3] * tsrc[5]; + tmp[4] = tsrc[1] * tsrc[6]; + tmp[5] = tsrc[2] * tsrc[5]; + tmp[6] = tsrc[0] * tsrc[7]; + tmp[7] = tsrc[3] * tsrc[4]; + tmp[8] = tsrc[0] * tsrc[6]; + tmp[9] = tsrc[2] * tsrc[4]; + tmp[10] = tsrc[0] * tsrc[5]; + tmp[11] = tsrc[1] * tsrc[4]; + + /* calculate second 8 elements(cofactors) */ + m[2][0] = tmp[0] * tsrc[13] + tmp[3] * tsrc[14] + tmp[4] * tsrc[15]; + m[2][0] -= tmp[1] * tsrc[13] + tmp[2] * tsrc[14] + tmp[5] * tsrc[15]; + m[2][1] = tmp[1] * tsrc[12] + tmp[6] * tsrc[14] + tmp[9] * tsrc[15]; + m[2][1] -= tmp[0] * tsrc[12] + tmp[7] * tsrc[14] + tmp[8] * tsrc[15]; + m[2][2] = tmp[2] * tsrc[12] + tmp[7] * tsrc[13] + tmp[10] * tsrc[15]; + m[2][2] -= tmp[3] * tsrc[12] + tmp[6] * tsrc[13] + tmp[11] * tsrc[15]; + m[2][3] = tmp[5] * tsrc[12] + tmp[8] * tsrc[13] + tmp[11] * tsrc[14]; + m[2][3] -= tmp[4] * tsrc[12] + tmp[9] * tsrc[13] + tmp[10] * tsrc[14]; + m[3][0] = tmp[2] * tsrc[10] + tmp[5] * tsrc[11] + tmp[1] * tsrc[9]; + m[3][0] -= tmp[4] * tsrc[11] + tmp[0] * tsrc[9] + tmp[3] * tsrc[10]; + m[3][1] = tmp[8] * tsrc[11] + tmp[0] * tsrc[8] + tmp[7] * tsrc[10]; + m[3][1] -= tmp[6] * tsrc[10] + tmp[9] * tsrc[11] + tmp[1] * tsrc[8]; + m[3][2] = tmp[6] * tsrc[9] + tmp[11] * tsrc[11] + tmp[3] * tsrc[8]; + m[3][2] -= tmp[10] * tsrc[11] + tmp[2] * tsrc[8] + tmp[7] * tsrc[9]; + m[3][3] = tmp[10] * tsrc[10] + tmp[4] * tsrc[8] + tmp[9] * tsrc[9]; + m[3][3] -= tmp[8] * tsrc[9] + tmp[11] * tsrc[0] + tmp[5] * tsrc[8]; + + /* calculate determinant */ + det = tsrc[0] * m[0][0] + tsrc[1] * m[0][1] + tsrc[2] * m[0][2] + + tsrc[3] * m[0][3]; + + /* calculate matrix inverse */ + det = static_cast(1.0) / det; + + for (j = 0; j < 4; j++) { + for (i = 0; i < 4; i++) { + m[j][i] *= det; + } + } + } + + static void Transpose(T m[4][4]) { + T t[4][4]; + + // Transpose + for (int j = 0; j < 4; j++) { + for (int i = 0; i < 4; i++) { + t[j][i] = m[i][j]; + } + } + + // Copy + for (int j = 0; j < 4; j++) { + for (int i = 0; i < 4; i++) { + m[j][i] = t[j][i]; + } + } + } + + static void Mult(T dst[4][4], const T m0[4][4], const T m1[4][4]) { + for (int i = 0; i < 4; ++i) { + for (int j = 0; j < 4; ++j) { + dst[i][j] = 0; + for (int k = 0; k < 4; ++k) { + dst[i][j] += m0[k][j] * m1[i][k]; + } + } + } + } + + static void MultV(T dst[3], const T m[4][4], const T v[3]) { + T tmp[3]; + tmp[0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0]; + tmp[1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1]; + tmp[2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2]; + dst[0] = tmp[0]; + dst[1] = tmp[1]; + dst[2] = tmp[2]; + } + + static void MultV(nanort::real3 &dst, const T m[4][4], const T v[3]) { + T tmp[3]; + tmp[0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0]; + tmp[1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1]; + tmp[2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2]; + dst[0] = tmp[0]; + dst[1] = tmp[1]; + dst[2] = tmp[2]; + } +}; + +// typedef Matrix Matrixf; +// typedef Matrix Matrixd; + +template +static void XformBoundingBox(T xbmin[3], // out + T xbmax[3], // out + T bmin[3], T bmax[3], T m[4][4]) { + // create bounding vertex from (bmin, bmax) + T b[8][3]; + + b[0][0] = bmin[0]; + b[0][1] = bmin[1]; + b[0][2] = bmin[2]; + b[1][0] = bmax[0]; + b[1][1] = bmin[1]; + b[1][2] = bmin[2]; + b[2][0] = bmin[0]; + b[2][1] = bmax[1]; + b[2][2] = bmin[2]; + b[3][0] = bmax[0]; + b[3][1] = bmax[1]; + b[3][2] = bmin[2]; + + b[4][0] = bmin[0]; + b[4][1] = bmin[1]; + b[4][2] = bmax[2]; + b[5][0] = bmax[0]; + b[5][1] = bmin[1]; + b[5][2] = bmax[2]; + b[6][0] = bmin[0]; + b[6][1] = bmax[1]; + b[6][2] = bmax[2]; + b[7][0] = bmax[0]; + b[7][1] = bmax[1]; + b[7][2] = bmax[2]; + + T xb[8][3]; + for (int i = 0; i < 8; i++) { + Matrix::MultV(xb[i], m, b[i]); + } + + xbmin[0] = xb[0][0]; + xbmin[1] = xb[0][1]; + xbmin[2] = xb[0][2]; + xbmax[0] = xb[0][0]; + xbmax[1] = xb[0][1]; + xbmax[2] = xb[0][2]; + + for (int i = 1; i < 8; i++) { + xbmin[0] = std::min(xb[i][0], xbmin[0]); + xbmin[1] = std::min(xb[i][1], xbmin[1]); + xbmin[2] = std::min(xb[i][2], xbmin[2]); + + xbmax[0] = std::max(xb[i][0], xbmax[0]); + xbmax[1] = std::max(xb[i][1], xbmax[1]); + xbmax[2] = std::max(xb[i][2], xbmax[2]); + } +} + +template +struct Intersection { + // required fields. + T t; // hit distance + unsigned int prim_id; // primitive ID of the hit + float u; + float v; + + unsigned int node_id; // node ID of the hit. + nanort::real3 P; // intersection point + nanort::real3 Ns; // shading normal + nanort::real3 Ng; // geometric normal +}; + +/// +/// Renderable node +/// +template +class Node { + public: + typedef Node type; + + explicit Node(const M *mesh) : mesh_(mesh) { + xbmin_[0] = xbmin_[1] = xbmin_[2] = std::numeric_limits::max(); + xbmax_[0] = xbmax_[1] = xbmax_[2] = -std::numeric_limits::max(); + + lbmin_[0] = lbmin_[1] = lbmin_[2] = std::numeric_limits::max(); + lbmax_[0] = lbmax_[1] = lbmax_[2] = -std::numeric_limits::max(); + + Matrix::Identity(local_xform_); + Matrix::Identity(xform_); + Matrix::Identity(inv_xform_); + Matrix::Identity(inv_xform33_); + inv_xform33_[3][3] = static_cast(0.0); + Matrix::Identity(inv_transpose_xform33_); + inv_transpose_xform33_[3][3] = static_cast(0.0); + } + + ~Node() {} + + void Copy(const type &rhs) { + Matrix::Copy(local_xform_, rhs.local_xform_); + Matrix::Copy(xform_, rhs.xform_); + Matrix::Copy(inv_xform_, rhs.inv_xform_); + Matrix::Copy(inv_xform33_, rhs.inv_xform33_); + Matrix::Copy(inv_transpose_xform33_, rhs.inv_transpose_xform33_); + + lbmin_[0] = rhs.lbmin_[0]; + lbmin_[1] = rhs.lbmin_[1]; + lbmin_[2] = rhs.lbmin_[2]; + + lbmax_[0] = rhs.lbmax_[0]; + lbmax_[1] = rhs.lbmax_[1]; + lbmax_[2] = rhs.lbmax_[2]; + + xbmin_[0] = rhs.xbmin_[0]; + xbmin_[1] = rhs.xbmin_[1]; + xbmin_[2] = rhs.xbmin_[2]; + + xbmax_[0] = rhs.xbmax_[0]; + xbmax_[1] = rhs.xbmax_[1]; + xbmax_[2] = rhs.xbmax_[2]; + + mesh_ = rhs.mesh_; + name_ = rhs.name_; + + children_ = rhs.children_; + } + + Node(const type &rhs) { Copy(rhs); } + + const type &operator=(const type &rhs) { + Copy(rhs); + return (*this); + } + + void SetName(const std::string &name) { name_ = name; } + + const std::string &GetName() const { return name_; } + + /// + /// Add child node. + /// + void AddChild(const type &child) { children_.push_back(child); } + + /// + /// Get chidren + /// + const std::vector &GetChildren() const { return children_; } + + std::vector &GetChildren() { return children_; } + + /// + /// Update internal state. + /// + void Update(const T parent_xform[4][4]) { + if (!accel_.IsValid() && mesh_ && (mesh_->vertices.size() > 3) && + (mesh_->faces.size() >= 3)) { + // Assume mesh is composed of triangle faces only. + nanort::TriangleMesh triangle_mesh( + mesh_->vertices.data(), mesh_->faces.data(), mesh_->stride); + nanort::TriangleSAHPred triangle_pred( + mesh_->vertices.data(), mesh_->faces.data(), mesh_->stride); + + bool ret = + accel_.Build(static_cast(mesh_->faces.size()) / 3, + triangle_mesh, triangle_pred); + + // Update local bbox. + if (ret) { + accel_.BoundingBox(lbmin_, lbmax_); + } + } + + // xform = parent_xform x local_xform + Matrix::Mult(xform_, parent_xform, local_xform_); + + // Compute the bounding box in world coordinate. + XformBoundingBox(xbmin_, xbmax_, lbmin_, lbmax_, xform_); + + // Inverse(xform) + Matrix::Copy(inv_xform_, xform_); + Matrix::Inverse(inv_xform_); + + // Clear translation, then inverse(xform) + Matrix::Copy(inv_xform33_, xform_); + inv_xform33_[3][0] = static_cast(0.0); + inv_xform33_[3][1] = static_cast(0.0); + inv_xform33_[3][2] = static_cast(0.0); + Matrix::Inverse(inv_xform33_); + + // Inverse transpose of xform33 + Matrix::Copy(inv_transpose_xform33_, inv_xform33_); + Matrix::Transpose(inv_transpose_xform33_); + + // Update children nodes + for (size_t i = 0; i < children_.size(); i++) { + children_[i].Update(xform_); + } + } + + /// + /// Set local transformation. + /// + void SetLocalXform(const T xform[4][4]) { + memcpy(local_xform_, xform, sizeof(float) * 16); + } + + const T *GetLocalXformPtr() const { return &local_xform_[0][0]; } + + const T *GetXformPtr() const { return &xform_[0][0]; } + + const M *GetMesh() const { return mesh_; } + + const nanort::BVHAccel &GetAccel() const { return accel_; } + + inline void GetWorldBoundingBox(T bmin[3], T bmax[3]) const { + bmin[0] = xbmin_[0]; + bmin[1] = xbmin_[1]; + bmin[2] = xbmin_[2]; + + bmax[0] = xbmax_[0]; + bmax[1] = xbmax_[1]; + bmax[2] = xbmax_[2]; + } + + inline void GetLocalBoundingBox(T bmin[3], T bmax[3]) const { + bmin[0] = lbmin_[0]; + bmin[1] = lbmin_[1]; + bmin[2] = lbmin_[2]; + + bmax[0] = lbmax_[0]; + bmax[1] = lbmax_[1]; + bmax[2] = lbmax_[2]; + } + + T local_xform_[4][4]; // Node's local transformation matrix. + T xform_[4][4]; // Parent xform x local_xform. + T inv_xform_[4][4]; // inverse(xform). world -> local + T inv_xform33_[4][4]; // inverse(xform0 with upper-left 3x3 elemets only(for + // transforming direction vector) + T inv_transpose_xform33_[4][4]; // inverse(transpose(xform)) with upper-left + // 3x3 elements only(for transforming normal + // vector) + + private: + // bounding box(local space) + T lbmin_[3]; + T lbmax_[3]; + + // bounding box after xform(world space) + T xbmin_[3]; + T xbmax_[3]; + + nanort::BVHAccel accel_; + + std::string name_; + + const M *mesh_; + + std::vector children_; +}; + +// ------------------------------------------------- + +// Predefined SAH predicator for cube. +template +class NodeBBoxPred { + public: + NodeBBoxPred(const std::vector > *nodes) + : axis_(0), pos_(0.0f), nodes_(nodes) {} + + void Set(int axis, float pos) const { + axis_ = axis; + pos_ = pos; + } + + bool operator()(unsigned int i) const { + int axis = axis_; + float pos = pos_; + + T bmin[3], bmax[3]; + + (*nodes_)[i].GetWorldBoundingBox(bmin, bmax); + + T center = bmax[axis] - bmin[axis]; + + return (center < pos); + } + + private: + mutable int axis_; + mutable float pos_; + const std::vector > *nodes_; +}; + +template +class NodeBBoxGeometry { + public: + NodeBBoxGeometry(const std::vector > *nodes) : nodes_(nodes) {} + + /// Compute bounding box for `prim_index`th cube. + /// This function is called for each primitive in BVH build. + void BoundingBox(nanort::real3 *bmin, nanort::real3 *bmax, + unsigned int prim_index) const { + T a[3], b[3]; + (*nodes_)[prim_index].GetWorldBoundingBox(a, b); + (*bmin)[0] = a[0]; + (*bmin)[1] = a[1]; + (*bmin)[2] = a[2]; + (*bmax)[0] = b[0]; + (*bmax)[1] = b[1]; + (*bmax)[2] = b[2]; + } + + const std::vector > *nodes_; + mutable nanort::real3 ray_org_; + mutable nanort::real3 ray_dir_; + mutable nanort::BVHTraceOptions trace_options_; + int _pad_; +}; + +class NodeBBoxIntersection { + public: + NodeBBoxIntersection() {} + + float normal[3]; + + // Required member variables. + float t; + unsigned int prim_id; +}; + +template +class NodeBBoxIntersector { + public: + NodeBBoxIntersector(const std::vector > *nodes) : nodes_(nodes) {} + + bool Intersect(float *out_t_min, float *out_t_max, + unsigned int prim_index) const { + T bmin[3], bmax[3]; + + (*nodes_)[prim_index].GetWorldBoundingBox(bmin, bmax); + + float tmin, tmax; + + const float min_x = ray_dir_sign_[0] ? bmax[0] : bmin[0]; + const float min_y = ray_dir_sign_[1] ? bmax[1] : bmin[1]; + const float min_z = ray_dir_sign_[2] ? bmax[2] : bmin[2]; + const float max_x = ray_dir_sign_[0] ? bmin[0] : bmax[0]; + const float max_y = ray_dir_sign_[1] ? bmin[1] : bmax[1]; + const float max_z = ray_dir_sign_[2] ? bmin[2] : bmax[2]; + + // X + const float tmin_x = (min_x - ray_org_[0]) * ray_inv_dir_[0]; + const float tmax_x = (max_x - ray_org_[0]) * ray_inv_dir_[0]; + + // Y + const float tmin_y = (min_y - ray_org_[1]) * ray_inv_dir_[1]; + const float tmax_y = (max_y - ray_org_[1]) * ray_inv_dir_[1]; + + // Z + const float tmin_z = (min_z - ray_org_[2]) * ray_inv_dir_[2]; + const float tmax_z = (max_z - ray_org_[2]) * ray_inv_dir_[2]; + + tmin = nanort::safemax(tmin_z, nanort::safemax(tmin_y, tmin_x)); + tmax = nanort::safemin(tmax_z, nanort::safemin(tmax_y, tmax_x)); + + if (tmin <= tmax) { + (*out_t_min) = tmin; + (*out_t_max) = tmax; + return true; + } + + return false; + } + + /// Prepare BVH traversal(e.g. compute inverse ray direction) + /// This function is called only once in BVH traversal. + void PrepareTraversal(const nanort::Ray &ray) const { + ray_org_[0] = ray.org[0]; + ray_org_[1] = ray.org[1]; + ray_org_[2] = ray.org[2]; + + ray_dir_[0] = ray.dir[0]; + ray_dir_[1] = ray.dir[1]; + ray_dir_[2] = ray.dir[2]; + + // FIXME(syoyo): Consider zero div case. + ray_inv_dir_[0] = static_cast(1.0) / ray.dir[0]; + ray_inv_dir_[1] = static_cast(1.0) / ray.dir[1]; + ray_inv_dir_[2] = static_cast(1.0) / ray.dir[2]; + + ray_dir_sign_[0] = ray.dir[0] < static_cast(0.0) ? 1 : 0; + ray_dir_sign_[1] = ray.dir[1] < static_cast(0.0) ? 1 : 0; + ray_dir_sign_[2] = ray.dir[2] < static_cast(0.0) ? 1 : 0; + } + + const std::vector > *nodes_; + mutable nanort::real3 ray_org_; + mutable nanort::real3 ray_dir_; + mutable nanort::real3 ray_inv_dir_; + mutable int ray_dir_sign_[3]; +}; + +template +class Scene { + public: + Scene() { + bmin_[0] = bmin_[1] = bmin_[2] = std::numeric_limits::max(); + bmax_[0] = bmax_[1] = bmax_[2] = -std::numeric_limits::max(); + } + + ~Scene() {} + + /// + /// Add intersectable node to the scene. + /// + bool AddNode(const Node &node) { + nodes_.push_back(node); + return true; + } + + const std::vector > &GetNodes() const { return nodes_; } + + bool FindNode(const std::string &name, Node **found_node) { + if (!found_node) { + return false; + } + + if (name.empty()) { + return false; + } + + // Simple exhaustive search. + for (size_t i = 0; i < nodes_.size(); i++) { + if (FindNodeRecursive(name, &(nodes_[i]), found_node)) { + return true; + } + } + + return false; + } + + /// + /// Commit the scene. Must be called before tracing rays into the scene. + /// + bool Commit() { + // the scene should contains something + if (nodes_.size() == 0) { + std::cerr << "You are attempting to commit an empty scene!\n"; + return false; + } + + // Update nodes. + for (size_t i = 0; i < nodes_.size(); i++) { + T ident[4][4]; + Matrix::Identity(ident); + + nodes_[i].Update(ident); + } + + // Build toplevel BVH. + NodeBBoxGeometry geom(&nodes_); + NodeBBoxPred pred(&nodes_); + + // FIXME(LTE): Limit one leaf contains one node bbox primitive. This would + // work, but would be inefficient. + // e.g. will miss some node when constructed BVH depth is larger than the + // value of BVHBuildOptions. + // Implement more better and efficient BVH build and traverse for Toplevel + // BVH. + nanort::BVHBuildOptions build_options; + build_options.min_leaf_primitives = 1; + + bool ret = toplevel_accel_.Build(static_cast(nodes_.size()), + geom, pred, build_options); + + nanort::BVHBuildStatistics stats = toplevel_accel_.GetStatistics(); + (void)stats; + + // toplevel_accel_.Debug(); + + if (ret) { + toplevel_accel_.BoundingBox(bmin_, bmax_); + } else { + // Set invalid bbox value. + bmin_[0] = std::numeric_limits::max(); + bmin_[1] = std::numeric_limits::max(); + bmin_[2] = std::numeric_limits::max(); + + bmax_[0] = -std::numeric_limits::max(); + bmax_[1] = -std::numeric_limits::max(); + bmax_[2] = -std::numeric_limits::max(); + } + + return ret; + } + + /// + /// Get the scene bounding box. + /// + void GetBoundingBox(T bmin[3], T bmax[3]) const { + bmin[0] = bmin_[0]; + bmin[1] = bmin_[1]; + bmin[2] = bmin_[2]; + + bmax[0] = bmax_[0]; + bmax[1] = bmax_[1]; + bmax[2] = bmax_[2]; + } + + /// + /// Trace the ray into the scene. + /// First find the intersection of nodes' bounding box using toplevel BVH. + /// Then, trace into the hit node to find the intersection of the primitive. + /// + template + bool Traverse(nanort::Ray &ray, H *isect, + const bool cull_back_face = false) const { + if (!toplevel_accel_.IsValid()) { + return false; + } + + const int kMaxIntersections = 64; + + bool has_hit = false; + + NodeBBoxIntersector isector(&nodes_); + nanort::StackVector, 128> node_hits; + bool may_hit = toplevel_accel_.ListNodeIntersections(ray, kMaxIntersections, + isector, &node_hits); + + if (may_hit) { + T t_max = std::numeric_limits::max(); + T t_nearest = t_max; + + nanort::BVHTraceOptions trace_options; + trace_options.cull_back_face = cull_back_face; + + // Find actual intersection point. + for (size_t i = 0; i < node_hits->size(); i++) { + // Early cull test. + if (t_nearest < node_hits[i].t_min) { + // printf("near: %f, t_min: %f, t_max: %f\n", t_nearest, + // node_hits[i].t_min, node_hits[i].t_max); + continue; + } + + assert(node_hits[i].node_id < nodes_.size()); + const Node &node = nodes_[node_hits[i].node_id]; + + // Transform ray into node's local space + // TODO(LTE): Set ray tmin and tmax + nanort::Ray local_ray; + Matrix::MultV(local_ray.org, node.inv_xform_, ray.org); + Matrix::MultV(local_ray.dir, node.inv_xform33_, ray.dir); + + nanort::TriangleIntersector triangle_intersector( + node.GetMesh()->vertices.data(), node.GetMesh()->faces.data(), + node.GetMesh()->stride); + H local_isect; + + bool hit = node.GetAccel().Traverse(local_ray, triangle_intersector, + &local_isect); + + if (hit) { + // Calulcate hit distance in world coordiante. + T local_P[3]; + local_P[0] = local_ray.org[0] + local_isect.t * local_ray.dir[0]; + local_P[1] = local_ray.org[1] + local_isect.t * local_ray.dir[1]; + local_P[2] = local_ray.org[2] + local_isect.t * local_ray.dir[2]; + + T world_P[3]; + Matrix::MultV(world_P, node.xform_, local_P); + + nanort::real3 po; + po[0] = world_P[0] - ray.org[0]; + po[1] = world_P[1] - ray.org[1]; + po[2] = world_P[2] - ray.org[2]; + + float t_world = vlength(po); + // printf("tworld %f, tnear %f\n", t_world, t_nearest); + + if (t_world < t_nearest) { + t_nearest = t_world; + has_hit = true; + //(*isect) = local_isect; + isect->node_id = node_hits[i].node_id; + isect->prim_id = local_isect.prim_id; + isect->u = local_isect.u; + isect->v = local_isect.v; + + // TODO(LTE): Implement + T Ng[3], Ns[3]; // geometric normal, shading normal. + + node.GetMesh()->GetNormal(Ng, Ns, isect->prim_id, isect->u, + isect->v); + + // Convert position and normal into world coordinate. + isect->t = t_world; + Matrix::MultV(isect->P, node.xform_, local_P); + Matrix::MultV(isect->Ng, node.inv_transpose_xform33_, Ng); + Matrix::MultV(isect->Ns, node.inv_transpose_xform33_, Ns); + } + } + } + } + + return has_hit; + } + + private: + /// + /// Find a node by name. + /// + bool FindNodeRecursive(const std::string &name, Node *root, + Node **found_node) { + if (root->GetName().compare(name) == 0) { + (*found_node) = root; + return true; + } + + // Simple exhaustive search. + for (size_t i = 0; i < root->GetChildren().size(); i++) { + if (FindNodeRecursive(name, &(root->GetChildren()[i]), found_node)) { + return true; + } + } + + return false; + } + + // Scene bounding box. + // Valid after calling `Commit()`. + T bmin_[3]; + T bmax_[3]; + + // Toplevel BVH accel. + nanort::BVHAccel toplevel_accel_; + std::vector > nodes_; +}; + +} // namespace nanosg + +#endif // NANOSG_H_ diff --git a/3rdparty/tinygltf/examples/raytrace/obj-loader.cc b/3rdparty/tinygltf/examples/raytrace/obj-loader.cc new file mode 100644 index 0000000..d55fb45 --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/obj-loader.cc @@ -0,0 +1,458 @@ +#include "obj-loader.h" +#include "nanort.h" // for float3 + +#define TINYOBJLOADER_IMPLEMENTATION +#include "tiny_obj_loader.h" + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wold-style-cast" +#pragma clang diagnostic ignored "-Wreserved-id-macro" +#pragma clang diagnostic ignored "-Wc++98-compat-pedantic" +#pragma clang diagnostic ignored "-Wcast-align" +#pragma clang diagnostic ignored "-Wpadded" +#pragma clang diagnostic ignored "-Wold-style-cast" +#pragma clang diagnostic ignored "-Wsign-conversion" +#pragma clang diagnostic ignored "-Wvariadic-macros" +#pragma clang diagnostic ignored "-Wc++11-extensions" +#pragma clang diagnostic ignored "-Wdisabled-macro-expansion" +#pragma clang diagnostic ignored "-Wimplicit-fallthrough" +#if __has_warning("-Wdouble-promotion") +#pragma clang diagnostic ignored "-Wdouble-promotion" +#endif +#if __has_warning("-Wcomma") +#pragma clang diagnostic ignored "-Wcomma" +#endif +#if __has_warning("-Wcast-qual") +#pragma clang diagnostic ignored "-Wcast-qual" +#endif +#endif + +#include "stb_image.h" + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#include + +#ifdef NANOSG_USE_CXX11 +#include +#else +#include +#endif + +#define USE_TEX_CACHE 1 + +namespace example { + +typedef nanort::real3 float3; + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wexit-time-destructors" +#pragma clang diagnostic ignored "-Wglobal-constructors" +#endif + +// TODO(LTE): Remove global static definition. +#ifdef NANOSG_USE_CXX11 +static std::unordered_map hashed_tex; +#else +static std::map hashed_tex; +#endif + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +inline void CalcNormal(float3 &N, float3 v0, float3 v1, float3 v2) { + float3 v10 = v1 - v0; + float3 v20 = v2 - v0; + + N = vcross(v20, v10); + N = vnormalize(N); +} + +static std::string GetBaseDir(const std::string &filepath) { + if (filepath.find_last_of("/\\") != std::string::npos) + return filepath.substr(0, filepath.find_last_of("/\\")); + return ""; +} + +static int LoadTexture(const std::string &filename, + std::vector *textures) { + int idx; + + if (filename.empty()) return -1; + + std::cout << " Loading texture : " << filename << std::endl; + Texture texture; + + // tigra: find in cache. get index + if (USE_TEX_CACHE) { + if (hashed_tex.find(filename) != hashed_tex.end()) { + puts("from cache"); + return hashed_tex[filename]; + } + } + + int w, h, n; + unsigned char *data = stbi_load(filename.c_str(), &w, &h, &n, 0); + if (data) { + texture.width = w; + texture.height = h; + texture.components = n; + + size_t n_elem = size_t(w * h * n); + texture.image = new unsigned char[n_elem]; + for (size_t i = 0; i < n_elem; i++) { + texture.image[i] = data[i]; + } + + free(data); + + textures->push_back(texture); + + idx = int(textures->size()) - 1; + + // tigra: store index to cache + if (USE_TEX_CACHE) { + hashed_tex[filename] = idx; + } + + return idx; + } + + std::cout << " Failed to load : " << filename << std::endl; + return -1; +} + +static void ComputeBoundingBoxOfMesh(float bmin[3], float bmax[3], + const example::Mesh &mesh) { + bmin[0] = bmin[1] = bmin[2] = std::numeric_limits::max(); + bmax[0] = bmax[1] = bmax[2] = -std::numeric_limits::max(); + + for (size_t i = 0; i < mesh.vertices.size() / 3; i++) { + bmin[0] = std::min(bmin[0], mesh.vertices[3 * i + 0]); + bmin[1] = std::min(bmin[1], mesh.vertices[3 * i + 1]); + bmin[2] = std::min(bmin[1], mesh.vertices[3 * i + 2]); + + bmax[0] = std::max(bmax[0], mesh.vertices[3 * i + 0]); + bmax[1] = std::max(bmax[1], mesh.vertices[3 * i + 1]); + bmax[2] = std::max(bmax[2], mesh.vertices[3 * i + 2]); + } +} + +bool LoadObj(const std::string &filename, float scale, + std::vector > *meshes, + std::vector *out_materials, + std::vector *out_textures) { + tinyobj::attrib_t attrib; + std::vector shapes; + std::vector materials; + std::string err; + + std::string basedir = GetBaseDir(filename) + "/"; + const char *basepath = (basedir.compare("/") == 0) ? NULL : basedir.c_str(); + + // auto t_start = std::chrono::system_clock::now(); + + bool ret = + tinyobj::LoadObj(&attrib, &shapes, &materials, &err, filename.c_str(), + basepath, /* triangulate */ true); + + // auto t_end = std::chrono::system_clock::now(); + // std::chrono::duration ms = t_end - t_start; + + if (!err.empty()) { + std::cerr << err << std::endl; + } + + if (!ret) { + return false; + } + + // std::cout << "[LoadOBJ] Parse time : " << ms.count() << " [msecs]" + // << std::endl; + + std::cout << "[LoadOBJ] # of shapes in .obj : " << shapes.size() << std::endl; + std::cout << "[LoadOBJ] # of materials in .obj : " << materials.size() + << std::endl; + + { + size_t total_num_vertices = 0; + size_t total_num_faces = 0; + + total_num_vertices = attrib.vertices.size() / 3; + std::cout << " vertices : " << attrib.vertices.size() / 3 << std::endl; + + for (size_t i = 0; i < shapes.size(); i++) { + std::cout << " shape[" << i << "].name : " << shapes[i].name + << std::endl; + std::cout << " shape[" << i + << "].indices : " << shapes[i].mesh.indices.size() << std::endl; + assert((shapes[i].mesh.indices.size() % 3) == 0); + + total_num_faces += shapes[i].mesh.indices.size() / 3; + + // tigra: empty name convert to _id + if (shapes[i].name.length() == 0) { +#ifdef NANOSG_USE_CXX11 + shapes[i].name = "_" + std::to_string(i); +#else + std::stringstream ss; + ss << i; + shapes[i].name = "_" + ss.str(); +#endif + std::cout << " EMPTY shape[" << i << "].name, new : " << shapes[i].name + << std::endl; + } + } + std::cout << "[LoadOBJ] # of faces: " << total_num_faces << std::endl; + std::cout << "[LoadOBJ] # of vertices: " << total_num_vertices << std::endl; + } + + // TODO(LTE): Implement tangents and binormals + + for (size_t i = 0; i < shapes.size(); i++) { + Mesh mesh(/* stride */ sizeof(float) * 3); + + mesh.name = shapes[i].name; + + const size_t num_faces = shapes[i].mesh.indices.size() / 3; + mesh.faces.resize(num_faces * 3); + mesh.material_ids.resize(num_faces); + mesh.facevarying_normals.resize(num_faces * 3 * 3); + mesh.facevarying_uvs.resize(num_faces * 3 * 2); + mesh.vertices.resize(num_faces * 3 * 3); + + for (size_t f = 0; f < shapes[i].mesh.indices.size() / 3; f++) { + // reorder vertices. may create duplicated vertices. + size_t f0 = size_t(shapes[i].mesh.indices[3 * f + 0].vertex_index); + size_t f1 = size_t(shapes[i].mesh.indices[3 * f + 1].vertex_index); + size_t f2 = size_t(shapes[i].mesh.indices[3 * f + 2].vertex_index); + + mesh.vertices[9 * f + 0] = scale * attrib.vertices[3 * f0 + 0]; + mesh.vertices[9 * f + 1] = scale * attrib.vertices[3 * f0 + 1]; + mesh.vertices[9 * f + 2] = scale * attrib.vertices[3 * f0 + 2]; + + mesh.vertices[9 * f + 3] = scale * attrib.vertices[3 * f1 + 0]; + mesh.vertices[9 * f + 4] = scale * attrib.vertices[3 * f1 + 1]; + mesh.vertices[9 * f + 5] = scale * attrib.vertices[3 * f1 + 2]; + + mesh.vertices[9 * f + 6] = scale * attrib.vertices[3 * f2 + 0]; + mesh.vertices[9 * f + 7] = scale * attrib.vertices[3 * f2 + 1]; + mesh.vertices[9 * f + 8] = scale * attrib.vertices[3 * f2 + 2]; + + mesh.faces[3 * f + 0] = static_cast(3 * f + 0); + mesh.faces[3 * f + 1] = static_cast(3 * f + 1); + mesh.faces[3 * f + 2] = static_cast(3 * f + 2); + + mesh.material_ids[f] = + static_cast(shapes[i].mesh.material_ids[f]); + } + + if (attrib.normals.size() > 0) { + for (size_t f = 0; f < shapes[i].mesh.indices.size() / 3; f++) { + size_t f0, f1, f2; + + f0 = size_t(shapes[i].mesh.indices[3 * f + 0].normal_index); + f1 = size_t(shapes[i].mesh.indices[3 * f + 1].normal_index); + f2 = size_t(shapes[i].mesh.indices[3 * f + 2].normal_index); + + if (f0 > 0 && f1 > 0 && f2 > 0) { + float n0[3], n1[3], n2[3]; + + n0[0] = attrib.normals[3 * f0 + 0]; + n0[1] = attrib.normals[3 * f0 + 1]; + n0[2] = attrib.normals[3 * f0 + 2]; + + n1[0] = attrib.normals[3 * f1 + 0]; + n1[1] = attrib.normals[3 * f1 + 1]; + n1[2] = attrib.normals[3 * f1 + 2]; + + n2[0] = attrib.normals[3 * f2 + 0]; + n2[1] = attrib.normals[3 * f2 + 1]; + n2[2] = attrib.normals[3 * f2 + 2]; + + mesh.facevarying_normals[3 * (3 * f + 0) + 0] = n0[0]; + mesh.facevarying_normals[3 * (3 * f + 0) + 1] = n0[1]; + mesh.facevarying_normals[3 * (3 * f + 0) + 2] = n0[2]; + + mesh.facevarying_normals[3 * (3 * f + 1) + 0] = n1[0]; + mesh.facevarying_normals[3 * (3 * f + 1) + 1] = n1[1]; + mesh.facevarying_normals[3 * (3 * f + 1) + 2] = n1[2]; + + mesh.facevarying_normals[3 * (3 * f + 2) + 0] = n2[0]; + mesh.facevarying_normals[3 * (3 * f + 2) + 1] = n2[1]; + mesh.facevarying_normals[3 * (3 * f + 2) + 2] = n2[2]; + } else { // face contains invalid normal index. calc geometric normal. + f0 = size_t(shapes[i].mesh.indices[3 * f + 0].vertex_index); + f1 = size_t(shapes[i].mesh.indices[3 * f + 1].vertex_index); + f2 = size_t(shapes[i].mesh.indices[3 * f + 2].vertex_index); + + float3 v0, v1, v2; + + v0[0] = attrib.vertices[3 * f0 + 0]; + v0[1] = attrib.vertices[3 * f0 + 1]; + v0[2] = attrib.vertices[3 * f0 + 2]; + + v1[0] = attrib.vertices[3 * f1 + 0]; + v1[1] = attrib.vertices[3 * f1 + 1]; + v1[2] = attrib.vertices[3 * f1 + 2]; + + v2[0] = attrib.vertices[3 * f2 + 0]; + v2[1] = attrib.vertices[3 * f2 + 1]; + v2[2] = attrib.vertices[3 * f2 + 2]; + + float3 N; + CalcNormal(N, v0, v1, v2); + + mesh.facevarying_normals[3 * (3 * f + 0) + 0] = N[0]; + mesh.facevarying_normals[3 * (3 * f + 0) + 1] = N[1]; + mesh.facevarying_normals[3 * (3 * f + 0) + 2] = N[2]; + + mesh.facevarying_normals[3 * (3 * f + 1) + 0] = N[0]; + mesh.facevarying_normals[3 * (3 * f + 1) + 1] = N[1]; + mesh.facevarying_normals[3 * (3 * f + 1) + 2] = N[2]; + + mesh.facevarying_normals[3 * (3 * f + 2) + 0] = N[0]; + mesh.facevarying_normals[3 * (3 * f + 2) + 1] = N[1]; + mesh.facevarying_normals[3 * (3 * f + 2) + 2] = N[2]; + } + } + } else { + // calc geometric normal + for (size_t f = 0; f < shapes[i].mesh.indices.size() / 3; f++) { + size_t f0, f1, f2; + + f0 = size_t(shapes[i].mesh.indices[3 * f + 0].vertex_index); + f1 = size_t(shapes[i].mesh.indices[3 * f + 1].vertex_index); + f2 = size_t(shapes[i].mesh.indices[3 * f + 2].vertex_index); + + float3 v0, v1, v2; + + v0[0] = attrib.vertices[3 * f0 + 0]; + v0[1] = attrib.vertices[3 * f0 + 1]; + v0[2] = attrib.vertices[3 * f0 + 2]; + + v1[0] = attrib.vertices[3 * f1 + 0]; + v1[1] = attrib.vertices[3 * f1 + 1]; + v1[2] = attrib.vertices[3 * f1 + 2]; + + v2[0] = attrib.vertices[3 * f2 + 0]; + v2[1] = attrib.vertices[3 * f2 + 1]; + v2[2] = attrib.vertices[3 * f2 + 2]; + + float3 N; + CalcNormal(N, v0, v1, v2); + + mesh.facevarying_normals[3 * (3 * f + 0) + 0] = N[0]; + mesh.facevarying_normals[3 * (3 * f + 0) + 1] = N[1]; + mesh.facevarying_normals[3 * (3 * f + 0) + 2] = N[2]; + + mesh.facevarying_normals[3 * (3 * f + 1) + 0] = N[0]; + mesh.facevarying_normals[3 * (3 * f + 1) + 1] = N[1]; + mesh.facevarying_normals[3 * (3 * f + 1) + 2] = N[2]; + + mesh.facevarying_normals[3 * (3 * f + 2) + 0] = N[0]; + mesh.facevarying_normals[3 * (3 * f + 2) + 1] = N[1]; + mesh.facevarying_normals[3 * (3 * f + 2) + 2] = N[2]; + } + } + + if (attrib.texcoords.size() > 0) { + for (size_t f = 0; f < shapes[i].mesh.indices.size() / 3; f++) { + size_t f0, f1, f2; + + f0 = size_t(shapes[i].mesh.indices[3 * f + 0].texcoord_index); + f1 = size_t(shapes[i].mesh.indices[3 * f + 1].texcoord_index); + f2 = size_t(shapes[i].mesh.indices[3 * f + 2].texcoord_index); + + if (f0 > 0 && f1 > 0 && f2 > 0) { + float3 n0, n1, n2; + + n0[0] = attrib.texcoords[2 * f0 + 0]; + n0[1] = attrib.texcoords[2 * f0 + 1]; + + n1[0] = attrib.texcoords[2 * f1 + 0]; + n1[1] = attrib.texcoords[2 * f1 + 1]; + + n2[0] = attrib.texcoords[2 * f2 + 0]; + n2[1] = attrib.texcoords[2 * f2 + 1]; + + mesh.facevarying_uvs[2 * (3 * f + 0) + 0] = n0[0]; + mesh.facevarying_uvs[2 * (3 * f + 0) + 1] = n0[1]; + + mesh.facevarying_uvs[2 * (3 * f + 1) + 0] = n1[0]; + mesh.facevarying_uvs[2 * (3 * f + 1) + 1] = n1[1]; + + mesh.facevarying_uvs[2 * (3 * f + 2) + 0] = n2[0]; + mesh.facevarying_uvs[2 * (3 * f + 2) + 1] = n2[1]; + } + } + } + + // Compute pivot translation and add offset to the vertices. + float bmin[3], bmax[3]; + ComputeBoundingBoxOfMesh(bmin, bmax, mesh); + + float bcenter[3]; + bcenter[0] = 0.5f * (bmax[0] - bmin[0]) + bmin[0]; + bcenter[1] = 0.5f * (bmax[1] - bmin[1]) + bmin[1]; + bcenter[2] = 0.5f * (bmax[2] - bmin[2]) + bmin[2]; + + for (size_t v = 0; v < mesh.vertices.size() / 3; v++) { + mesh.vertices[3 * v + 0] -= bcenter[0]; + mesh.vertices[3 * v + 1] -= bcenter[1]; + mesh.vertices[3 * v + 2] -= bcenter[2]; + } + + mesh.pivot_xform[0][0] = 1.0f; + mesh.pivot_xform[0][1] = 0.0f; + mesh.pivot_xform[0][2] = 0.0f; + mesh.pivot_xform[0][3] = 0.0f; + + mesh.pivot_xform[1][0] = 0.0f; + mesh.pivot_xform[1][1] = 1.0f; + mesh.pivot_xform[1][2] = 0.0f; + mesh.pivot_xform[1][3] = 0.0f; + + mesh.pivot_xform[2][0] = 0.0f; + mesh.pivot_xform[2][1] = 0.0f; + mesh.pivot_xform[2][2] = 1.0f; + mesh.pivot_xform[2][3] = 0.0f; + + mesh.pivot_xform[3][0] = bcenter[0]; + mesh.pivot_xform[3][1] = bcenter[1]; + mesh.pivot_xform[3][2] = bcenter[2]; + mesh.pivot_xform[3][3] = 1.0f; + + meshes->push_back(mesh); + } + + // material_t -> Material and Texture + out_materials->resize(materials.size()); + out_textures->resize(0); + for (size_t i = 0; i < materials.size(); i++) { + (*out_materials)[i].diffuse[0] = materials[i].diffuse[0]; + (*out_materials)[i].diffuse[1] = materials[i].diffuse[1]; + (*out_materials)[i].diffuse[2] = materials[i].diffuse[2]; + (*out_materials)[i].specular[0] = materials[i].specular[0]; + (*out_materials)[i].specular[1] = materials[i].specular[1]; + (*out_materials)[i].specular[2] = materials[i].specular[2]; + + (*out_materials)[i].id = int(i); + + // map_Kd + (*out_materials)[i].diffuse_texid = + LoadTexture(materials[i].diffuse_texname, out_textures); + // map_Ks + (*out_materials)[i].specular_texid = + LoadTexture(materials[i].specular_texname, out_textures); + } + + return true; +} + +} // namespace example diff --git a/3rdparty/tinygltf/examples/raytrace/obj-loader.h b/3rdparty/tinygltf/examples/raytrace/obj-loader.h new file mode 100644 index 0000000..9827791 --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/obj-loader.h @@ -0,0 +1,19 @@ +#ifndef EXAMPLE_OBJ_LOADER_H_ +#define EXAMPLE_OBJ_LOADER_H_ + +#include +#include + +#include "mesh.h" +#include "material.h" + +namespace example { + +/// +/// Loads wavefront .obj mesh +/// +bool LoadObj(const std::string &filename, float scale, std::vector > *meshes, std::vector *materials, std::vector *textures); + +} + +#endif // EXAMPLE_OBJ_LOADER_H_ diff --git a/3rdparty/tinygltf/examples/raytrace/premake5.lua b/3rdparty/tinygltf/examples/raytrace/premake5.lua new file mode 100644 index 0000000..d035674 --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/premake5.lua @@ -0,0 +1,115 @@ +newoption { + trigger = "with-gtk3nfd", + description = "Build with native file dialog support(GTK3 required. Linux only)" +} + +newoption { + trigger = "asan", + description = "Enable Address Sanitizer(gcc5+ ang clang only)" +} + +sources = { + "stbi-impl.cc", + "main.cc", + "render.cc", + "render-config.cc", + "obj-loader.cc", + "gltf-loader.cc", + "matrix.cc", + "../common/trackball.cc", + "../common/imgui/imgui.cpp", + "../common/imgui/imgui_draw.cpp", + "../common/imgui/imgui_impl_btgui.cpp", + "../common/imgui/ImGuizmo.cpp", + } + +solution "NanoSGSolution" + configurations { "Release", "Debug" } + + if os.is("Windows") then + platforms { "x64", "x32" } + else + platforms { "native", "x64", "x32" } + end + + + -- RootDir for OpenGLWindow + projectRootDir = os.getcwd() .. "/../common/" + dofile ("../common/findOpenGLGlewGlut.lua") + initOpenGL() + initGlew() + + -- Use c++11 + flags { "c++11" } + + -- A project defines one build target + project "viwewer" + kind "ConsoleApp" + language "C++" + files { sources } + + includedirs { "./", "../../" } + includedirs { "../common" } + includedirs { "../common/imgui" } + includedirs { "../common/glm" } + --includedirs { "../common/nativefiledialog/src/include" } + + if _OPTIONS['asan'] then + buildoptions { "-fsanitize=address" } + linkoptions { "-fsanitize=address" } + end + + if os.is("Windows") then + warnings "Extra" -- /W4 + + defines { "NOMINMAX" } + defines { "USE_NATIVEFILEDIALOG" } + buildoptions { "/W4" } -- raise compile error level. + files{ + "../common/OpenGLWindow/Win32OpenGLWindow.cpp", + "../common/OpenGLWindow/Win32OpenGLWindow.h", + "../common/OpenGLWindow/Win32Window.cpp", + "../common/OpenGLWindow/Win32Window.h", + } + includedirs { "./../common/nativefiledialog/src/include" } + files { "../common/nativefiledialog/src/nfd_common.c", + "../common/nativefiledialog/src/nfd_win.cpp" } + end + if os.is("Linux") then + files { + "../common/OpenGLWindow/X11OpenGLWindow.cpp", + "../common/OpenGLWindow/X11OpenGLWindows.h" + } + links {"X11", "pthread", "dl"} + if _OPTIONS["with-gtk3nfd"] then + defines { "USE_NATIVEFILEDIALOG" } + includedirs { "./../common/nativefiledialog/src/include" } + files { "../common/nativefiledialog/src/nfd_gtk.c", + "../common/nativefiledialog/src/nfd_common.c" + } + buildoptions { "`pkg-config --cflags gtk+-3.0`" } + linkoptions { "`pkg-config --libs gtk+-3.0`" } + end + end + if os.is("MacOSX") then + defines { "USE_NATIVEFILEDIALOG" } + links {"Cocoa.framework"} + files { + "../common/OpenGLWindow/MacOpenGLWindow.h", + "../common/OpenGLWindow/MacOpenGLWindow.mm", + } + includedirs { "./../common/nativefiledialog/src/include" } + files { "../common/nativefiledialog/src/nfd_cocoa.m", + "../common/nativefiledialog/src/nfd_common.c" } + end + + configuration "Debug" + defines { "DEBUG" } -- -DDEBUG + symbols "On" + targetname "view_debug" + + configuration "Release" + -- defines { "NDEBUG" } -- -NDEBUG + symbols "On" + optimize "On" + targetname "view" diff --git a/3rdparty/tinygltf/examples/raytrace/render-config.cc b/3rdparty/tinygltf/examples/raytrace/render-config.cc new file mode 100644 index 0000000..2a30b61 --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/render-config.cc @@ -0,0 +1,122 @@ +#include "render-config.h" + +#include "picojson.h" + +#include +#include + +namespace example { + +bool LoadRenderConfig(example::RenderConfig* config, const char* filename) { + std::ifstream is(filename); + if (is.fail()) { + std::cerr << "Cannot open " << filename << std::endl; + return false; + } + + std::istream_iterator input(is); + std::string err; + picojson::value v; + input = picojson::parse(v, input, std::istream_iterator(), &err); + if (!err.empty()) { + std::cerr << err << std::endl; + } + + if (!v.is()) { + std::cerr << "Not a JSON object" << std::endl; + return false; + } + + picojson::object o = v.get(); + + if (o.find("obj_filename") != o.end()) { + if (o["obj_filename"].is()) { + config->obj_filename = o["obj_filename"].get(); + } + } + + if (o.find("gltf_filename") != o.end()) { + if (o["gltf_filename"].is()) { + config->gltf_filename = o["gltf_filename"].get(); + } + } + + if (o.find("eson_filename") != o.end()) { + if (o["eson_filename"].is()) { + config->eson_filename = o["eson_filename"].get(); + } + } + + config->scene_scale = 1.0f; + if (o.find("scene_scale") != o.end()) { + if (o["scene_scale"].is()) { + config->scene_scale = static_cast(o["scene_scale"].get()); + } + } + + config->eye[0] = 0.0f; + config->eye[1] = 0.0f; + config->eye[2] = 5.0f; + if (o.find("eye") != o.end()) { + if (o["eye"].is()) { + picojson::array arr = o["eye"].get(); + if (arr.size() == 3) { + config->eye[0] = static_cast(arr[0].get()); + config->eye[1] = static_cast(arr[1].get()); + config->eye[2] = static_cast(arr[2].get()); + } + } + } + + config->up[0] = 0.0f; + config->up[1] = 1.0f; + config->up[2] = 0.0f; + if (o.find("up") != o.end()) { + if (o["up"].is()) { + picojson::array arr = o["up"].get(); + if (arr.size() == 3) { + config->up[0] = static_cast(arr[0].get()); + config->up[1] = static_cast(arr[1].get()); + config->up[2] = static_cast(arr[2].get()); + } + } + } + + config->look_at[0] = 0.0f; + config->look_at[1] = 0.0f; + config->look_at[2] = 0.0f; + if (o.find("look_at") != o.end()) { + if (o["look_at"].is()) { + picojson::array arr = o["look_at"].get(); + if (arr.size() == 3) { + config->look_at[0] = static_cast(arr[0].get()); + config->look_at[1] = static_cast(arr[1].get()); + config->look_at[2] = static_cast(arr[2].get()); + } + } + } + + config->fov = 45.0f; + if (o.find("fov") != o.end()) { + if (o["fov"].is()) { + config->fov = static_cast(o["fov"].get()); + } + } + + config->width = 512; + if (o.find("width") != o.end()) { + if (o["width"].is()) { + config->width = static_cast(o["width"].get()); + } + } + + config->height = 512; + if (o.find("height") != o.end()) { + if (o["height"].is()) { + config->height = static_cast(o["height"].get()); + } + } + + return true; +} +} // namespace example diff --git a/3rdparty/tinygltf/examples/raytrace/render-config.h b/3rdparty/tinygltf/examples/raytrace/render-config.h new file mode 100644 index 0000000..c3ffe4e --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/render-config.h @@ -0,0 +1,43 @@ +#ifndef RENDER_CONFIG_H +#define RENDER_CONFIG_H + +#include + +namespace example { + +typedef struct { + // framebuffer + int width; + int height; + + // camera + float eye[3]; + float up[3]; + float look_at[3]; + float fov; // vertical fov in degree. + + // render pass + int pass; + int max_passes; + + // For debugging. Array size = width * height * 4. + float *normalImage; + float *positionImage; + float *depthImage; + float *texcoordImage; + float *varycoordImage; + + // Scene input info + std::string obj_filename; + std::string gltf_filename; + std::string eson_filename; + float scene_scale; + +} RenderConfig; + +/// Loads config from JSON file. +bool LoadRenderConfig(example::RenderConfig *config, const char *filename); + +} // namespace + +#endif // RENDER_CONFIG_H diff --git a/3rdparty/tinygltf/examples/raytrace/render.cc b/3rdparty/tinygltf/examples/raytrace/render.cc new file mode 100644 index 0000000..1749369 --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/render.cc @@ -0,0 +1,560 @@ +/* +The MIT License (MIT) + +Copyright (c) 2015 - 2016 Light Transport Entertainment, Inc. + +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. +*/ + + +#ifdef _MSC_VER +#pragma warning(disable : 4018) +#pragma warning(disable : 4244) +#pragma warning(disable : 4189) +#pragma warning(disable : 4996) +#pragma warning(disable : 4267) +#pragma warning(disable : 4477) +#endif + +#include "render.h" + +#include // C++11 +#include +#include // C++11 +#include + +#include + +#include "nanort.h" +#include "matrix.h" +#include "material.h" +#include "mesh.h" + + +#include "trackball.h" + + +#ifdef WIN32 +#undef min +#undef max +#endif + +namespace example { + +// PCG32 code / (c) 2014 M.E. O'Neill / pcg-random.org +// Licensed under Apache License 2.0 (NO WARRANTY, etc. see website) +// http://www.pcg-random.org/ +typedef struct { + unsigned long long state; + unsigned long long inc; // not used? +} pcg32_state_t; + +#define PCG32_INITIALIZER \ + { 0x853c49e6748fea9bULL, 0xda3e39cb94b95bdbULL } + +float pcg32_random(pcg32_state_t* rng) { + unsigned long long oldstate = rng->state; + rng->state = oldstate * 6364136223846793005ULL + rng->inc; + unsigned int xorshifted = ((oldstate >> 18u) ^ oldstate) >> 27u; + unsigned int rot = oldstate >> 59u; + unsigned int ret = (xorshifted >> rot) | (xorshifted << ((-static_cast(rot)) & 31)); + + return (float)((double)ret / (double)4294967296.0); +} + +void pcg32_srandom(pcg32_state_t* rng, uint64_t initstate, uint64_t initseq) { + rng->state = 0U; + rng->inc = (initseq << 1U) | 1U; + pcg32_random(rng); + rng->state += initstate; + pcg32_random(rng); +} + +const float kPI = 3.141592f; + +typedef nanort::real3 float3; + +inline float3 Lerp3(float3 v0, float3 v1, float3 v2, float u, float v) { + return (1.0f - u - v) * v0 + u * v1 + v * v2; +} + +inline void CalcNormal(float3& N, float3 v0, float3 v1, float3 v2) { + float3 v10 = v1 - v0; + float3 v20 = v2 - v0; + + N = vcross(v20, v10); + N = vnormalize(N); +} + +void BuildCameraFrame(float3* origin, float3* corner, float3* u, float3* v, + float quat[4], float eye[3], float lookat[3], float up[3], + float fov, int width, int height) { + float e[4][4]; + + Matrix::LookAt(e, eye, lookat, up); + + float r[4][4]; + build_rotmatrix(r, quat); + + float3 lo; + lo[0] = lookat[0] - eye[0]; + lo[1] = lookat[1] - eye[1]; + lo[2] = lookat[2] - eye[2]; + float dist = vlength(lo); + + float dir[3]; + dir[0] = 0.0; + dir[1] = 0.0; + dir[2] = dist; + + Matrix::Inverse(r); + + float rr[4][4]; + float re[4][4]; + float zero[3] = {0.0f, 0.0f, 0.0f}; + float localUp[3] = {0.0f, 1.0f, 0.0f}; + Matrix::LookAt(re, dir, zero, localUp); + + // translate + re[3][0] += eye[0]; // 0.0; //lo[0]; + re[3][1] += eye[1]; // 0.0; //lo[1]; + re[3][2] += (eye[2] - dist); + + // rot -> trans + Matrix::Mult(rr, r, re); + + float m[4][4]; + for (int j = 0; j < 4; j++) { + for (int i = 0; i < 4; i++) { + m[j][i] = rr[j][i]; + } + } + + float vzero[3] = {0.0f, 0.0f, 0.0f}; + float eye1[3]; + Matrix::MultV(eye1, m, vzero); + + float lookat1d[3]; + dir[2] = -dir[2]; + Matrix::MultV(lookat1d, m, dir); + float3 lookat1(lookat1d[0], lookat1d[1], lookat1d[2]); + + float up1d[3]; + Matrix::MultV(up1d, m, up); + + float3 up1(up1d[0], up1d[1], up1d[2]); + + // absolute -> relative + up1[0] -= eye1[0]; + up1[1] -= eye1[1]; + up1[2] -= eye1[2]; + // printf("up1(after) = %f, %f, %f\n", up1[0], up1[1], up1[2]); + + // Use original up vector + // up1[0] = up[0]; + // up1[1] = up[1]; + // up1[2] = up[2]; + + { + float flen = + (0.5f * (float)height / tanf(0.5f * (float)(fov * kPI / 180.0f))); + float3 look1; + look1[0] = lookat1[0] - eye1[0]; + look1[1] = lookat1[1] - eye1[1]; + look1[2] = lookat1[2] - eye1[2]; + // vcross(u, up1, look1); + // flip + (*u) = nanort::vcross(look1, up1); + (*u) = vnormalize((*u)); + + (*v) = vcross(look1, (*u)); + (*v) = vnormalize((*v)); + + look1 = vnormalize(look1); + look1[0] = flen * look1[0] + eye1[0]; + look1[1] = flen * look1[1] + eye1[1]; + look1[2] = flen * look1[2] + eye1[2]; + (*corner)[0] = look1[0] - 0.5f * (width * (*u)[0] + height * (*v)[0]); + (*corner)[1] = look1[1] - 0.5f * (width * (*u)[1] + height * (*v)[1]); + (*corner)[2] = look1[2] - 0.5f * (width * (*u)[2] + height * (*v)[2]); + + (*origin)[0] = eye1[0]; + (*origin)[1] = eye1[1]; + (*origin)[2] = eye1[2]; + } +} + +#if 0 // TODO(LTE): Not used method. Delete. +nanort::Ray GenerateRay(const float3& origin, const float3& corner, + const float3& du, const float3& dv, float u, + float v) { + float3 dir; + + dir[0] = (corner[0] + u * du[0] + v * dv[0]) - origin[0]; + dir[1] = (corner[1] + u * du[1] + v * dv[1]) - origin[1]; + dir[2] = (corner[2] + u * du[2] + v * dv[2]) - origin[2]; + dir = vnormalize(dir); + + float3 org; + + nanort::Ray ray; + ray.org[0] = origin[0]; + ray.org[1] = origin[1]; + ray.org[2] = origin[2]; + ray.dir[0] = dir[0]; + ray.dir[1] = dir[1]; + ray.dir[2] = dir[2]; + + return ray; +} +#endif + +void FetchTexture(const Texture &texture, float u, float v, float* col) { + int tx = u * texture.width; + int ty = (1.0f - v) * texture.height; + int idx_offset = (ty * texture.width + tx) * texture.components; + col[0] = texture.image[idx_offset + 0] / 255.f; + col[1] = texture.image[idx_offset + 1] / 255.f; + col[2] = texture.image[idx_offset + 2] / 255.f; +} + +bool Renderer::Render(float* rgba, float* aux_rgba, int* sample_counts, + float quat[4], + const nanosg::Scene> &scene, + const example::Asset &asset, + const RenderConfig& config, + std::atomic& cancelFlag, + int &_showBufferMode + ) { + //if (!gAccel.IsValid()) { + // return false; + //} + + + + + int width = config.width; + int height = config.height; + + // camera + float eye[3] = {config.eye[0], config.eye[1], config.eye[2]}; + float look_at[3] = {config.look_at[0], config.look_at[1], config.look_at[2]}; + float up[3] = {config.up[0], config.up[1], config.up[2]}; + float fov = config.fov; + float3 origin, corner, u, v; + BuildCameraFrame(&origin, &corner, &u, &v, quat, eye, look_at, up, fov, width, + height); + + auto kCancelFlagCheckMilliSeconds = 300; + + std::vector workers; + std::atomic i(0); + + uint32_t num_threads = std::max(1U, std::thread::hardware_concurrency()); + + auto startT = std::chrono::system_clock::now(); + + // Initialize RNG. + + for (auto t = 0; t < num_threads; t++) { + workers.emplace_back(std::thread([&, t]() { + pcg32_state_t rng; + pcg32_srandom(&rng, config.pass, + t); // seed = combination of render pass + thread no. + + int y = 0; + while ((y = i++) < config.height) { + auto currT = std::chrono::system_clock::now(); + + std::chrono::duration ms = currT - startT; + // Check cancel flag + if (ms.count() > kCancelFlagCheckMilliSeconds) { + if (cancelFlag) { + break; + } + } + + // draw dash line to aux buffer for progress. + // for (int x = 0; x < config.width; x++) { + // float c = (x / 8) % 2; + // aux_rgba[4*(y*config.width+x)+0] = c; + // aux_rgba[4*(y*config.width+x)+1] = c; + // aux_rgba[4*(y*config.width+x)+2] = c; + // aux_rgba[4*(y*config.width+x)+3] = 0.0f; + //} + + for (int x = 0; x < config.width; x++) { + nanort::Ray ray; + ray.org[0] = origin[0]; + ray.org[1] = origin[1]; + ray.org[2] = origin[2]; + + float u0 = pcg32_random(&rng); + float u1 = pcg32_random(&rng); + + float3 dir; + + //for modes not a "color" + if(_showBufferMode != SHOW_BUFFER_COLOR) + { + //only one pass + if(config.pass > 0) + continue; + + //to the center of pixel + u0 = 0.5f; + u1 = 0.5f; + } + + dir = corner + (float(x) + u0) * u + + (float(config.height - y - 1) + u1) * v; + dir = vnormalize(dir); + ray.dir[0] = dir[0]; + ray.dir[1] = dir[1]; + ray.dir[2] = dir[2]; + + float kFar = 1.0e+30f; + ray.min_t = 0.0f; + ray.max_t = kFar; + + + nanosg::Intersection isect; + bool hit = scene.Traverse(ray, &isect, /* cull_back_face */false); + + if (hit) { + + const std::vector &materials = asset.materials; + const std::vector &textures = asset.textures; + const Mesh &mesh = asset.meshes[isect.node_id]; + + //tigra: add default material + const Material &default_material = asset.default_material; + + float3 p; + p[0] = + ray.org[0] + isect.t * ray.dir[0]; + p[1] = + ray.org[1] + isect.t * ray.dir[1]; + p[2] = + ray.org[2] + isect.t * ray.dir[2]; + + config.positionImage[4 * (y * config.width + x) + 0] = p.x(); + config.positionImage[4 * (y * config.width + x) + 1] = p.y(); + config.positionImage[4 * (y * config.width + x) + 2] = p.z(); + config.positionImage[4 * (y * config.width + x) + 3] = 1.0f; + + config.varycoordImage[4 * (y * config.width + x) + 0] = + isect.u; + config.varycoordImage[4 * (y * config.width + x) + 1] = + isect.v; + config.varycoordImage[4 * (y * config.width + x) + 2] = 0.0f; + config.varycoordImage[4 * (y * config.width + x) + 3] = 1.0f; + + unsigned int prim_id = isect.prim_id; + + float3 N; + if (mesh.facevarying_normals.size() > 0) { + float3 n0, n1, n2; + n0[0] = mesh.facevarying_normals[9 * prim_id + 0]; + n0[1] = mesh.facevarying_normals[9 * prim_id + 1]; + n0[2] = mesh.facevarying_normals[9 * prim_id + 2]; + n1[0] = mesh.facevarying_normals[9 * prim_id + 3]; + n1[1] = mesh.facevarying_normals[9 * prim_id + 4]; + n1[2] = mesh.facevarying_normals[9 * prim_id + 5]; + n2[0] = mesh.facevarying_normals[9 * prim_id + 6]; + n2[1] = mesh.facevarying_normals[9 * prim_id + 7]; + n2[2] = mesh.facevarying_normals[9 * prim_id + 8]; + N = Lerp3(n0, n1, n2, isect.u, isect.v); + } else { + unsigned int f0, f1, f2; + f0 = mesh.faces[3 * prim_id + 0]; + f1 = mesh.faces[3 * prim_id + 1]; + f2 = mesh.faces[3 * prim_id + 2]; + + float3 v0, v1, v2; + v0[0] = mesh.vertices[3 * f0 + 0]; + v0[1] = mesh.vertices[3 * f0 + 1]; + v0[2] = mesh.vertices[3 * f0 + 2]; + v1[0] = mesh.vertices[3 * f1 + 0]; + v1[1] = mesh.vertices[3 * f1 + 1]; + v1[2] = mesh.vertices[3 * f1 + 2]; + v2[0] = mesh.vertices[3 * f2 + 0]; + v2[1] = mesh.vertices[3 * f2 + 1]; + v2[2] = mesh.vertices[3 * f2 + 2]; + CalcNormal(N, v0, v1, v2); + } + + config.normalImage[4 * (y * config.width + x) + 0] = + 0.5f * N[0] + 0.5f; + config.normalImage[4 * (y * config.width + x) + 1] = + 0.5f * N[1] + 0.5f; + config.normalImage[4 * (y * config.width + x) + 2] = + 0.5f * N[2] + 0.5f; + config.normalImage[4 * (y * config.width + x) + 3] = 1.0f; + + config.depthImage[4 * (y * config.width + x) + 0] = + isect.t; + config.depthImage[4 * (y * config.width + x) + 1] = + isect.t; + config.depthImage[4 * (y * config.width + x) + 2] = + isect.t; + config.depthImage[4 * (y * config.width + x) + 3] = 1.0f; + + float3 UV; + if (mesh.facevarying_uvs.size() > 0) { + float3 uv0, uv1, uv2; + uv0[0] = mesh.facevarying_uvs[6 * prim_id + 0]; + uv0[1] = mesh.facevarying_uvs[6 * prim_id + 1]; + uv1[0] = mesh.facevarying_uvs[6 * prim_id + 2]; + uv1[1] = mesh.facevarying_uvs[6 * prim_id + 3]; + uv2[0] = mesh.facevarying_uvs[6 * prim_id + 4]; + uv2[1] = mesh.facevarying_uvs[6 * prim_id + 5]; + + UV = Lerp3(uv0, uv1, uv2, isect.u, isect.v); + + config.texcoordImage[4 * (y * config.width + x) + 0] = UV[0]; + config.texcoordImage[4 * (y * config.width + x) + 1] = UV[1]; + } + + // Fetch texture + unsigned int material_id = + mesh.material_ids[isect.prim_id]; + + //printf("material_id=%d materials=%lld\n", material_id, materials.size()); + + float diffuse_col[3]; + + float specular_col[3]; + + //tigra: material_id is ok + if(material_id= 0) { + FetchTexture(textures[diffuse_texid], UV[0], UV[1], diffuse_col); + } else { + diffuse_col[0] = materials[material_id].diffuse[0]; + diffuse_col[1] = materials[material_id].diffuse[1]; + diffuse_col[2] = materials[material_id].diffuse[2]; + } + + int specular_texid = materials[material_id].specular_texid; + if (specular_texid >= 0) { + FetchTexture(textures[specular_texid], UV[0], UV[1], specular_col); + } else { + specular_col[0] = materials[material_id].specular[0]; + specular_col[1] = materials[material_id].specular[1]; + specular_col[2] = materials[material_id].specular[2]; + } + } + else + //tigra: wrong material_id, use default_material + { + + //printf("default_material\n"); + + diffuse_col[0] = default_material.diffuse[0]; + diffuse_col[1] = default_material.diffuse[1]; + diffuse_col[2] = default_material.diffuse[2]; + specular_col[0] = default_material.specular[0]; + specular_col[1] = default_material.specular[1]; + specular_col[2] = default_material.specular[2]; + } + + // Simple shading + float NdotV = fabsf(vdot(N, dir)); + + if (config.pass == 0) { + rgba[4 * (y * config.width + x) + 0] = NdotV * diffuse_col[0]; + rgba[4 * (y * config.width + x) + 1] = NdotV * diffuse_col[1]; + rgba[4 * (y * config.width + x) + 2] = NdotV * diffuse_col[2]; + rgba[4 * (y * config.width + x) + 3] = 1.0f; + sample_counts[y * config.width + x] = + 1; // Set 1 for the first pass + } else { // additive. + rgba[4 * (y * config.width + x) + 0] += NdotV * diffuse_col[0]; + rgba[4 * (y * config.width + x) + 1] += NdotV * diffuse_col[1]; + rgba[4 * (y * config.width + x) + 2] += NdotV * diffuse_col[2]; + rgba[4 * (y * config.width + x) + 3] += 1.0f; + sample_counts[y * config.width + x]++; + } + + } else { + { + if (config.pass == 0) { + // clear pixel + rgba[4 * (y * config.width + x) + 0] = 0.0f; + rgba[4 * (y * config.width + x) + 1] = 0.0f; + rgba[4 * (y * config.width + x) + 2] = 0.0f; + rgba[4 * (y * config.width + x) + 3] = 0.0f; + aux_rgba[4 * (y * config.width + x) + 0] = 0.0f; + aux_rgba[4 * (y * config.width + x) + 1] = 0.0f; + aux_rgba[4 * (y * config.width + x) + 2] = 0.0f; + aux_rgba[4 * (y * config.width + x) + 3] = 0.0f; + sample_counts[y * config.width + x] = + 1; // Set 1 for the first pass + } else { + sample_counts[y * config.width + x]++; + } + + // No super sampling + config.normalImage[4 * (y * config.width + x) + 0] = 0.0f; + config.normalImage[4 * (y * config.width + x) + 1] = 0.0f; + config.normalImage[4 * (y * config.width + x) + 2] = 0.0f; + config.normalImage[4 * (y * config.width + x) + 3] = 0.0f; + config.positionImage[4 * (y * config.width + x) + 0] = 0.0f; + config.positionImage[4 * (y * config.width + x) + 1] = 0.0f; + config.positionImage[4 * (y * config.width + x) + 2] = 0.0f; + config.positionImage[4 * (y * config.width + x) + 3] = 0.0f; + config.depthImage[4 * (y * config.width + x) + 0] = 0.0f; + config.depthImage[4 * (y * config.width + x) + 1] = 0.0f; + config.depthImage[4 * (y * config.width + x) + 2] = 0.0f; + config.depthImage[4 * (y * config.width + x) + 3] = 0.0f; + config.texcoordImage[4 * (y * config.width + x) + 0] = 0.0f; + config.texcoordImage[4 * (y * config.width + x) + 1] = 0.0f; + config.texcoordImage[4 * (y * config.width + x) + 2] = 0.0f; + config.texcoordImage[4 * (y * config.width + x) + 3] = 0.0f; + config.varycoordImage[4 * (y * config.width + x) + 0] = 0.0f; + config.varycoordImage[4 * (y * config.width + x) + 1] = 0.0f; + config.varycoordImage[4 * (y * config.width + x) + 2] = 0.0f; + config.varycoordImage[4 * (y * config.width + x) + 3] = 0.0f; + } + } + } + + for (int x = 0; x < config.width; x++) { + aux_rgba[4 * (y * config.width + x) + 0] = 0.0f; + aux_rgba[4 * (y * config.width + x) + 1] = 0.0f; + aux_rgba[4 * (y * config.width + x) + 2] = 0.0f; + aux_rgba[4 * (y * config.width + x) + 3] = 0.0f; + } + } + })); + } + + for (auto& t : workers) { + t.join(); + } + + return (!cancelFlag); +}; + +} // namespace example diff --git a/3rdparty/tinygltf/examples/raytrace/render.h b/3rdparty/tinygltf/examples/raytrace/render.h new file mode 100644 index 0000000..ccd2f2d --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/render.h @@ -0,0 +1,45 @@ +#ifndef EXAMPLE_RENDER_H_ +#define EXAMPLE_RENDER_H_ + +#include // C++11 + +//mode definitions now here + +#define SHOW_BUFFER_COLOR (0) +#define SHOW_BUFFER_NORMAL (1) +#define SHOW_BUFFER_POSITION (2) +#define SHOW_BUFFER_DEPTH (3) +#define SHOW_BUFFER_TEXCOORD (4) +#define SHOW_BUFFER_VARYCOORD (5) + +#include "render-config.h" +#include "nanosg.h" +#include "mesh.h" +#include "material.h" + +namespace example { + +struct Asset { + std::vector > meshes; + std::vector materials; + + //tigra: add default material + Material default_material; + std::vector textures; +}; + +class Renderer { + public: + Renderer() {} + ~Renderer() {} + + /// Returns false when the rendering was canceled. + static bool Render(float* rgba, float* aux_rgba, int *sample_counts, float quat[4], + const nanosg::Scene> &scene, const Asset &asset, const RenderConfig& config, + std::atomic& cancel_flag, + int& _showBufferMode + ); +}; +}; + +#endif // EXAMPLE_RENDER_H_ diff --git a/3rdparty/tinygltf/examples/raytrace/stbi-impl.cc b/3rdparty/tinygltf/examples/raytrace/stbi-impl.cc new file mode 100644 index 0000000..0375a5a --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/stbi-impl.cc @@ -0,0 +1,3 @@ + +#define STB_IMAGE_IMPLEMENTATION +#include "stb_image.h" diff --git a/3rdparty/tinygltf/examples/raytrace/viwewer.make b/3rdparty/tinygltf/examples/raytrace/viwewer.make new file mode 100644 index 0000000..3d35b1b --- /dev/null +++ b/3rdparty/tinygltf/examples/raytrace/viwewer.make @@ -0,0 +1,357 @@ +# GNU Make project makefile autogenerated by Premake + +ifndef config + config=release_native +endif + +ifndef verbose + SILENT = @ +endif + +.PHONY: clean prebuild prelink + +ifeq ($(config),release_native) + RESCOMP = windres + TARGETDIR = bin/native/Release + TARGET = $(TARGETDIR)/view + OBJDIR = obj/native/Release + DEFINES += -DGLEW_INIT_OPENGL11_FUNCTIONS=1 -DGLEW_STATIC -DGLEW_DYNAMIC_LOAD_ALL_GLX_FUNCTIONS=1 + INCLUDES += -I../common/ThirdPartyLibs/Glew -I. -I../.. -I../common -I../common/imgui -I../common/glm + FORCE_INCLUDE += + ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES) + ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -O2 -g + ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -O2 -g -std=c++11 + ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES) + LIBS += -lX11 -lpthread -ldl + LDDEPS += + ALL_LDFLAGS += $(LDFLAGS) + LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS) + define PREBUILDCMDS + endef + define PRELINKCMDS + endef + define POSTBUILDCMDS + endef +all: prebuild prelink $(TARGET) + @: + +endif + +ifeq ($(config),release_x64) + RESCOMP = windres + TARGETDIR = bin/x64/Release + TARGET = $(TARGETDIR)/view + OBJDIR = obj/x64/Release + DEFINES += -DGLEW_INIT_OPENGL11_FUNCTIONS=1 -DGLEW_STATIC -DGLEW_DYNAMIC_LOAD_ALL_GLX_FUNCTIONS=1 + INCLUDES += -I../common/ThirdPartyLibs/Glew -I. -I../.. -I../common -I../common/imgui -I../common/glm + FORCE_INCLUDE += + ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES) + ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m64 -O2 -g + ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m64 -O2 -g -std=c++11 + ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES) + LIBS += -lX11 -lpthread -ldl + LDDEPS += + ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib64 -m64 + LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS) + define PREBUILDCMDS + endef + define PRELINKCMDS + endef + define POSTBUILDCMDS + endef +all: prebuild prelink $(TARGET) + @: + +endif + +ifeq ($(config),release_x32) + RESCOMP = windres + TARGETDIR = bin/x32/Release + TARGET = $(TARGETDIR)/view + OBJDIR = obj/x32/Release + DEFINES += -DGLEW_INIT_OPENGL11_FUNCTIONS=1 -DGLEW_STATIC -DGLEW_DYNAMIC_LOAD_ALL_GLX_FUNCTIONS=1 + INCLUDES += -I../common/ThirdPartyLibs/Glew -I. -I../.. -I../common -I../common/imgui -I../common/glm + FORCE_INCLUDE += + ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES) + ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m32 -O2 -g + ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m32 -O2 -g -std=c++11 + ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES) + LIBS += -lX11 -lpthread -ldl + LDDEPS += + ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib32 -m32 + LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS) + define PREBUILDCMDS + endef + define PRELINKCMDS + endef + define POSTBUILDCMDS + endef +all: prebuild prelink $(TARGET) + @: + +endif + +ifeq ($(config),debug_native) + RESCOMP = windres + TARGETDIR = bin/native/Debug + TARGET = $(TARGETDIR)/view_debug + OBJDIR = obj/native/Debug + DEFINES += -DGLEW_INIT_OPENGL11_FUNCTIONS=1 -DGLEW_STATIC -DGLEW_DYNAMIC_LOAD_ALL_GLX_FUNCTIONS=1 -DDEBUG + INCLUDES += -I../common/ThirdPartyLibs/Glew -I. -I../.. -I../common -I../common/imgui -I../common/glm + FORCE_INCLUDE += + ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES) + ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -g + ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -g -std=c++11 + ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES) + LIBS += -lX11 -lpthread -ldl + LDDEPS += + ALL_LDFLAGS += $(LDFLAGS) + LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS) + define PREBUILDCMDS + endef + define PRELINKCMDS + endef + define POSTBUILDCMDS + endef +all: prebuild prelink $(TARGET) + @: + +endif + +ifeq ($(config),debug_x64) + RESCOMP = windres + TARGETDIR = bin/x64/Debug + TARGET = $(TARGETDIR)/view_debug + OBJDIR = obj/x64/Debug + DEFINES += -DGLEW_INIT_OPENGL11_FUNCTIONS=1 -DGLEW_STATIC -DGLEW_DYNAMIC_LOAD_ALL_GLX_FUNCTIONS=1 -DDEBUG + INCLUDES += -I../common/ThirdPartyLibs/Glew -I. -I../.. -I../common -I../common/imgui -I../common/glm + FORCE_INCLUDE += + ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES) + ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m64 -g + ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m64 -g -std=c++11 + ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES) + LIBS += -lX11 -lpthread -ldl + LDDEPS += + ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib64 -m64 + LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS) + define PREBUILDCMDS + endef + define PRELINKCMDS + endef + define POSTBUILDCMDS + endef +all: prebuild prelink $(TARGET) + @: + +endif + +ifeq ($(config),debug_x32) + RESCOMP = windres + TARGETDIR = bin/x32/Debug + TARGET = $(TARGETDIR)/view_debug + OBJDIR = obj/x32/Debug + DEFINES += -DGLEW_INIT_OPENGL11_FUNCTIONS=1 -DGLEW_STATIC -DGLEW_DYNAMIC_LOAD_ALL_GLX_FUNCTIONS=1 -DDEBUG + INCLUDES += -I../common/ThirdPartyLibs/Glew -I. -I../.. -I../common -I../common/imgui -I../common/glm + FORCE_INCLUDE += + ALL_CPPFLAGS += $(CPPFLAGS) -MMD -MP $(DEFINES) $(INCLUDES) + ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) -m32 -g + ALL_CXXFLAGS += $(CXXFLAGS) $(ALL_CPPFLAGS) -m32 -g -std=c++11 + ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES) + LIBS += -lX11 -lpthread -ldl + LDDEPS += + ALL_LDFLAGS += $(LDFLAGS) -L/usr/lib32 -m32 + LINKCMD = $(CXX) -o "$@" $(OBJECTS) $(RESOURCES) $(ALL_LDFLAGS) $(LIBS) + define PREBUILDCMDS + endef + define PRELINKCMDS + endef + define POSTBUILDCMDS + endef +all: prebuild prelink $(TARGET) + @: + +endif + +OBJECTS := \ + $(OBJDIR)/X11OpenGLWindow.o \ + $(OBJDIR)/glew.o \ + $(OBJDIR)/ImGuizmo.o \ + $(OBJDIR)/imgui.o \ + $(OBJDIR)/imgui_draw.o \ + $(OBJDIR)/imgui_impl_btgui.o \ + $(OBJDIR)/trackball.o \ + $(OBJDIR)/gltf-loader.o \ + $(OBJDIR)/main.o \ + $(OBJDIR)/matrix.o \ + $(OBJDIR)/obj-loader.o \ + $(OBJDIR)/render-config.o \ + $(OBJDIR)/render.o \ + $(OBJDIR)/stbi-impl.o \ + +RESOURCES := \ + +CUSTOMFILES := \ + +SHELLTYPE := msdos +ifeq (,$(ComSpec)$(COMSPEC)) + SHELLTYPE := posix +endif +ifeq (/bin,$(findstring /bin,$(SHELL))) + SHELLTYPE := posix +endif + +$(TARGET): $(GCH) ${CUSTOMFILES} $(OBJECTS) $(LDDEPS) $(RESOURCES) + @echo Linking viwewer +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(TARGETDIR) +else + $(SILENT) mkdir $(subst /,\\,$(TARGETDIR)) +endif + $(SILENT) $(LINKCMD) + $(POSTBUILDCMDS) + +clean: + @echo Cleaning viwewer +ifeq (posix,$(SHELLTYPE)) + $(SILENT) rm -f $(TARGET) + $(SILENT) rm -rf $(OBJDIR) +else + $(SILENT) if exist $(subst /,\\,$(TARGET)) del $(subst /,\\,$(TARGET)) + $(SILENT) if exist $(subst /,\\,$(OBJDIR)) rmdir /s /q $(subst /,\\,$(OBJDIR)) +endif + +prebuild: + $(PREBUILDCMDS) + +prelink: + $(PRELINKCMDS) + +ifneq (,$(PCH)) +$(OBJECTS): $(GCH) $(PCH) +$(GCH): $(PCH) + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) -x c++-header $(ALL_CXXFLAGS) -o "$@" -MF "$(@:%.gch=%.d)" -c "$<" +endif + +$(OBJDIR)/X11OpenGLWindow.o: ../common/OpenGLWindow/X11OpenGLWindow.cpp + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" +$(OBJDIR)/glew.o: ../common/ThirdPartyLibs/Glew/glew.c + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CC) $(ALL_CFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" +$(OBJDIR)/ImGuizmo.o: ../common/imgui/ImGuizmo.cpp + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" +$(OBJDIR)/imgui.o: ../common/imgui/imgui.cpp + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" +$(OBJDIR)/imgui_draw.o: ../common/imgui/imgui_draw.cpp + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" +$(OBJDIR)/imgui_impl_btgui.o: ../common/imgui/imgui_impl_btgui.cpp + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" +$(OBJDIR)/trackball.o: ../common/trackball.cc + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" +$(OBJDIR)/gltf-loader.o: gltf-loader.cc + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" +$(OBJDIR)/main.o: main.cc + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" +$(OBJDIR)/matrix.o: matrix.cc + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" +$(OBJDIR)/obj-loader.o: obj-loader.cc + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" +$(OBJDIR)/render-config.o: render-config.cc + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" +$(OBJDIR)/render.o: render.cc + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" +$(OBJDIR)/stbi-impl.o: stbi-impl.cc + @echo $(notdir $<) +ifeq (posix,$(SHELLTYPE)) + $(SILENT) mkdir -p $(OBJDIR) +else + $(SILENT) mkdir $(subst /,\\,$(OBJDIR)) +endif + $(SILENT) $(CXX) $(ALL_CXXFLAGS) $(FORCE_INCLUDE) -o "$@" -MF "$(@:%.o=%.d)" -c "$<" + +-include $(OBJECTS:%.o=%.d) +ifneq (,$(PCH)) + -include $(OBJDIR)/$(notdir $(PCH)).d +endif \ No newline at end of file diff --git a/3rdparty/tinygltf/examples/saver/Makefile.dev b/3rdparty/tinygltf/examples/saver/Makefile.dev new file mode 100644 index 0000000..f36d3df --- /dev/null +++ b/3rdparty/tinygltf/examples/saver/Makefile.dev @@ -0,0 +1,2 @@ +all: + clang++ -std=c++11 -I../../ -g -O1 -o saver main.cc diff --git a/3rdparty/tinygltf/examples/saver/README.md b/3rdparty/tinygltf/examples/saver/README.md new file mode 100644 index 0000000..69e5a26 --- /dev/null +++ b/3rdparty/tinygltf/examples/saver/README.md @@ -0,0 +1 @@ +# Simple serialization API sample. diff --git a/3rdparty/tinygltf/examples/saver/main.cc b/3rdparty/tinygltf/examples/saver/main.cc new file mode 100644 index 0000000..cbc478b --- /dev/null +++ b/3rdparty/tinygltf/examples/saver/main.cc @@ -0,0 +1,33 @@ +#include +#include + +#define TINYGLTF_IMPLEMENTATION +#define STB_IMAGE_IMPLEMENTATION +#include "tiny_gltf.h" + +int main(int argc, char *argv[]) +{ + if (argc != 3) { + std::cout << "Needs input.gltf output.gltf" << std::endl; + return EXIT_FAILURE; + } + + tinygltf::Model model; + tinygltf::TinyGLTF loader; + std::string err; + std::string input_filename(argv[1]); + std::string output_filename(argv[2]); + + // assume ascii glTF. + bool ret = loader.LoadASCIIFromFile(&model, &err, input_filename.c_str()); + if (!ret) { + if (!err.empty()) { + std::cerr << err << std::endl; + } + return EXIT_FAILURE; + } + loader.WriteGltfSceneToFile(&model, output_filename); + + return EXIT_SUCCESS; + +} diff --git a/3rdparty/tinygltf/examples/validator/CMakeLists.txt b/3rdparty/tinygltf/examples/validator/CMakeLists.txt new file mode 100644 index 0000000..4dd8a80 --- /dev/null +++ b/3rdparty/tinygltf/examples/validator/CMakeLists.txt @@ -0,0 +1,47 @@ +project(tinygltf-validator CXX) + +cmake_minimum_required(VERSION 3.2) + +# exe +add_executable(tinygltf-validator + app/tinygltf-validate.cc + src/json-schema.hpp + src/json-schema-draft4.json.cpp + src/json-uri.cpp + src/json-validator.cpp) + +target_include_directories(tinygltf-validator + PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR}/src) + +target_compile_features(tinygltf-validator + PUBLIC + cxx_range_for) # for C++11 - flags +# Enable more compiler warnings, except when using Visual Studio compiler +if(NOT MSVC) + target_compile_options(tinygltf-validator + PUBLIC + -Wall -Wextra) +endif() +target_compile_definitions(tinygltf-validator + PRIVATE + -DJSON_SCHEMA_VALIDATOR_EXPORTS) + +# regex with boost if gcc < 4.8 - default is std::regex +if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.9.0") + find_package(Boost COMPONENTS regex) + if(NOT Boost_FOUND) + message(STATUS "GCC less then 4.9 and boost-regex NOT found - no regex used") + target_compile_definitions(tinygltf-validator PRIVATE -DJSON_SCHEMA_NO_REGEX) + else() + message(STATUS "GCC less then 4.9 and boost-regex FOUND - using boost::regex") + target_compile_definitions(tinygltf-validator PRIVATE -DJSON_SCHEMA_BOOST_REGEX) + target_include_directories(tinygltf-validator PRIVATE ${Boost_INCLUDE_DIRS}) + target_link_libraries(tinygltf-validator PRIVATE ${Boost_LIBRARIES}) + endif() + endif() +endif() + +# test-zone +# enable_testing() diff --git a/3rdparty/tinygltf/examples/validator/LICENSE.json-schema-validator.MIT b/3rdparty/tinygltf/examples/validator/LICENSE.json-schema-validator.MIT new file mode 100644 index 0000000..f660b34 --- /dev/null +++ b/3rdparty/tinygltf/examples/validator/LICENSE.json-schema-validator.MIT @@ -0,0 +1,22 @@ +Modern C++ JSON schema validator is licensed under the MIT License +: + +Copyright (c) 2016 Patrick Boettcher + +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. diff --git a/3rdparty/tinygltf/examples/validator/LICENSE.jsonhpp.MIT b/3rdparty/tinygltf/examples/validator/LICENSE.jsonhpp.MIT new file mode 100644 index 0000000..00599af --- /dev/null +++ b/3rdparty/tinygltf/examples/validator/LICENSE.jsonhpp.MIT @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2013-2017 Niels Lohmann + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/3rdparty/tinygltf/examples/validator/README.md b/3rdparty/tinygltf/examples/validator/README.md new file mode 100644 index 0000000..0becc8d --- /dev/null +++ b/3rdparty/tinygltf/examples/validator/README.md @@ -0,0 +1,32 @@ +# tinygltf-validator + +TinyGLTF validator based on Modern C++ JSON schema validator https://github.com/pboettch/json-schema-validator + +## Status + +Experimental. W.I.P. + +## Requirements + +* C++11 compiler +* CMake + +## How to build + +``` +$ mkdir build +$ cd build +$ cmake .. +$ make +``` + +## How to use + +``` +$ gltf-validator /path/to/file.gltf /path/to/gltf-schema +``` + +## Third party licenses + +* json.hpp https://github.com/nlohmann/json : MIT +* json-schema-validator https://github.com/pboettch/json-schema-validator : MIT diff --git a/3rdparty/tinygltf/examples/validator/app/tinygltf-validate.cc b/3rdparty/tinygltf/examples/validator/app/tinygltf-validate.cc new file mode 100644 index 0000000..def5577 --- /dev/null +++ b/3rdparty/tinygltf/examples/validator/app/tinygltf-validate.cc @@ -0,0 +1,140 @@ +/* + * Modern C++ JSON schema validator + * + * Licensed under the MIT License . + * + * Copyright (c) 2016 Patrick Boettcher . + * + * 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. + */ +#include + +#include +#include + +using nlohmann::json; +using nlohmann::json_uri; +using nlohmann::json_schema_draft4::json_validator; + +static void usage(const char *name) +{ + std::cerr << "Usage: " << name << " \n"; + std::cerr << " schema dir : $glTF/specification/2.0/schema\n"; + exit(EXIT_FAILURE); +} + +#if 0 + resolver r(nlohmann::json_schema_draft4::root_schema, + nlohmann::json_schema_draft4::root_schema["id"]); + schema_refs_.insert(r.schema_refs.begin(), r.schema_refs.end()); + assert(r.undefined_refs.size() == 0); +#endif + +#if 0 +static void loader(const json_uri &uri, json &schema) +{ + std::fstream lf("." + uri.path()); + if (!lf.good()) + throw std::invalid_argument("could not open " + uri.url() + " tried with " + uri.path()); + + try { + lf >> schema; + } catch (std::exception &e) { + throw e; + } +} +#endif + +bool validate(const std::string &schema_dir, const std::string &filename) +{ + std::string gltf_schema = schema_dir + "/glTF.schema.json"; + + std::fstream f(gltf_schema); + if (!f.good()) { + std::cerr << "could not open " << gltf_schema << " for reading\n"; + return false; + } + + // 1) Read the schema for the document you want to validate + json schema; + try { + f >> schema; + } catch (std::exception &e) { + std::cerr << e.what() << " at " << f.tellp() << " - while parsing the schema\n"; + return false; + } + + // 2) create the validator and + json_validator validator([&schema_dir](const json_uri &uri, json &schema) { + std::cout << "uri.url : " << uri.url() << std::endl; + std::cout << "uri.path : " << uri.path() << std::endl; + + std::fstream lf(schema_dir + "/" + uri.path()); + if (!lf.good()) + throw std::invalid_argument("could not open " + uri.url() + " tried with " + uri.path()); + + try { + lf >> schema; + } catch (std::exception &e) { + throw e; + } + }, [](const std::string &, const std::string &) {}); + + try { + // insert this schema as the root to the validator + // this resolves remote-schemas, sub-schemas and references via the given loader-function + validator.set_root_schema(schema); + } catch (std::exception &e) { + std::cerr << "setting root schema failed\n"; + std::cerr << e.what() << "\n"; + } + + // 3) do the actual validation of the document + json document; + + std::fstream d(filename); + if (!d.good()) { + std::cerr << "could not open " << filename << " for reading\n"; + return false; + } + + try { + d >> document; + validator.validate(document); + } catch (std::exception &e) { + std::cerr << "schema validation failed\n"; + std::cerr << e.what() << " at offset: " << d.tellg() << "\n"; + return false; + } + + std::cerr << "document is valid\n"; + + return true; + +} + +int main(int argc, char *argv[]) +{ + if (argc != 3) + usage(argv[0]); + + bool ret = validate(argv[1], argv[2]); + + return ret ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/3rdparty/tinygltf/examples/validator/src/json-schema-draft4.json.cpp b/3rdparty/tinygltf/examples/validator/src/json-schema-draft4.json.cpp new file mode 100644 index 0000000..43bab6f --- /dev/null +++ b/3rdparty/tinygltf/examples/validator/src/json-schema-draft4.json.cpp @@ -0,0 +1,160 @@ +#include + +namespace nlohmann +{ +namespace json_schema_draft4 +{ + +json draft4_schema_builtin = R"( { + "id": "http://json-schema.org/draft-04/schema#", + "$schema": "http://json-schema.org/draft-04/schema#", + "description": "Core schema meta-schema", + "definitions": { + "schemaArray": { + "type": "array", + "minItems": 1, + "items": { "$ref": "#" } + }, + "positiveInteger": { + "type": "integer", + "minimum": 0 + }, + "positiveIntegerDefault0": { + "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ] + }, + "simpleTypes": { + "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ] + }, + "stringArray": { + "type": "array", + "items": { "type": "string" }, + "minItems": 1, + "uniqueItems": true + } + }, + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "uri" + }, + "$schema": { + "type": "string", + "format": "uri" + }, + "title": { + "type": "string" + }, + "description": { + "type": "string" + }, + "default": {}, + "multipleOf": { + "type": "number", + "minimum": 0, + "exclusiveMinimum": true + }, + "maximum": { + "type": "number" + }, + "exclusiveMaximum": { + "type": "boolean", + "default": false + }, + "minimum": { + "type": "number" + }, + "exclusiveMinimum": { + "type": "boolean", + "default": false + }, + "maxLength": { "$ref": "#/definitions/positiveInteger" }, + "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" }, + "pattern": { + "type": "string", + "format": "regex" + }, + "additionalItems": { + "anyOf": [ + { "type": "boolean" }, + { "$ref": "#" } + ], + "default": {} + }, + "items": { + "anyOf": [ + { "$ref": "#" }, + { "$ref": "#/definitions/schemaArray" } + ], + "default": {} + }, + "maxItems": { "$ref": "#/definitions/positiveInteger" }, + "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" }, + "uniqueItems": { + "type": "boolean", + "default": false + }, + "maxProperties": { "$ref": "#/definitions/positiveInteger" }, + "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" }, + "required": { "$ref": "#/definitions/stringArray" }, + "additionalProperties": { + "anyOf": [ + { "type": "boolean" }, + { "$ref": "#" } + ], + "default": {} + }, + "definitions": { + "type": "object", + "additionalProperties": { "$ref": "#" }, + "default": {} + }, + "properties": { + "type": "object", + "additionalProperties": { "$ref": "#" }, + "default": {} + }, + "patternProperties": { + "type": "object", + "additionalProperties": { "$ref": "#" }, + "default": {} + }, + "dependencies": { + "type": "object", + "additionalProperties": { + "anyOf": [ + { "$ref": "#" }, + { "$ref": "#/definitions/stringArray" } + ] + } + }, + "enum": { + "type": "array", + "minItems": 1, + "uniqueItems": true + }, + "type": { + "anyOf": [ + { "$ref": "#/definitions/simpleTypes" }, + { + "type": "array", + "items": { "$ref": "#/definitions/simpleTypes" }, + "minItems": 1, + "uniqueItems": true + } + ] + }, + "allOf": { "$ref": "#/definitions/schemaArray" }, + "anyOf": { "$ref": "#/definitions/schemaArray" }, + "oneOf": { "$ref": "#/definitions/schemaArray" }, + "not": { "$ref": "#" } + }, + "dependencies": { + "exclusiveMaximum": [ "maximum" ], + "exclusiveMinimum": [ "minimum" ] + }, + "default": {} +} )"_json; + +} +} diff --git a/3rdparty/tinygltf/examples/validator/src/json-schema.hpp b/3rdparty/tinygltf/examples/validator/src/json-schema.hpp new file mode 100644 index 0000000..51f521b --- /dev/null +++ b/3rdparty/tinygltf/examples/validator/src/json-schema.hpp @@ -0,0 +1,201 @@ +/* + * Modern C++ JSON schema validator + * + * Licensed under the MIT License . + * + * Copyright (c) 2016 Patrick Boettcher . + * + * 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_SCHEMA_HPP__ +#define NLOHMANN_JSON_SCHEMA_HPP__ + +#ifdef _WIN32 +# ifdef JSON_SCHEMA_VALIDATOR_EXPORTS +# define JSON_SCHEMA_VALIDATOR_API __declspec(dllexport) +# else +# define JSON_SCHEMA_VALIDATOR_API __declspec(dllimport) +# endif +#else +# define JSON_SCHEMA_VALIDATOR_API +#endif + +#include + +// make yourself a home - welcome to nlohmann's namespace +namespace nlohmann +{ + +// a class representing a JSON-pointer RFC6901 +// +// examples of JSON pointers +// +// # - root of the current document +// #item - refers to the object which is identified ("id") by `item` +// in the current document +// #/path/to/element +// - refers to the element in /path/to from the root-document +// +// +// The json_pointer-class stores everything in a string, which might seem bizarre +// as parsing is done from a string to a string, but from_string() is also +// doing some formatting. +// +// TODO +// ~ and % - codec +// needs testing and clarification regarding the '#' at the beginning + +class json_pointer +{ + std::string str_; + + void from_string(const std::string &r); + +public: + json_pointer(const std::string &s = "") + { + from_string(s); + } + + void append(const std::string &elem) + { + str_.append(elem); + } + + const std::string &to_string() const + { + return str_; + } +}; + +// A class representing a JSON-URI for schemas derived from +// section 8 of JSON Schema: A Media Type for Describing JSON Documents +// draft-wright-json-schema-00 +// +// New URIs can be derived from it using the derive()-method. +// This is useful for resolving refs or subschema-IDs in json-schemas. +// +// This is done implement the requirements described in section 8.2. +// +class JSON_SCHEMA_VALIDATOR_API json_uri +{ + std::string urn_; + + std::string proto_; + std::string hostname_; + std::string path_; + json_pointer pointer_; + +protected: + // decodes a JSON uri and replaces all or part of the currently stored values + void from_string(const std::string &uri); + + std::tuple tie() const + { + return std::tie(urn_, proto_, hostname_, path_, pointer_.to_string()); + } + +public: + json_uri(const std::string &uri) + { + from_string(uri); + } + + const std::string protocol() const { return proto_; } + const std::string hostname() const { return hostname_; } + const std::string path() const { return path_; } + const json_pointer pointer() const { return pointer_; } + + const std::string url() const; + + // decode and encode strings for ~ and % escape sequences + static std::string unescape(const std::string &); + static std::string escape(const std::string &); + + // create a new json_uri based in this one and the given uri + // resolves relative changes (pathes or pointers) and resets part if proto or hostname changes + json_uri derive(const std::string &uri) const + { + json_uri u = *this; + u.from_string(uri); + return u; + } + + // append a pointer-field to the pointer-part of this uri + json_uri append(const std::string &field) const + { + json_uri u = *this; + u.pointer_.append("/" + field); + return u; + } + + std::string to_string() const; + + friend bool operator<(const json_uri &l, const json_uri &r) + { + return l.tie() < r.tie(); + } + + friend bool operator==(const json_uri &l, const json_uri &r) + { + return l.tie() == r.tie(); + } + + friend std::ostream &operator<<(std::ostream &os, const json_uri &u); +}; + +namespace json_schema_draft4 +{ + +extern json draft4_schema_builtin; + +class JSON_SCHEMA_VALIDATOR_API json_validator +{ + std::vector> schema_store_; + std::shared_ptr root_schema_; + std::function schema_loader_ = nullptr; + std::function format_check_ = nullptr; + + std::map schema_refs_; + + void validate(const json &instance, const json &schema_, const std::string &name); + void validate_array(const json &instance, const json &schema_, const std::string &name); + void validate_object(const json &instance, const json &schema_, const std::string &name); + void validate_string(const json &instance, const json &schema, const std::string &name); + + void insert_schema(const json &input, const json_uri &id); + +public: + json_validator(std::function loader = nullptr, + std::function format = nullptr) + : schema_loader_(loader), format_check_(format) + { + } + + // insert and set a root-schema + void set_root_schema(const json &); + + // validate a json-document based on the root-schema + void validate(const json &instance); +}; + +} // json_schema_draft4 +} // nlohmann + +#endif /* NLOHMANN_JSON_SCHEMA_HPP__ */ diff --git a/3rdparty/tinygltf/examples/validator/src/json-uri.cpp b/3rdparty/tinygltf/examples/validator/src/json-uri.cpp new file mode 100644 index 0000000..2dc6113 --- /dev/null +++ b/3rdparty/tinygltf/examples/validator/src/json-uri.cpp @@ -0,0 +1,190 @@ +/* + * Modern C++ JSON schema validator + * + * Licensed under the MIT License . + * + * Copyright (c) 2016 Patrick Boettcher . + * + * 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. + */ +#include "json-schema.hpp" + +namespace nlohmann +{ + +void json_pointer::from_string(const std::string &r) +{ + str_ = "#"; + + if (r.size() == 0) + return; + + if (r[0] != '#') + throw std::invalid_argument("not a valid JSON pointer - missing # at the beginning"); + + if (r.size() == 1) + return; + + std::size_t pos = 1; + + do { + std::size_t next = r.find('/', pos + 1); + str_.append(r.substr(pos, next - pos)); + pos = next; + } while (pos != std::string::npos); +} + +void json_uri::from_string(const std::string &uri) +{ + // if it is an urn take it as it is - maybe there is more to be done + if (uri.find("urn:") == 0) { + urn_ = uri; + return; + } + + std::string pointer = "#"; // default pointer is the root + + // first split the URI into URL and JSON-pointer + auto pointer_separator = uri.find('#'); + if (pointer_separator != std::string::npos) // and extract the JSON-pointer-string if found + pointer = uri.substr(pointer_separator); + + // the rest is an URL + std::string url = uri.substr(0, pointer_separator); + if (url.size()) { // if an URL is part of the URI + + std::size_t pos = 0; + auto proto = url.find("://", pos); + if (proto != std::string::npos) { // extract the protocol + proto_ = url.substr(pos, proto - pos); + pos = 3 + proto; // 3 == "://" + + auto hostname = url.find("/", pos); + if (hostname != std::string::npos) { // and the hostname (no proto without hostname) + hostname_ = url.substr(pos, hostname - pos); + pos = hostname; + } + } + + // the rest is the path + auto path = url.substr(pos); + if (path[0] == '/') // if it starts with a / it is root-path + path_ = path; + else { // otherwise it is a subfolder + // HACK(syoyo): Force append '/' for glTF json schemas + path_ = path; + //path_.append(path); + } + + pointer_ = json_pointer(""); + } + + if (pointer.size() > 0) + pointer_ = pointer; +} + +const std::string json_uri::url() const +{ + std::stringstream s; + + if (proto_.size() > 0) + s << proto_ << "://"; + + s << hostname_ + << path_; + + return s.str(); +} + +std::string json_uri::to_string() const +{ + std::stringstream s; + + s << urn_ + << url() + << pointer_.to_string(); + + return s.str(); +} + +std::ostream &operator<<(std::ostream &os, const json_uri &u) +{ + return os << u.to_string(); +} + +std::string json_uri::unescape(const std::string &src) +{ + std::string l = src; + std::size_t pos = src.size() - 1; + + do { + pos = l.rfind('~', pos); + + if (pos == std::string::npos) + break; + + if (pos < l.size() - 1) { + switch (l[pos + 1]) { + case '0': + l.replace(pos, 2, "~"); + break; + + case '1': + l.replace(pos, 2, "/"); + break; + + default: + break; + } + } + + if (pos == 0) + break; + pos--; + } while (pos != std::string::npos); + + // TODO - percent handling + + return l; +} + +std::string json_uri::escape(const std::string &src) +{ + std::vector> chars = { + {"~", "~0"}, + {"/", "~1"}, + {"%", "%25"}}; + + std::string l = src; + + for (const auto &c : chars) { + std::size_t pos = 0; + do { + pos = l.find(c.first, pos); + if (pos == std::string::npos) + break; + l.replace(pos, 1, c.second); + pos += c.second.size(); + } while (1); + } + + return l; +} + +} // nlohmann diff --git a/3rdparty/tinygltf/examples/validator/src/json-validator.cpp b/3rdparty/tinygltf/examples/validator/src/json-validator.cpp new file mode 100644 index 0000000..3358805 --- /dev/null +++ b/3rdparty/tinygltf/examples/validator/src/json-validator.cpp @@ -0,0 +1,738 @@ +/* + * Modern C++ JSON schema validator + * + * Licensed under the MIT License . + * + * Copyright (c) 2016 Patrick Boettcher . + * + * 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. + */ +#include + +#include + +using nlohmann::json; +using nlohmann::json_uri; + +#ifdef JSON_SCHEMA_BOOST_REGEX + #include + #define REGEX_NAMESPACE boost +#elif defined(JSON_SCHEMA_NO_REGEX) + #define NO_STD_REGEX +#else + #include + #define REGEX_NAMESPACE std +#endif + +namespace +{ + +class resolver +{ + void resolve(json &schema, json_uri id) + { + // look for the id-field in this schema + auto fid = schema.find("id"); + + // found? + if (fid != schema.end() && + fid.value().type() == json::value_t::string) + id = id.derive(fid.value()); // resolve to a full id with URL + path based on the parent + + // already existing - error + if (schema_refs.find(id) != schema_refs.end()) + throw std::invalid_argument("schema " + id.to_string() + " already present in local resolver"); + + // store a raw pointer to this (sub-)schema referenced by its absolute json_uri + // this (sub-)schema is part of a schema stored inside schema_store_ so we can the a raw-pointer-ref + schema_refs[id] = &schema; + + for (auto i = schema.begin(), end = schema.end(); i != end; ++i) { + // FIXME: this inhibits the user adding properties with the key "default" + if (i.key() == "default") /* default value can be objects, but are not schemas */ + continue; + + switch (i.value().type()) { + + case json::value_t::object: // child is object, it is a schema + resolve(i.value(), id.append(json_uri::escape(i.key()))); + break; + + case json::value_t::array: { + std::size_t index = 0; + auto child_id = id.append(json_uri::escape(i.key())); + for (auto &v : i.value()) { + if (v.type() == json::value_t::object) // array element is object + resolve(v, child_id.append(std::to_string(index))); + index++; + } + } break; + + case json::value_t::string: + if (i.key() == "$ref") { + json_uri ref = id.derive(i.value()); + i.value() = ref.to_string(); + refs.insert(ref); + } + break; + + default: + break; + } + } + } + + std::set refs; + +public: + std::set undefined_refs; + + std::map schema_refs; + + resolver(json &schema, json_uri id) + { + // if schema has an id use it as name and to retrieve the namespace (URL) + auto fid = schema.find("id"); + if (fid != schema.end()) + id = id.derive(fid.value()); + + resolve(schema, id); + + // refs now contains all references + // + // local references should be resolvable inside the same URL + // + // undefined_refs will only contain external references + for (auto r : refs) { + if (schema_refs.find(r) == schema_refs.end()) { + if (r.url() == id.url()) // same url means referencing a sub-schema + // of the same document, which has not been found + throw std::invalid_argument("sub-schema " + r.pointer().to_string() + + " in schema " + id.to_string() + " not found"); + undefined_refs.insert(r.url()); + } + } + } +}; + +void validate_type(const json &schema, const std::string &expected_type, const std::string &name) +{ + const auto &type_it = schema.find("type"); + if (type_it == schema.end()) + /* TODO something needs to be done here, I think */ + return; + + const auto &type_instance = type_it.value(); + + // any of the types in this array + if (type_instance.type() == json::value_t::array) { + if ((std::find(type_instance.begin(), + type_instance.end(), + expected_type) != type_instance.end()) || + (expected_type == "integer" && + std::find(type_instance.begin(), + type_instance.end(), + "number") != type_instance.end())) + return; + + std::ostringstream s; + s << expected_type << " is not any of " << type_instance << " for " << name; + throw std::invalid_argument(s.str()); + + } else { // type_instance is a string + if (type_instance == expected_type || + (type_instance == "number" && expected_type == "integer")) + return; + + throw std::invalid_argument(name + " is " + expected_type + + ", but required type is " + type_instance.get()); + } +} + +void validate_enum(const json &instance, const json &schema, const std::string &name) +{ + const auto &enum_value = schema.find("enum"); + if (enum_value == schema.end()) + return; + + if (std::find(enum_value.value().begin(), enum_value.value().end(), instance) != enum_value.value().end()) + return; + + std::ostringstream s; + s << "invalid enum-value '" << instance << "' " + << "for instance '" << name << "'. Candidates are " << enum_value.value() << "."; + + throw std::invalid_argument(s.str()); +} + +void validate_boolean(const json & /*instance*/, const json &schema, const std::string &name) +{ + validate_type(schema, "boolean", name); +} + +void validate_numeric(const json &schema, const std::string &name, double value) +{ + // multipleOf - if the rest of the division is 0 -> OK + const auto &multipleOf = schema.find("multipleOf"); + if (multipleOf != schema.end()) { + if (multipleOf.value().get() != 0.0) { + + double v = value; + v /= multipleOf.value().get(); + + if (v != (double) (long) v) + throw std::out_of_range(name + " is not a multiple ..."); + } + } + + const auto &maximum = schema.find("maximum"); + if (maximum != schema.end()) { + double maxi = maximum.value(); + auto ex = std::out_of_range(name + " exceeds maximum of " + std::to_string(maxi)); + if (schema.find("exclusiveMaximum") != schema.end()) { + if (value >= maxi) + throw ex; + } else { + if (value > maxi) + throw ex; + } + } + + const auto &minimum = schema.find("minimum"); + if (minimum != schema.end()) { + double mini = minimum.value(); + auto ex = std::out_of_range(name + " exceeds minimum of " + std::to_string(mini)); + if (schema.find("exclusiveMinimum") != schema.end()) { + if (value <= mini) + throw ex; + } else { + if (value < mini) + throw ex; + } + } +} + +void validate_integer(const json &instance, const json &schema, const std::string &name) +{ + validate_type(schema, "integer", name); + validate_numeric(schema, name, instance.get()); +} + +void validate_unsigned(const json &instance, const json &schema, const std::string &name) +{ + validate_type(schema, "integer", name); + validate_numeric(schema, name, instance.get()); +} + +void validate_float(const json &instance, const json &schema, const std::string &name) +{ + validate_type(schema, "number", name); + validate_numeric(schema, name, instance.get()); +} + +void validate_null(const json & /*instance*/, const json &schema, const std::string &name) +{ + validate_type(schema, "null", name); +} + +} // anonymous namespace + +namespace nlohmann +{ +namespace json_schema_draft4 +{ + +void json_validator::insert_schema(const json &input, const json_uri &id) +{ + // allocate create a copy for later storage - if resolving reference works + std::shared_ptr schema = std::make_shared(input); + + do { + // resolve all local schemas and references + resolver r(*schema, id); + + // check whether all undefined schema references can be resolved with existing ones + std::set undefined; + for (auto &ref : r.undefined_refs) + if (schema_refs_.find(ref) == schema_refs_.end()) // exact schema reference not found + undefined.insert(ref); + + if (undefined.size() == 0) { // no undefined references + // now insert all schema-references + // check whether all schema-references are new + for (auto &sref : r.schema_refs) { + if (schema_refs_.find(sref.first) != schema_refs_.end()) + // HACK(syoyo): Skip duplicated schema. + break; + //throw std::invalid_argument("schema " + sref.first.to_string() + " already present in validator."); + } + // no undefined references and no duplicated schema - store the schema + schema_store_.push_back(schema); + + // and insert all references + schema_refs_.insert(r.schema_refs.begin(), r.schema_refs.end()); + + break; + } + + if (schema_loader_ == nullptr) + throw std::invalid_argument("schema contains undefined references to other schemas, needed schema-loader."); + + for (auto undef : undefined) { + json ext; + + schema_loader_(undef, ext); + insert_schema(ext, undef.url()); + } + } while (1); + + // store the document root-schema + if (id == json_uri("#")) + root_schema_ = schema; +} + +void json_validator::validate(const json &instance) +{ + if (root_schema_ == nullptr) + throw std::invalid_argument("no root-schema has been inserted. Cannot validate an instance without it."); + + validate(instance, *root_schema_, "root"); +} + +void json_validator::set_root_schema(const json &schema) +{ + insert_schema(schema, json_uri("#")); +} + +void json_validator::validate(const json &instance, const json &schema_, const std::string &name) +{ + const json *schema = &schema_; + + // $ref resolution + do { + const auto &ref = schema->find("$ref"); + if (ref == schema->end()) + break; + + auto it = schema_refs_.find(ref.value().get()); + + if (it == schema_refs_.end()) + throw std::invalid_argument("schema reference " + ref.value().get() + " not found. Make sure all schemas have been inserted before validation."); + + schema = it->second; + } while (1); // loop in case of nested refs + + // not + const auto attr = schema->find("not"); + if (attr != schema->end()) { + bool ok; + + try { + validate(instance, attr.value(), name); + ok = false; + } catch (std::exception &) { + ok = true; + } + if (!ok) + throw std::invalid_argument("schema match for " + name + " but a not-match is defined by schema."); + return; // return here - not cannot be mixed with based-schemas? + } + + // allOf, anyOf, oneOf + const json *combined_schemas = nullptr; + enum { + none, + allOf, + anyOf, + oneOf + } combine_logic = none; + + { + const auto &attr = schema->find("allOf"); + if (attr != schema->end()) { + combine_logic = allOf; + combined_schemas = &attr.value(); + } + } + { + const auto &attr = schema->find("anyOf"); + if (attr != schema->end()) { + combine_logic = anyOf; + combined_schemas = &attr.value(); + } + } + { + const auto &attr = schema->find("oneOf"); + if (attr != schema->end()) { + combine_logic = oneOf; + combined_schemas = &attr.value(); + } + } + + if (combine_logic != none) { + std::size_t count = 0; + std::ostringstream sub_schema_err; + + for (const auto &s : *combined_schemas) { + try { + validate(instance, s, name); + count++; + } catch (std::exception &e) { + sub_schema_err << " one schema failed because: " << e.what() << "\n"; + + if (combine_logic == allOf) + throw std::out_of_range("At least one schema has failed for " + name + " where allOf them were requested.\n" + sub_schema_err.str()); + } + if (combine_logic == oneOf && count > 1) + throw std::out_of_range("More than one schema has succeeded for " + name + " where only oneOf them was requested.\n" + sub_schema_err.str()); + } + if ((combine_logic == anyOf || combine_logic == oneOf) && count == 0) + throw std::out_of_range("No schema has succeeded for " + name + " but anyOf/oneOf them should have worked.\n" + sub_schema_err.str()); + } + + // check (base) schema + validate_enum(instance, *schema, name); + + switch (instance.type()) { + case json::value_t::object: + validate_object(instance, *schema, name); + break; + + case json::value_t::array: + validate_array(instance, *schema, name); + break; + + case json::value_t::string: + validate_string(instance, *schema, name); + break; + + case json::value_t::number_unsigned: + validate_unsigned(instance, *schema, name); + break; + + case json::value_t::number_integer: + validate_integer(instance, *schema, name); + break; + + case json::value_t::number_float: + validate_float(instance, *schema, name); + break; + + case json::value_t::boolean: + validate_boolean(instance, *schema, name); + break; + + case json::value_t::null: + validate_null(instance, *schema, name); + break; + + default: + assert(0 && "unexpected instance type for validation"); + break; + } +} + +void json_validator::validate_array(const json &instance, const json &schema, const std::string &name) +{ + validate_type(schema, "array", name); + + // maxItems + const auto &maxItems = schema.find("maxItems"); + if (maxItems != schema.end()) + if (instance.size() > maxItems.value().get()) + throw std::out_of_range(name + " has too many items."); + + // minItems + const auto &minItems = schema.find("minItems"); + if (minItems != schema.end()) + if (instance.size() < minItems.value().get()) + throw std::out_of_range(name + " has too few items."); + + // uniqueItems + const auto &uniqueItems = schema.find("uniqueItems"); + if (uniqueItems != schema.end()) + if (uniqueItems.value().get() == true) { + std::set array_to_set; + for (auto v : instance) { + auto ret = array_to_set.insert(v); + if (ret.second == false) + throw std::out_of_range(name + " should have only unique items."); + } + } + + // items and additionalItems + // default to empty schemas + auto items_iter = schema.find("items"); + json items = {}; + if (items_iter != schema.end()) + items = items_iter.value(); + + auto additionalItems_iter = schema.find("additionalItems"); + json additionalItems = {}; + if (additionalItems_iter != schema.end()) + additionalItems = additionalItems_iter.value(); + + size_t i = 0; + bool validation_done = false; + + for (auto &value : instance) { + std::string sub_name = name + "[" + std::to_string(i) + "]"; + + switch (items.type()) { + + case json::value_t::array: + + if (i < items.size()) + validate(value, items[i], sub_name); + else { + switch (additionalItems.type()) { // items is an array + // we need to take into consideration additionalItems + case json::value_t::object: + validate(value, additionalItems, sub_name); + break; + + case json::value_t::boolean: + if (additionalItems.get() == false) + throw std::out_of_range("additional values in array are not allowed for " + sub_name); + else + validation_done = true; + break; + + default: + break; + } + } + + break; + + case json::value_t::object: // items is a schema + validate(value, items, sub_name); + break; + + default: + break; + } + if (validation_done) + break; + + i++; + } +} + +void json_validator::validate_object(const json &instance, const json &schema, const std::string &name) +{ + validate_type(schema, "object", name); + + json properties = {}; + if (schema.find("properties") != schema.end()) + properties = schema["properties"]; + +#if 0 + // check for default values of properties + // and insert them into this object, if they don't exists + // works only for object properties for the moment + if (default_value_insertion) + for (auto it = properties.begin(); it != properties.end(); ++it) { + + const auto &default_value = it.value().find("default"); + if (default_value == it.value().end()) + continue; /* no default value -> continue */ + + if (instance.find(it.key()) != instance.end()) + continue; /* value is present */ + + /* create element from default value */ + instance[it.key()] = default_value.value(); + } +#endif + // maxProperties + const auto &maxProperties = schema.find("maxProperties"); + if (maxProperties != schema.end()) + if (instance.size() > maxProperties.value().get()) + throw std::out_of_range(name + " has too many properties."); + + // minProperties + const auto &minProperties = schema.find("minProperties"); + if (minProperties != schema.end()) + if (instance.size() < minProperties.value().get()) + throw std::out_of_range(name + " has too few properties."); + + // additionalProperties + enum { + True, + False, + Object + } additionalProperties = True; + + const auto &additionalPropertiesVal = schema.find("additionalProperties"); + if (additionalPropertiesVal != schema.end()) { + if (additionalPropertiesVal.value().type() == json::value_t::boolean) + additionalProperties = additionalPropertiesVal.value().get() == true ? True : False; + else + additionalProperties = Object; + } + + // patternProperties + json patternProperties = {}; + if (schema.find("patternProperties") != schema.end()) + patternProperties = schema["patternProperties"]; + + // check all elements in object + for (auto child = instance.begin(); child != instance.end(); ++child) { + std::string child_name = name + "." + child.key(); + + bool property_or_patternProperties_has_validated = false; + // is this a property which is described in the schema + const auto &object_prop = properties.find(child.key()); + if (object_prop != properties.end()) { + // validate the element with its schema + validate(child.value(), object_prop.value(), child_name); + property_or_patternProperties_has_validated = true; + } + + for (auto pp = patternProperties.begin(); + pp != patternProperties.end(); ++pp) { +#ifndef NO_STD_REGEX + REGEX_NAMESPACE::regex re(pp.key(), REGEX_NAMESPACE::regex::ECMAScript); + + if (REGEX_NAMESPACE::regex_search(child.key(), re)) { + validate(child.value(), pp.value(), child_name); + property_or_patternProperties_has_validated = true; + } +#else + // accept everything in case of a patternProperty + property_or_patternProperties_has_validated = true; + break; +#endif + } + + if (property_or_patternProperties_has_validated) + continue; + + switch (additionalProperties) { + case True: + break; + + case Object: + validate(child.value(), additionalPropertiesVal.value(), child_name); + break; + + case False: + throw std::invalid_argument("unknown property '" + child.key() + "' in object '" + name + "'"); + break; + }; + } + + // required + const auto &required = schema.find("required"); + if (required != schema.end()) + for (const auto &element : required.value()) { + if (instance.find(element) == instance.end()) { + throw std::invalid_argument("required element '" + element.get() + + "' not found in object '" + name + "'"); + } + } + + // dependencies + const auto &dependencies = schema.find("dependencies"); + if (dependencies == schema.end()) + return; + + for (auto dep = dependencies.value().cbegin(); + dep != dependencies.value().cend(); + ++dep) { + + // property not present in this instance - next + if (instance.find(dep.key()) == instance.end()) + continue; + + std::string sub_name = name + ".dependency-of-" + dep.key(); + + switch (dep.value().type()) { + + case json::value_t::object: + validate(instance, dep.value(), sub_name); + break; + + case json::value_t::array: + for (const auto &prop : dep.value()) + if (instance.find(prop) == instance.end()) + throw std::invalid_argument("failed dependency for " + sub_name + ". Need property " + prop.get()); + break; + + default: + break; + } + } +} + +static std::size_t utf8_length(const std::string &s) +{ + size_t len = 0; + for (const unsigned char &c : s) + if ((c & 0xc0) != 0x80) + len++; + return len; +} + +void json_validator::validate_string(const json &instance, const json &schema, const std::string &name) +{ + validate_type(schema, "string", name); + + // minLength + auto attr = schema.find("minLength"); + if (attr != schema.end()) + if (utf8_length(instance) < attr.value().get()) { + std::ostringstream s; + s << "'" << name << "' of value '" << instance << "' is too short as per minLength (" + << attr.value() << ")"; + throw std::out_of_range(s.str()); + } + + // maxLength + attr = schema.find("maxLength"); + if (attr != schema.end()) + if (utf8_length(instance) > attr.value().get()) { + std::ostringstream s; + s << "'" << name << "' of value '" << instance << "' is too long as per maxLength (" + << attr.value() << ")"; + throw std::out_of_range(s.str()); + } + +#ifndef NO_STD_REGEX + // pattern + attr = schema.find("pattern"); + if (attr != schema.end()) { + REGEX_NAMESPACE::regex re(attr.value().get(), REGEX_NAMESPACE::regex::ECMAScript); + if (!REGEX_NAMESPACE::regex_search(instance.get(), re)) + throw std::invalid_argument(instance.get() + " does not match regex pattern: " + attr.value().get() + " for " + name); + } +#endif + + // format + attr = schema.find("format"); + if (attr != schema.end()) { + if (format_check_ == nullptr) + throw std::logic_error("A format checker was not provided but a format-attribute for this string is present. " + + name + " cannot be validated for " + attr.value().get()); + format_check_(attr.value(), instance); + } +} +} +} diff --git a/3rdparty/tinygltf/examples/validator/src/json.hpp b/3rdparty/tinygltf/examples/validator/src/json.hpp new file mode 100644 index 0000000..6dfc183 --- /dev/null +++ b/3rdparty/tinygltf/examples/validator/src/json.hpp @@ -0,0 +1,13003 @@ +/* + __ _____ _____ _____ + __| | __| | | | JSON for Modern C++ +| | |__ | | | | | | version 2.1.1 +|_____|_____|_____|_|___| https://github.com/nlohmann/json + +Licensed under the MIT License . +Copyright (c) 2013-2017 Niels Lohmann . + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef NLOHMANN_JSON_HPP +#define NLOHMANN_JSON_HPP + +#include // all_of, copy, fill, find, for_each, none_of, remove, reverse, transform +#include // array +#include // assert +#include // isdigit +#include // and, not, or +#include // isfinite, labs, ldexp, signbit +#include // nullptr_t, ptrdiff_t, size_t +#include // int64_t, uint64_t +#include // abort, strtod, strtof, strtold, strtoul, strtoll, strtoull +#include // strlen +#include // forward_list +#include // function, hash, less +#include // initializer_list +#include // setw +#include // istream, ostream +#include // advance, begin, back_inserter, bidirectional_iterator_tag, distance, end, inserter, iterator, iterator_traits, next, random_access_iterator_tag, reverse_iterator +#include // numeric_limits +#include // locale +#include // map +#include // addressof, allocator, allocator_traits, unique_ptr +#include // accumulate +#include // stringstream +#include // domain_error, invalid_argument, out_of_range +#include // getline, stoi, string, to_string +#include // 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 // declval, forward, make_pair, move, pair, swap +#include // 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 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(lhs)] < + order[static_cast(rhs)]; +} + + +///////////// +// helpers // +///////////// + +// alias templates to reduce boilerplate +template +using enable_if_t = typename std::enable_if::type; + +template +using uncvref_t = typename std::remove_cv::type>::type; + +// taken from http://stackoverflow.com/a/26936864/266378 +template +using is_unscoped_enum = + std::integral_constant::value and + std::is_enum::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::value and has_value_type::value +will not compile when T = void (on MSVC at least). Whereas +conjunction>, has_value_type>::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 struct conjunction : std::true_type {}; +template struct conjunction : B1 {}; +template +struct conjunction : std::conditional, B1>::type {}; + +template struct negation : std::integral_constant < bool, !B::value > {}; + +// dispatch utility (taken from ranges-v3) +template struct priority_tag : priority_tag < N - 1 > {}; +template<> struct priority_tag<0> {}; + + +////////////////// +// constructors // +////////////////// + +template struct external_constructor; + +template<> +struct external_constructor +{ + template + 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 +{ + template + 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 +{ + template + 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 +{ + template + 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 +{ + template + 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 +{ + template + 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::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(begin(arr), end(arr)); + j.assert_invariant(); + } +}; + +template<> +struct external_constructor +{ + template + 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::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(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 struct has_##type { \ + private: \ + template \ + static int detect(U &&); \ + static void detect(...); \ + public: \ + static constexpr bool value = \ + std::is_integral()))>::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 +struct is_compatible_object_type_impl : std::false_type {}; + +template +struct is_compatible_object_type_impl +{ + static constexpr auto value = + std::is_constructible::value and + std::is_constructible::value; +}; + +template +struct is_compatible_object_type +{ + static auto constexpr value = is_compatible_object_type_impl < + conjunction>, + has_mapped_type, + has_key_type>::value, + typename BasicJsonType::object_t, CompatibleObjectType >::value; +}; + +template +struct is_basic_json_nested_type +{ + static auto constexpr value = std::is_same::value or + std::is_same::value or + std::is_same::value or + std::is_same::value or + std::is_same::value; +}; + +template +struct is_compatible_array_type +{ + static auto constexpr value = + conjunction>, + negation>, + negation>, + negation>, + has_value_type, + has_iterator>::value; +}; + +template +struct is_compatible_integer_type_impl : std::false_type {}; + +template +struct is_compatible_integer_type_impl +{ + // is there an assert somewhere on overflows? + using RealLimits = std::numeric_limits; + using CompatibleLimits = std::numeric_limits; + + static constexpr auto value = + std::is_constructible::value and + CompatibleLimits::is_integer and + RealLimits::is_signed == CompatibleLimits::is_signed; +}; + +template +struct is_compatible_integer_type +{ + static constexpr auto value = + is_compatible_integer_type_impl < + std::is_integral::value and + not std::is_same::value, + RealIntegerType, CompatibleNumberIntegerType > ::value; +}; + + +// trait checking if JSONSerializer::from_json(json const&, udt&) exists +template +struct has_from_json +{ + private: + // also check the return type of from_json + template::from_json( + std::declval(), std::declval()))>::value>> + static int detect(U&&); + static void detect(...); + + public: + static constexpr bool value = std::is_integral>()))>::value; +}; + +// This trait checks if JSONSerializer::from_json(json const&) exists +// this overload is used for non-default-constructible user-defined-types +template +struct has_non_default_from_json +{ + private: + template < + typename U, + typename = enable_if_t::from_json(std::declval()))>::value >> + static int detect(U&&); + static void detect(...); + + public: + static constexpr bool value = std::is_integral>()))>::value; +}; + +// This trait checks if BasicJsonType::json_serializer::to_json exists +template +struct has_to_json +{ + private: + template::to_json( + std::declval(), std::declval()))> + static int detect(U&&); + static void detect(...); + + public: + static constexpr bool value = std::is_integral>()))>::value; +}; + + +///////////// +// to_json // +///////////// + +template::value, int> = 0> +void to_json(BasicJsonType& j, T b) noexcept +{ + external_constructor::construct(j, b); +} + +template::value, int> = 0> +void to_json(BasicJsonType& j, const CompatibleString& s) +{ + external_constructor::construct(j, s); +} + +template::value, int> = 0> +void to_json(BasicJsonType& j, FloatType val) noexcept +{ + external_constructor::construct(j, static_cast(val)); +} + +template < + typename BasicJsonType, typename CompatibleNumberUnsignedType, + enable_if_t::value, int> = 0 > +void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept +{ + external_constructor::construct(j, static_cast(val)); +} + +template < + typename BasicJsonType, typename CompatibleNumberIntegerType, + enable_if_t::value, int> = 0 > +void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept +{ + external_constructor::construct(j, static_cast(val)); +} + +template::value, int> = 0> +void to_json(BasicJsonType& j, UnscopedEnumType e) noexcept +{ + external_constructor::construct(j, e); +} + +template < + typename BasicJsonType, typename CompatibleArrayType, + enable_if_t < + is_compatible_array_type::value or + std::is_same::value, + int > = 0 > +void to_json(BasicJsonType& j, const CompatibleArrayType& arr) +{ + external_constructor::construct(j, arr); +} + +template < + typename BasicJsonType, typename CompatibleObjectType, + enable_if_t::value, + int> = 0 > +void to_json(BasicJsonType& j, const CompatibleObjectType& arr) +{ + external_constructor::construct(j, arr); +} + + +/////////////// +// from_json // +/////////////// + +// overloads for basic_json template parameters +template::value and + not std::is_same::value, + int> = 0> +void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val) +{ + switch (static_cast(j)) + { + case value_t::number_unsigned: + { + val = static_cast( + *j.template get_ptr()); + break; + } + case value_t::number_integer: + { + val = static_cast( + *j.template get_ptr()); + break; + } + case value_t::number_float: + { + val = static_cast( + *j.template get_ptr()); + break; + } + default: + { + JSON_THROW( + std::domain_error("type must be number, but is " + j.type_name())); + } + } +} + +template +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(); +} + +template +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(); +} + +template +void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val) +{ + get_arithmetic_value(j, val); +} + +template +void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val) +{ + get_arithmetic_value(j, val); +} + +template +void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val) +{ + get_arithmetic_value(j, val); +} + +template::value, int> = 0> +void from_json(const BasicJsonType& j, UnscopedEnumType& e) +{ + typename std::underlying_type::type val; + get_arithmetic_value(j, val); + e = static_cast(val); +} + +template +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(); +} + +// forward_list doesn't have an insert method +template +void from_json(const BasicJsonType& j, std::forward_list& 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::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()); + } +} + +template +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() returns *this, this won't call a from_json + // method when value_type is BasicJsonType + return i.template get(); + }); +} + +template +auto from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<1>) +-> decltype( + arr.reserve(std::declval()), + 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() returns *this, this won't call a from_json + // method when value_type is BasicJsonType + return i.template get(); + }); +} + +template::value and + not std::is_same::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::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::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(); + 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::value and + not std::is_same::value and + not std::is_same::value and + not std::is_same::value and + not std::is_same::value, + int> = 0> +void from_json(const BasicJsonType& j, ArithmeticType& val) +{ + switch (static_cast(j)) + { + case value_t::number_unsigned: + { + val = static_cast(*j.template get_ptr()); + break; + } + case value_t::number_integer: + { + val = static_cast(*j.template get_ptr()); + break; + } + case value_t::number_float: + { + val = static_cast(*j.template get_ptr()); + break; + } + case value_t::boolean: + { + val = static_cast(*j.template get_ptr()); + break; + } + default: + { + JSON_THROW(std::domain_error("type must be number, but is " + j.type_name())); + } + } +} + +struct to_json_fn +{ + private: + template + auto call(BasicJsonType& j, T&& val, priority_tag<1>) const noexcept(noexcept(to_json(j, std::forward(val)))) + -> decltype(to_json(j, std::forward(val)), void()) + { + return to_json(j, std::forward(val)); + } + + template + 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 + void operator()(BasicJsonType& j, T&& val) const + noexcept(noexcept(std::declval().call(j, std::forward(val), priority_tag<1> {}))) + { + return call(j, std::forward(val), priority_tag<1> {}); + } +}; + +struct from_json_fn +{ + private: + template + 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 + 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 + void operator()(const BasicJsonType& j, T& val) const + noexcept(noexcept(std::declval().call(j, val, priority_tag<1> {}))) + { + return call(j, val, priority_tag<1> {}); + } +}; + +// taken from ranges-v3 +template +struct static_const +{ + static constexpr T value{}; +}; + +template +constexpr T static_const::value; +} // namespace detail + + +/// namespace to hold default `to_json` / `from_json` functions +namespace +{ +constexpr const auto& to_json = detail::static_const::value; +constexpr const auto& from_json = detail::static_const::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 +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 + static void from_json(BasicJsonType&& j, ValueType& val) noexcept( + noexcept(::nlohmann::from_json(std::forward(j), val))) + { + ::nlohmann::from_json(std::forward(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 + static void to_json(BasicJsonType& j, ValueType&& val) noexcept( + noexcept(::nlohmann::to_json(j, std::forward(val)))) + { + ::nlohmann::to_json(j, std::forward(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 class ObjectType = std::map, + template 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 class AllocatorType = std::allocator, + template class JSONSerializer = adl_serializer + > +class basic_json +{ + private: + template friend struct detail::external_constructor; + /// workaround type for MSVC + using basic_json_t = basic_json; + + public: + using value_t = detail::value_t; + // forward declarations + template class iter_impl; + template class json_reverse_iterator; + class json_pointer; + template + using json_serializer = JSONSerializer; + + ///////////////////// + // 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; + + /// the type of an element pointer + using pointer = typename std::allocator_traits::pointer; + /// the type of an element const pointer + using const_pointer = typename std::allocator_traits::const_pointer; + + /// an iterator for a basic_json container + using iterator = iter_impl; + /// a const iterator for a basic_json container + using const_iterator = iter_impl; + /// a reverse iterator for a basic_json container + using reverse_iterator = json_reverse_iterator; + /// a const reverse iterator for a basic_json container + using const_reverse_iterator = json_reverse_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` 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, // key_compare + std::allocator> // 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, + AllocatorType>>; + + /*! + @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 // 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>; + + /*! + @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 + static T* create(Args&& ... args) + { + AllocatorType alloc; + auto deleter = [&](T * object) + { + alloc.deallocate(object, 1); + }; + std::unique_ptr object(alloc.allocate(1), deleter); + alloc.construct(object.get(), std::forward(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(); + break; + } + + case value_t::array: + { + array = create(); + break; + } + + case value_t::string: + { + string = create(""); + 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(value); + } + + /// constructor for objects + json_value(const object_t& value) + { + object = create(value); + } + + /// constructor for arrays + json_value(const array_t& value) + { + array = create(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; + + + ////////////////// + // 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::to_json` method + with `U = uncvref_t`, 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 has a + `to_json(basic_json_t&, CompatibleType&&)` method + + @tparam U = `uncvref_t` + + @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::to_json()` throws + + @liveexample{The following code shows the constructor with several + compatible types.,basic_json__CompatibleType} + + @since version 2.1.0 + */ + template, + detail::enable_if_t::value and + not std::is_same::value and + not detail::is_basic_json_nested_type< + basic_json_t, U>::value and + detail::has_to_json::value, + int> = 0> + basic_json(CompatibleType && val) noexcept(noexcept(JSONSerializer::to_json( + std::declval(), std::forward(val)))) + { + JSONSerializer::to_json(*this, std::forward(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) + with an empty initializer list in this case + - arrays whose elements satisfy rule 2: use @ref + array(std::initializer_list) 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) and + @ref object(std::initializer_list). + + @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) -- create a JSON array + value from an initializer list + @sa @ref object(std::initializer_list) -- create a JSON object + value from an initializer list + + @since version 1.0.0 + */ + basic_json(std::initializer_list 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(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, 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, bool, value_t) -- + create a JSON value from an initializer list + @sa @ref object(std::initializer_list) -- create a JSON object + value from an initializer list + + @since version 1.0.0 + */ + static basic_json array(std::initializer_list init = + std::initializer_list()) + { + 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), 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, 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, 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, bool, value_t) -- + create a JSON value from an initializer list + @sa @ref array(std::initializer_list) -- create a JSON array + value from an initializer list + + @since version 1.0.0 + */ + static basic_json object(std::initializer_list init = + std::initializer_list()) + { + 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(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::value or + std::is_same::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(first.m_it.object_iterator, + last.m_it.object_iterator); + break; + } + + case value_t::array: + { + m_value.array = create(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 and + std::is_nothrow_move_assignable::value and + std::is_nothrow_move_constructible::value and + std::is_nothrow_move_assignable::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 alloc; + alloc.destroy(m_value.object); + alloc.deallocate(m_value.object, 1); + break; + } + + case value_t::array: + { + AllocatorType alloc; + alloc.destroy(m_value.array); + alloc.deallocate(m_value.array, 1); + break; + } + + case value_t::string: + { + AllocatorType 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(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 + static ReferenceType get_ref_impl(ThisType& obj) + { + // helper type + using PointerType = typename std::add_pointer::type; + + // delegate the call to get_ptr<>() + auto ptr = obj.template get_ptr(); + + 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::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 + `from_json()` method. + + The function is equivalent to executing + @code {.cpp} + ValueType ret; + JSONSerializer::from_json(*this, ret); + return ret; + @endcode + + This overloads is chosen if: + - @a ValueType is not @ref basic_json, + - @ref json_serializer has a `from_json()` method of the form + `void from_json(const @ref basic_json&, ValueType&)`, and + - @ref json_serializer 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 `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`\, (3) A JSON object can be converted to C++ + associative containers such as `std::unordered_map`.,get__ValueType_const} + + @since version 2.1.0 + */ + template < + typename ValueTypeCV, + typename ValueType = detail::uncvref_t, + detail::enable_if_t < + not std::is_same::value and + detail::has_from_json::value and + not detail::has_non_default_from_json::value, + int > = 0 > + ValueType get() const noexcept(noexcept( + JSONSerializer::from_json(std::declval(), std::declval()))) + { + // we cannot static_assert on ValueTypeCV being non-const, because + // there is support for get(), which is why we + // still need the uncvref + static_assert(not std::is_reference::value, + "get() cannot be used with reference types, you might want to use get_ref()"); + static_assert(std::is_default_constructible::value, + "types must be DefaultConstructible when used with get()"); + + ValueType ret; + JSONSerializer::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 + `from_json()` method. + + The function is equivalent to executing + @code {.cpp} + return JSONSerializer::from_json(*this); + @endcode + + This overloads is chosen if: + - @a ValueType is not @ref basic_json and + - @ref json_serializer has a `from_json()` method of the form + `ValueType from_json(const @ref basic_json&)` + + @note If @ref json_serializer 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 `from_json()` method throws + + @since version 2.1.0 + */ + template < + typename ValueTypeCV, + typename ValueType = detail::uncvref_t, + detail::enable_if_t::value and + detail::has_non_default_from_json::value, int> = 0 > + ValueType get() const noexcept(noexcept( + JSONSerializer::from_json(std::declval()))) + { + static_assert(not std::is_reference::value, + "get() cannot be used with reference types, you might want to use get_ref()"); + return JSONSerializer::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::value, int>::type = 0> + PointerType get() noexcept + { + // delegate the call to get_ptr + return get_ptr(); + } + + /*! + @brief get a pointer value (explicit) + @copydoc get() + */ + template::value, int>::type = 0> + constexpr const PointerType get() const noexcept + { + // delegate the call to get_ptr + return get_ptr(); + } + + /*! + @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::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::type>::type>::type; + // make sure the type matches the allowed types + static_assert( + std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + , "incompatible pointer type"); + + // delegate the call to get_impl_ptr<>() + return get_impl_ptr(static_cast(nullptr)); + } + + /*! + @brief get a pointer value (implicit) + @copydoc get_ptr() + */ + template::value and + std::is_const::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::type>::type>::type; + // make sure the type matches the allowed types + static_assert( + std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + , "incompatible pointer type"); + + // delegate the call to get_impl_ptr<>() const + return get_impl_ptr(static_cast(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::value, int>::type = 0> + ReferenceType get_ref() + { + // delegate call to get_ref_impl + return get_ref_impl(*this); + } + + /*! + @brief get a reference value (implicit) + @copydoc get_ref() + */ + template::value and + std::is_const::type>::value, int>::type = 0> + ReferenceType get_ref() const + { + // delegate call to get_ref_impl + return get_ref_impl(*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`\, (3) A JSON object can be converted to C++ + associative containers such as `std::unordered_map`.,operator__ValueType} + + @since version 1.0.0 + */ + template < typename ValueType, typename std::enable_if < + not std::is_pointer::value and + not std::is_same::value +#ifndef _MSC_VER // fix for issue #167 operator<< ambiguity under VS2015 + and not std::is_same>::value +#endif + , int >::type = 0 > + operator ValueType() const + { + // delegate the call to get<>() const + return get(); + } + + /// @} + + + //////////////////// + // 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(); + 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(); + 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 + reference operator[](T * (&key)[n]) + { + return operator[](static_cast(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 + const_reference operator[](T * (&key)[n]) const + { + return operator[](static_cast(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 + 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 + 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::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::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::value or + std::is_same::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 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::value or + std::is_same::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 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(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(*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(*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(*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(*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 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_wrapper(reference cont) + { + return iteration_proxy(cont); + } + + /*! + @copydoc iterator_wrapper(reference) + */ + static iteration_proxy iterator_wrapper(const_reference cont) + { + return iteration_proxy(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`, 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 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) + */ + reference operator+=(std::initializer_list 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 + 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)...); + } + + /*! + @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 + std::pair 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)...); + // 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 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 and + std::is_nothrow_move_assignable::value and + std::is_nothrow_move_constructible::value and + std::is_nothrow_move_assignable::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(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(rhs.m_value.number_integer); + } + else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float) + { + return static_cast(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(rhs.m_value.number_unsigned); + } + else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer) + { + return static_cast(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(rhs.m_value.number_unsigned); + } + + return false; + } + + /*! + @brief comparison: equal + @copydoc operator==(const_reference, const_reference) + */ + template::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::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::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::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(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(rhs.m_value.number_integer); + } + else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float) + { + return static_cast(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(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(rhs.m_value.number_unsigned); + } + else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer) + { + return static_cast(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(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 + 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::value and + std::is_integral::type>::value and + sizeof(typename std::remove_pointer::type) == 1, int>::type = 0> + static basic_json parse(const CharT s, + const parser_callback_t cb = nullptr) + { + return parser(reinterpret_cast(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::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(true, 0), + [&first](std::pair 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::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::value and + std::is_base_of< + std::random_access_iterator_tag, + typename std::iterator_traits()))>::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 + static void add_to_vector(std::vector& 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((static_cast(number) >> 070) & 0xff)); + vec.push_back(static_cast((static_cast(number) >> 060) & 0xff)); + vec.push_back(static_cast((static_cast(number) >> 050) & 0xff)); + vec.push_back(static_cast((static_cast(number) >> 040) & 0xff)); + vec.push_back(static_cast((number >> 030) & 0xff)); + vec.push_back(static_cast((number >> 020) & 0xff)); + vec.push_back(static_cast((number >> 010) & 0xff)); + vec.push_back(static_cast(number & 0xff)); + break; + } + + case 4: + { + vec.push_back(static_cast((number >> 030) & 0xff)); + vec.push_back(static_cast((number >> 020) & 0xff)); + vec.push_back(static_cast((number >> 010) & 0xff)); + vec.push_back(static_cast(number & 0xff)); + break; + } + + case 2: + { + vec.push_back(static_cast((number >> 010) & 0xff)); + vec.push_back(static_cast(number & 0xff)); + break; + } + + case 1: + { + vec.push_back(static_cast(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 . + */ + template + static T get_from_vector(const std::vector& 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(&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& 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::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::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::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::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::min() and j.m_value.number_integer <= std::numeric_limits::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::min() and j.m_value.number_integer <= std::numeric_limits::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::min() and j.m_value.number_integer <= std::numeric_limits::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::min() and j.m_value.number_integer <= std::numeric_limits::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::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::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::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::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(&(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(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(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(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& 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::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::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::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(0x20 + positive_number)); + } + else if (positive_number <= std::numeric_limits::max()) + { + // int 8 + v.push_back(0x38); + add_to_vector(v, 1, positive_number); + } + else if (positive_number <= std::numeric_limits::max()) + { + // int 16 + v.push_back(0x39); + add_to_vector(v, 2, positive_number); + } + else if (positive_number <= std::numeric_limits::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(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(&(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(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(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(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::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& 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(v.data()) + offset, len); + } + } + else if (v[current_idx] >= 0xe0) // negative fixint + { + return static_cast(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(&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(&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(v, current_idx); + } + + case 0xcd: // uint 16 + { + idx += 2; // skip 2 content bytes + return get_from_vector(v, current_idx); + } + + case 0xce: // uint 32 + { + idx += 4; // skip 4 content bytes + return get_from_vector(v, current_idx); + } + + case 0xcf: // uint 64 + { + idx += 8; // skip 8 content bytes + return get_from_vector(v, current_idx); + } + + case 0xd0: // int 8 + { + idx += 1; // skip content byte + return get_from_vector(v, current_idx); + } + + case 0xd1: // int 16 + { + idx += 2; // skip 2 content bytes + return get_from_vector(v, current_idx); + } + + case 0xd2: // int 32 + { + idx += 4; // skip 4 content bytes + return get_from_vector(v, current_idx); + } + + case 0xd3: // int 64 + { + idx += 8; // skip 8 content bytes + return get_from_vector(v, current_idx); + } + + case 0xd9: // str 8 + { + const auto len = static_cast(get_from_vector(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(v.data()) + offset, len); + } + + case 0xda: // str 16 + { + const auto len = static_cast(get_from_vector(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(v.data()) + offset, len); + } + + case 0xdb: // str 32 + { + const auto len = static_cast(get_from_vector(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(v.data()) + offset, len); + } + + case 0xdc: // array 16 + { + basic_json result = value_t::array; + const auto len = static_cast(get_from_vector(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(get_from_vector(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(get_from_vector(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(get_from_vector(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(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& 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(v, current_idx); + } + + case 0x19: // Unsigned integer (two-byte uint16_t follows) + { + idx += 2; // skip 2 content bytes + return get_from_vector(v, current_idx); + } + + case 0x1a: // Unsigned integer (four-byte uint32_t follows) + { + idx += 4; // skip 4 content bytes + return get_from_vector(v, current_idx); + } + + case 0x1b: // Unsigned integer (eight-byte uint64_t follows) + { + idx += 8; // skip 8 content bytes + return get_from_vector(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(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(-1) - get_from_vector(v, current_idx); + } + + case 0x39: // Negative integer -1-n (two-byte uint16_t follows) + { + idx += 2; // skip 2 content bytes + return static_cast(-1) - get_from_vector(v, current_idx); + } + + case 0x3a: // Negative integer -1-n (four-byte uint32_t follows) + { + idx += 4; // skip 4 content bytes + return static_cast(-1) - get_from_vector(v, current_idx); + } + + case 0x3b: // Negative integer -1-n (eight-byte uint64_t follows) + { + idx += 8; // skip 8 content bytes + return static_cast(-1) - static_cast(get_from_vector(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(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(v.data()) + offset, len); + } + + case 0x78: // UTF-8 string (one-byte uint8_t for n follows) + { + const auto len = static_cast(get_from_vector(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(v.data()) + offset, len); + } + + case 0x79: // UTF-8 string (two-byte uint16_t for n follow) + { + const auto len = static_cast(get_from_vector(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(v.data()) + offset, len); + } + + case 0x7a: // UTF-8 string (four-byte uint32_t for n follow) + { + const auto len = static_cast(get_from_vector(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(v.data()) + offset, len); + } + + case 0x7b: // UTF-8 string (eight-byte uint64_t for n follow) + { + const auto len = static_cast(get_from_vector(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(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(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(get_from_vector(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(get_from_vector(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(get_from_vector(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(get_from_vector(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(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(get_from_vector(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(get_from_vector(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(get_from_vector(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(get_from_vector(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::infinity() + : std::numeric_limits::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(&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(&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(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&, 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 to_msgpack(const basic_json& j) + { + std::vector 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&, 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& 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&, 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 to_cbor(const basic_json& j) + { + std::vector 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&, 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& 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 + numtostr(NumberType value) + { + x_write(value, std::is_integral()); + } + + const char* c_str() const + { + return m_buf.data(); + } + + private: + /// a (hopefully) large enough character buffer + std::array < char, 64 > m_buf{{}}; + + template + 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(x % 10)); + m_buf[i++] = static_cast('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 + 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::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(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 << ""; + 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::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 + 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 + class iter_impl : public std::iterator + { + /// 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::value + or std::is_same::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::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::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::value and + std::is_nothrow_move_assignable::value and + std::is_nothrow_move_constructible::value and + std::is_nothrow_move_assignable::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 + class json_reverse_iterator : public std::reverse_iterator + { + public: + /// shortcut to the reverse iterator adaptor + using base_iterator = std::reverse_iterator; + /// 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 + */ + 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(codepoint)); + } + else if (codepoint <= 0x7ff) + { + // 2-byte characters: 110xxxxx 10xxxxxx + result.append(1, static_cast(0xC0 | ((codepoint >> 6) & 0x1F))); + result.append(1, static_cast(0x80 | (codepoint & 0x3F))); + } + else if (codepoint <= 0xffff) + { + // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx + result.append(1, static_cast(0xE0 | ((codepoint >> 12) & 0x0F))); + result.append(1, static_cast(0x80 | ((codepoint >> 6) & 0x3F))); + result.append(1, static_cast(0x80 | (codepoint & 0x3F))); + } + else if (codepoint <= 0x10ffff) + { + // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + result.append(1, static_cast(0xF0 | ((codepoint >> 18) & 0x07))); + result.append(1, static_cast(0x80 | ((codepoint >> 12) & 0x3F))); + result.append(1, static_cast(0x80 | ((codepoint >> 6) & 0x3F))); + result.append(1, static_cast(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 ""; + 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 ""; + 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(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(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(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(m_start), + static_cast(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(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(*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(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 + (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::value>::type> + bool to(T& val) const + { + return parse(val, std::is_integral()); + } + + 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 + 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 + 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 buf; + const size_t len = static_cast(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(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(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 + 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()); + + // called right overload? + static_assert(std::is_signed() == std::is_signed(), ""); + + value = static_cast(x); + + return (x == static_cast(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(m_start), + reinterpret_cast(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(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::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(&(*first)), + static_cast(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(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(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(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(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(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 split(const std::string& reference_string) + { + std::vector 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 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(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(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(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(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::value and + is_nothrow_move_assignable::value + ) +{ + j1.swap(j2); +} + +/// hash value for JSON objects +template<> +struct hash +{ + /*! + @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(); + 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/3rdparty/tinygltf/json.hpp b/3rdparty/tinygltf/json.hpp new file mode 100644 index 0000000..e894130 --- /dev/null +++ b/3rdparty/tinygltf/json.hpp @@ -0,0 +1,14722 @@ +/* + __ _____ _____ _____ + __| | __| | | | JSON for Modern C++ +| | |__ | | | | | | version 2.1.1 +|_____|_____|_____|_|___| https://github.com/nlohmann/json + +Licensed under the MIT License . +Copyright (c) 2013-2017 Niels Lohmann . + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef NLOHMANN_JSON_HPP +#define NLOHMANN_JSON_HPP + +#include // all_of, copy, fill, find, for_each, generate_n, none_of, remove, reverse, transform +#include // array +#include // assert +#include // and, not, or +#include // lconv, localeconv +#include // isfinite, labs, ldexp, signbit +#include // nullptr_t, ptrdiff_t, size_t +#include // int64_t, uint64_t +#include // abort, strtod, strtof, strtold, strtoul, strtoll, strtoull +#include // memcpy, strlen +#include // forward_list +#include // function, hash, less +#include // initializer_list +#include // hex +#include // istream, ostream +#include // advance, begin, back_inserter, bidirectional_iterator_tag, distance, end, inserter, iterator, iterator_traits, next, random_access_iterator_tag, reverse_iterator +#include // numeric_limits +#include // locale +#include // map +#include // addressof, allocator, allocator_traits, unique_ptr +#include // accumulate +#include // stringstream +#include // getline, stoi, string, to_string +#include // 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 // declval, forward, make_pair, move, pair, swap +#include // valarray +#include // 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__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) + #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 (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && not defined(JSON_NOEXCEPTION) + #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 + +// manual branch prediction +#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__) + #define JSON_LIKELY(x) __builtin_expect(!!(x), 1) + #define JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) +#else + #define JSON_LIKELY(x) x + #define JSON_UNLIKELY(x) x +#endif + +// cpp language standard detection +#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 +#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) + #define JSON_HAS_CPP_14 +#endif + +/*! +@brief namespace for Niels Lohmann +@see https://github.com/nlohmann +@since version 1.0.0 +*/ +namespace nlohmann +{ +template +struct adl_serializer; + +// forward declaration of basic_json (required to split the class) +template class ObjectType = + std::map, + template 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 class AllocatorType = std::allocator, + template class JSONSerializer = + adl_serializer> +class basic_json; + +// Ugly macros to avoid uglier copy-paste when specializing basic_json +// This is only temporary and will be removed in 3.0 + +#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ + template class ObjectType, \ + template class ArrayType, \ + class StringType, class BooleanType, class NumberIntegerType, \ + class NumberUnsignedType, class NumberFloatType, \ + template class AllocatorType, \ + template class JSONSerializer> + +#define NLOHMANN_BASIC_JSON_TPL \ + basic_json + + +/*! +@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 +{ +//////////////// +// exceptions // +//////////////// + +/*! +@brief general exception of the @ref basic_json class + +This class is an extension of `std::exception` objects with a member @a id for +exception ids. It is used as the base class for all exceptions thrown by the +@ref basic_json class. This class can hence be used as "wildcard" to catch +exceptions. + +Subclasses: +- @ref parse_error for exceptions indicating a parse error +- @ref invalid_iterator for exceptions indicating errors with iterators +- @ref type_error for exceptions indicating executing a member function with + a wrong type +- @ref out_of_range for exceptions indicating access out of the defined range +- @ref other_error for exceptions indicating other library errors + +@internal +@note To have nothrow-copy-constructible exceptions, we internally use + `std::runtime_error` which can cope with arbitrary-length error messages. + Intermediate strings are built with static functions and then passed to + the actual constructor. +@endinternal + +@liveexample{The following code shows how arbitrary library exceptions can be +caught.,exception} + +@since version 3.0.0 +*/ +class exception : public std::exception +{ + public: + /// returns the explanatory string + const char* what() const noexcept override + { + return m.what(); + } + + /// the id of the exception + const int id; + + protected: + exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} + + static std::string name(const std::string& ename, int id_) + { + return "[json.exception." + ename + "." + std::to_string(id_) + "] "; + } + + private: + /// an exception object as storage for error messages + std::runtime_error m; +}; + +/*! +@brief exception indicating a parse error + +This excpetion is thrown by the library when a parse error occurs. Parse errors +can occur during the deserialization of JSON text, CBOR, MessagePack, as well +as when using JSON Patch. + +Member @a byte holds the byte index of the last read character in the input +file. + +Exceptions have ids 1xx. + +name / id | example message | description +------------------------------ | --------------- | ------------------------- +json.exception.parse_error.101 | parse error at 2: unexpected end of input; expected string literal | This error indicates a syntax error while deserializing a JSON text. The error message describes that an unexpected token (character) was encountered, and the member @a byte indicates the error position. +json.exception.parse_error.102 | parse error at 14: missing or wrong low surrogate | JSON uses the `\uxxxx` format to describe Unicode characters. Code points above above 0xFFFF are split into two `\uxxxx` entries ("surrogate pairs"). This error indicates that the surrogate pair is incomplete or contains an invalid code point. +json.exception.parse_error.103 | parse error: code points above 0x10FFFF are invalid | Unicode supports code points up to 0x10FFFF. Code points above 0x10FFFF are invalid. +json.exception.parse_error.104 | parse error: JSON patch must be an array of objects | [RFC 6902](https://tools.ietf.org/html/rfc6902) requires a JSON Patch document to be a JSON document that represents an array of objects. +json.exception.parse_error.105 | parse error: operation must have string member 'op' | An operation of a JSON Patch document must contain exactly one "op" member, whose value indicates the operation to perform. Its value must be one of "add", "remove", "replace", "move", "copy", or "test"; other values are errors. +json.exception.parse_error.106 | parse error: array index '01' must not begin with '0' | An array index in a JSON Pointer ([RFC 6901](https://tools.ietf.org/html/rfc6901)) may be `0` or any number wihtout a leading `0`. +json.exception.parse_error.107 | parse error: JSON pointer must be empty or begin with '/' - was: 'foo' | A JSON Pointer must be a Unicode string containing a sequence of zero or more reference tokens, each prefixed by a `/` character. +json.exception.parse_error.108 | parse error: escape character '~' must be followed with '0' or '1' | In a JSON Pointer, only `~0` and `~1` are valid escape sequences. +json.exception.parse_error.109 | parse error: array index 'one' is not a number | A JSON Pointer array index must be a number. +json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vector | When parsing CBOR or MessagePack, the byte vector ends before the complete value has been read. +json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xf8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read. +json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read. + +@note For an input with n bytes, 1 is the index of the first character and n+1 + is the index of the terminating null byte or the end of file. This also + holds true when reading a byte vector (CBOR or MessagePack). + +@liveexample{The following code shows how a `parse_error` exception can be +caught.,parse_error} + +@sa @ref exception for the base class of the library exceptions +@sa @ref invalid_iterator for exceptions indicating errors with iterators +@sa @ref type_error for exceptions indicating executing a member function with + a wrong type +@sa @ref out_of_range for exceptions indicating access out of the defined range +@sa @ref other_error for exceptions indicating other library errors + +@since version 3.0.0 +*/ +class parse_error : public exception +{ + public: + /*! + @brief create a parse error exception + @param[in] id_ the id of the exception + @param[in] byte_ the byte index where the error occurred (or 0 if the + position cannot be determined) + @param[in] what_arg the explanatory string + @return parse_error object + */ + static parse_error create(int id_, std::size_t byte_, const std::string& what_arg) + { + std::string w = exception::name("parse_error", id_) + "parse error" + + (byte_ != 0 ? (" at " + std::to_string(byte_)) : "") + + ": " + what_arg; + return parse_error(id_, byte_, w.c_str()); + } + + /*! + @brief byte index of the parse error + + The byte index of the last read character in the input file. + + @note For an input with n bytes, 1 is the index of the first character and + n+1 is the index of the terminating null byte or the end of file. + This also holds true when reading a byte vector (CBOR or MessagePack). + */ + const std::size_t byte; + + private: + parse_error(int id_, std::size_t byte_, const char* what_arg) + : exception(id_, what_arg), byte(byte_) {} +}; + +/*! +@brief exception indicating errors with iterators + +This exception is thrown if iterators passed to a library function do not match +the expected semantics. + +Exceptions have ids 2xx. + +name / id | example message | description +----------------------------------- | --------------- | ------------------------- +json.exception.invalid_iterator.201 | iterators are not compatible | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid. +json.exception.invalid_iterator.202 | iterator does not fit current value | In an erase or insert function, the passed iterator @a pos does not belong to the JSON value for which the function was called. It hence does not define a valid position for the deletion/insertion. +json.exception.invalid_iterator.203 | iterators do not fit current value | Either iterator passed to function @ref erase(IteratorType first, IteratorType last) does not belong to the JSON value from which values shall be erased. It hence does not define a valid range to delete values from. +json.exception.invalid_iterator.204 | iterators out of range | When an iterator range for a primitive type (number, boolean, or string) is passed to a constructor or an erase function, this range has to be exactly (@ref begin(), @ref end()), because this is the only way the single stored value is expressed. All other ranges are invalid. +json.exception.invalid_iterator.205 | iterator out of range | When an iterator for a primitive type (number, boolean, or string) is passed to an erase function, the iterator has to be the @ref begin() iterator, because it is the only way to address the stored value. All other iterators are invalid. +json.exception.invalid_iterator.206 | cannot construct with iterators from null | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) belong to a JSON null value and hence to not define a valid range. +json.exception.invalid_iterator.207 | cannot use key() for non-object iterators | The key() member function can only be used on iterators belonging to a JSON object, because other types do not have a concept of a key. +json.exception.invalid_iterator.208 | cannot use operator[] for object iterators | The operator[] to specify a concrete offset cannot be used on iterators belonging to a JSON object, because JSON objects are unordered. +json.exception.invalid_iterator.209 | cannot use offsets with object iterators | The offset operators (+, -, +=, -=) cannot be used on iterators belonging to a JSON object, because JSON objects are unordered. +json.exception.invalid_iterator.210 | iterators do not fit | The iterator range passed to the insert function are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid. +json.exception.invalid_iterator.211 | passed iterators may not belong to container | The iterator range passed to the insert function must not be a subrange of the container to insert to. +json.exception.invalid_iterator.212 | cannot compare iterators of different containers | When two iterators are compared, they must belong to the same container. +json.exception.invalid_iterator.213 | cannot compare order of object iterators | The order of object iterators cannot be compared, because JSON objects are unordered. +json.exception.invalid_iterator.214 | cannot get value | Cannot get value for iterator: Either the iterator belongs to a null value or it is an iterator to a primitive type (number, boolean, or string), but the iterator is different to @ref begin(). + +@liveexample{The following code shows how an `invalid_iterator` exception can be +caught.,invalid_iterator} + +@sa @ref exception for the base class of the library exceptions +@sa @ref parse_error for exceptions indicating a parse error +@sa @ref type_error for exceptions indicating executing a member function with + a wrong type +@sa @ref out_of_range for exceptions indicating access out of the defined range +@sa @ref other_error for exceptions indicating other library errors + +@since version 3.0.0 +*/ +class invalid_iterator : public exception +{ + public: + static invalid_iterator create(int id_, const std::string& what_arg) + { + std::string w = exception::name("invalid_iterator", id_) + what_arg; + return invalid_iterator(id_, w.c_str()); + } + + private: + invalid_iterator(int id_, const char* what_arg) + : exception(id_, what_arg) {} +}; + +/*! +@brief exception indicating executing a member function with a wrong type + +This exception is thrown in case of a type error; that is, a library function is +executed on a JSON value whose type does not match the expected semantics. + +Exceptions have ids 3xx. + +name / id | example message | description +----------------------------- | --------------- | ------------------------- +json.exception.type_error.301 | cannot create object from initializer list | To create an object from an initializer list, the initializer list must consist only of a list of pairs whose first element is a string. When this constraint is violated, an array is created instead. +json.exception.type_error.302 | type must be object, but is array | During implicit or explicit value conversion, the JSON type must be compatible to the target type. For instance, a JSON string can only be converted into string types, but not into numbers or boolean types. +json.exception.type_error.303 | incompatible ReferenceType for get_ref, actual type is object | To retrieve a reference to a value stored in a @ref basic_json object with @ref get_ref, the type of the reference must match the value type. For instance, for a JSON array, the @a ReferenceType must be @ref array_t&. +json.exception.type_error.304 | cannot use at() with string | The @ref at() member functions can only be executed for certain JSON types. +json.exception.type_error.305 | cannot use operator[] with string | The @ref operator[] member functions can only be executed for certain JSON types. +json.exception.type_error.306 | cannot use value() with string | The @ref value() member functions can only be executed for certain JSON types. +json.exception.type_error.307 | cannot use erase() with string | The @ref erase() member functions can only be executed for certain JSON types. +json.exception.type_error.308 | cannot use push_back() with string | The @ref push_back() and @ref operator+= member functions can only be executed for certain JSON types. +json.exception.type_error.309 | cannot use insert() with | The @ref insert() member functions can only be executed for certain JSON types. +json.exception.type_error.310 | cannot use swap() with number | The @ref swap() member functions can only be executed for certain JSON types. +json.exception.type_error.311 | cannot use emplace_back() with string | The @ref emplace_back() member function can only be executed for certain JSON types. +json.exception.type_error.312 | cannot use update() with string | The @ref update() member functions can only be executed for certain JSON types. +json.exception.type_error.313 | invalid value to unflatten | The @ref unflatten function converts an object whose keys are JSON Pointers back into an arbitrary nested JSON value. The JSON Pointers must not overlap, because then the resulting value would not be well defined. +json.exception.type_error.314 | only objects can be unflattened | The @ref unflatten function only works for an object whose keys are JSON Pointers. +json.exception.type_error.315 | values in object must be primitive | The @ref unflatten function only works for an object whose keys are JSON Pointers and whose values are primitive. + +@liveexample{The following code shows how a `type_error` exception can be +caught.,type_error} + +@sa @ref exception for the base class of the library exceptions +@sa @ref parse_error for exceptions indicating a parse error +@sa @ref invalid_iterator for exceptions indicating errors with iterators +@sa @ref out_of_range for exceptions indicating access out of the defined range +@sa @ref other_error for exceptions indicating other library errors + +@since version 3.0.0 +*/ +class type_error : public exception +{ + public: + static type_error create(int id_, const std::string& what_arg) + { + std::string w = exception::name("type_error", id_) + what_arg; + return type_error(id_, w.c_str()); + } + + private: + type_error(int id_, const char* what_arg) : exception(id_, what_arg) {} +}; + +/*! +@brief exception indicating access out of the defined range + +This exception is thrown in case a library function is called on an input +parameter that exceeds the expected range, for instance in case of array +indices or nonexisting object keys. + +Exceptions have ids 4xx. + +name / id | example message | description +------------------------------- | --------------- | ------------------------- +json.exception.out_of_range.401 | array index 3 is out of range | The provided array index @a i is larger than @a size-1. +json.exception.out_of_range.402 | array index '-' (3) is out of range | The special array index `-` in a JSON Pointer never describes a valid element of the array, but the index past the end. That is, it can only be used to add elements at this position, but not to read it. +json.exception.out_of_range.403 | key 'foo' not found | The provided key was not found in the JSON object. +json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved. +json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value. +json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF. + +@liveexample{The following code shows how an `out_of_range` exception can be +caught.,out_of_range} + +@sa @ref exception for the base class of the library exceptions +@sa @ref parse_error for exceptions indicating a parse error +@sa @ref invalid_iterator for exceptions indicating errors with iterators +@sa @ref type_error for exceptions indicating executing a member function with + a wrong type +@sa @ref other_error for exceptions indicating other library errors + +@since version 3.0.0 +*/ +class out_of_range : public exception +{ + public: + static out_of_range create(int id_, const std::string& what_arg) + { + std::string w = exception::name("out_of_range", id_) + what_arg; + return out_of_range(id_, w.c_str()); + } + + private: + out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {} +}; + +/*! +@brief exception indicating other library errors + +This exception is thrown in case of errors that cannot be classified with the +other exception types. + +Exceptions have ids 5xx. + +name / id | example message | description +------------------------------ | --------------- | ------------------------- +json.exception.other_error.501 | unsuccessful: {"op":"test","path":"/baz", "value":"bar"} | A JSON Patch operation 'test' failed. The unsuccessful operation is also printed. +json.exception.other_error.502 | invalid object size for conversion | Some conversions to user-defined types impose constraints on the object size (e.g. std::pair) + +@sa @ref exception for the base class of the library exceptions +@sa @ref parse_error for exceptions indicating a parse error +@sa @ref invalid_iterator for exceptions indicating errors with iterators +@sa @ref type_error for exceptions indicating executing a member function with + a wrong type +@sa @ref out_of_range for exceptions indicating access out of the defined range + +@liveexample{The following code shows how an `other_error` exception can be +caught.,other_error} + +@since version 3.0.0 +*/ +class other_error : public exception +{ + public: + static other_error create(int id_, const std::string& what_arg) + { + std::string w = exception::name("other_error", id_) + what_arg; + return other_error(id_, w.c_str()); + } + + private: + other_error(int id_, const char* what_arg) : exception(id_, what_arg) {} +}; + + + +/////////////////////////// +// 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 order = {{ + 0, // null + 3, // object + 4, // array + 5, // string + 1, // boolean + 2, // integer + 2, // unsigned + 2, // float + } + }; + + // discarded values are not comparable + return lhs != value_t::discarded and rhs != value_t::discarded and + order[static_cast(lhs)] < order[static_cast(rhs)]; +} + + +///////////// +// helpers // +///////////// + +template struct is_basic_json : std::false_type {}; + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +struct is_basic_json : std::true_type {}; + +// alias templates to reduce boilerplate +template +using enable_if_t = typename std::enable_if::type; + +template +using uncvref_t = typename std::remove_cv::type>::type; + +// implementation of C++14 index_sequence and affiliates +// source: https://stackoverflow.com/a/32223343 +template +struct index_sequence +{ + using type = index_sequence; + using value_type = std::size_t; + static constexpr std::size_t size() noexcept + { + return sizeof...(Ints); + } +}; + +template +struct merge_and_renumber; + +template +struct merge_and_renumber, index_sequence> + : index_sequence < I1..., (sizeof...(I1) + I2)... > + {}; + +template +struct make_index_sequence + : merge_and_renumber < typename make_index_sequence < N / 2 >::type, + typename make_index_sequence < N - N / 2 >::type > +{}; + +template<> struct make_index_sequence<0> : index_sequence<> { }; +template<> struct make_index_sequence<1> : index_sequence<0> { }; + +template +using index_sequence_for = make_index_sequence; + +/* +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::value and has_value_type::value +will not compile when T = void (on MSVC at least). Whereas +conjunction>, has_value_type>::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 struct conjunction : std::true_type {}; +template struct conjunction : B1 {}; +template +struct conjunction : std::conditional, B1>::type {}; + +template struct negation : std::integral_constant < bool, !B::value > {}; + +// dispatch utility (taken from ranges-v3) +template struct priority_tag : priority_tag < N - 1 > {}; +template<> struct priority_tag<0> {}; + + +////////////////// +// constructors // +////////////////// + +template struct external_constructor; + +template<> +struct external_constructor +{ + template + 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 +{ + template + 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 + static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s) + { + j.m_type = value_t::string; + j.m_value = std::move(s); + j.assert_invariant(); + } +}; + +template<> +struct external_constructor +{ + template + static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept + { + j.m_type = value_t::number_float; + j.m_value = val; + j.assert_invariant(); + } +}; + +template<> +struct external_constructor +{ + template + 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 +{ + template + 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 +{ + template + 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 + static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr) + { + j.m_type = value_t::array; + j.m_value = std::move(arr); + j.assert_invariant(); + } + + template::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(begin(arr), end(arr)); + j.assert_invariant(); + } + + template + static void construct(BasicJsonType& j, const std::vector& arr) + { + j.m_type = value_t::array; + j.m_value = value_t::array; + j.m_value.array->reserve(arr.size()); + for (bool x : arr) + { + j.m_value.array->push_back(x); + } + j.assert_invariant(); + } + + template::value, int> = 0> + static void construct(BasicJsonType& j, const std::valarray& arr) + { + j.m_type = value_t::array; + j.m_value = value_t::array; + j.m_value.array->resize(arr.size()); + std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin()); + j.assert_invariant(); + } +}; + +template<> +struct external_constructor +{ + template + 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 + static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj) + { + j.m_type = value_t::object; + j.m_value = std::move(obj); + j.assert_invariant(); + } + + template::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(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 struct has_##type { \ + private: \ + template \ + static int detect(U &&); \ + static void detect(...); \ + public: \ + static constexpr bool value = \ + std::is_integral()))>::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 +struct is_compatible_object_type_impl : std::false_type {}; + +template +struct is_compatible_object_type_impl +{ + static constexpr auto value = + std::is_constructible::value and + std::is_constructible::value; +}; + +template +struct is_compatible_object_type +{ + static auto constexpr value = is_compatible_object_type_impl < + conjunction>, + has_mapped_type, + has_key_type>::value, + typename BasicJsonType::object_t, CompatibleObjectType >::value; +}; + +template +struct is_basic_json_nested_type +{ + static auto constexpr value = std::is_same::value or + std::is_same::value or + std::is_same::value or + std::is_same::value; +}; + +template +struct is_compatible_array_type +{ + static auto constexpr value = + conjunction>, + negation>, + negation>, + negation>, + has_value_type, + has_iterator>::value; +}; + +template +struct is_compatible_integer_type_impl : std::false_type {}; + +template +struct is_compatible_integer_type_impl +{ + // is there an assert somewhere on overflows? + using RealLimits = std::numeric_limits; + using CompatibleLimits = std::numeric_limits; + + static constexpr auto value = + std::is_constructible::value and + CompatibleLimits::is_integer and + RealLimits::is_signed == CompatibleLimits::is_signed; +}; + +template +struct is_compatible_integer_type +{ + static constexpr auto value = + is_compatible_integer_type_impl < + std::is_integral::value and + not std::is_same::value, + RealIntegerType, CompatibleNumberIntegerType > ::value; +}; + + +// trait checking if JSONSerializer::from_json(json const&, udt&) exists +template +struct has_from_json +{ + private: + // also check the return type of from_json + template::from_json( + std::declval(), std::declval()))>::value>> + static int detect(U&&); + static void detect(...); + + public: + static constexpr bool value = std::is_integral>()))>::value; +}; + +// This trait checks if JSONSerializer::from_json(json const&) exists +// this overload is used for non-default-constructible user-defined-types +template +struct has_non_default_from_json +{ + private: + template < + typename U, + typename = enable_if_t::from_json(std::declval()))>::value >> + static int detect(U&&); + static void detect(...); + + public: + static constexpr bool value = std::is_integral>()))>::value; +}; + +// This trait checks if BasicJsonType::json_serializer::to_json exists +template +struct has_to_json +{ + private: + template::to_json( + std::declval(), std::declval()))> + static int detect(U&&); + static void detect(...); + + public: + static constexpr bool value = std::is_integral>()))>::value; +}; + + +///////////// +// to_json // +///////////// + +template::value, int> = 0> +void to_json(BasicJsonType& j, T b) noexcept +{ + external_constructor::construct(j, b); +} + +template::value, int> = 0> +void to_json(BasicJsonType& j, const CompatibleString& s) +{ + external_constructor::construct(j, s); +} + +template +void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s) +{ + external_constructor::construct(j, std::move(s)); +} + +template::value, int> = 0> +void to_json(BasicJsonType& j, FloatType val) noexcept +{ + external_constructor::construct(j, static_cast(val)); +} + +template < + typename BasicJsonType, typename CompatibleNumberUnsignedType, + enable_if_t::value, int> = 0 > +void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept +{ + external_constructor::construct(j, static_cast(val)); +} + +template < + typename BasicJsonType, typename CompatibleNumberIntegerType, + enable_if_t::value, int> = 0 > +void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept +{ + external_constructor::construct(j, static_cast(val)); +} + +template::value, int> = 0> +void to_json(BasicJsonType& j, EnumType e) noexcept +{ + using underlying_type = typename std::underlying_type::type; + external_constructor::construct(j, static_cast(e)); +} + +template +void to_json(BasicJsonType& j, const std::vector& e) +{ + external_constructor::construct(j, e); +} + +template < + typename BasicJsonType, typename CompatibleArrayType, + enable_if_t < + is_compatible_array_type::value or + std::is_same::value, + int > = 0 > +void to_json(BasicJsonType& j, const CompatibleArrayType& arr) +{ + external_constructor::construct(j, arr); +} + +template ::value, int> = 0> +void to_json(BasicJsonType& j, std::valarray arr) +{ + external_constructor::construct(j, std::move(arr)); +} + +template +void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr) +{ + external_constructor::construct(j, std::move(arr)); +} + +template < + typename BasicJsonType, typename CompatibleObjectType, + enable_if_t::value, + int> = 0 > +void to_json(BasicJsonType& j, const CompatibleObjectType& obj) +{ + external_constructor::construct(j, obj); +} + +template +void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj) +{ + external_constructor::construct(j, std::move(obj)); +} + +template::value, + int> = 0> +void to_json(BasicJsonType& j, T (&arr)[N]) +{ + external_constructor::construct(j, arr); +} + +template +void to_json(BasicJsonType& j, const std::pair& p) +{ + j = {p.first, p.second}; +} + +template +void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence) +{ + j = {std::get(t)...}; +} + +template +void to_json(BasicJsonType& j, const std::tuple& t) +{ + to_json_tuple_impl(j, t, index_sequence_for {}); +} + +/////////////// +// from_json // +/////////////// + +// overloads for basic_json template parameters +template::value and + not std::is_same::value, + int> = 0> +void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val) +{ + switch (static_cast(j)) + { + case value_t::number_unsigned: + { + val = static_cast(*j.template get_ptr()); + break; + } + case value_t::number_integer: + { + val = static_cast(*j.template get_ptr()); + break; + } + case value_t::number_float: + { + val = static_cast(*j.template get_ptr()); + break; + } + + default: + JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()))); + } +} + +template +void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b) +{ + if (JSON_UNLIKELY(not j.is_boolean())) + { + JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name()))); + } + b = *j.template get_ptr(); +} + +template +void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s) +{ + if (JSON_UNLIKELY(not j.is_string())) + { + JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()))); + } + s = *j.template get_ptr(); +} + +template +void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val) +{ + get_arithmetic_value(j, val); +} + +template +void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val) +{ + get_arithmetic_value(j, val); +} + +template +void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val) +{ + get_arithmetic_value(j, val); +} + +template::value, int> = 0> +void from_json(const BasicJsonType& j, EnumType& e) +{ + typename std::underlying_type::type val; + get_arithmetic_value(j, val); + e = static_cast(val); +} + +template +void from_json(const BasicJsonType& j, typename BasicJsonType::array_t& arr) +{ + if (JSON_UNLIKELY(not j.is_array())) + { + JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()))); + } + arr = *j.template get_ptr(); +} + +// forward_list doesn't have an insert method +template::value, int> = 0> +void from_json(const BasicJsonType& j, std::forward_list& l) +{ + if (JSON_UNLIKELY(not j.is_array())) + { + JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()))); + } + std::transform(j.rbegin(), j.rend(), + std::front_inserter(l), [](const BasicJsonType & i) + { + return i.template get(); + }); +} + +// valarray doesn't have an insert method +template::value, int> = 0> +void from_json(const BasicJsonType& j, std::valarray& l) +{ + if (JSON_UNLIKELY(not j.is_array())) + { + JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()))); + } + l.resize(j.size()); + std::copy(j.m_value.array->begin(), j.m_value.array->end(), std::begin(l)); +} + +template +void from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<0> /*unused*/) +{ + using std::end; + + std::transform(j.begin(), j.end(), + std::inserter(arr, end(arr)), [](const BasicJsonType & i) + { + // get() returns *this, this won't call a from_json + // method when value_type is BasicJsonType + return i.template get(); + }); +} + +template +auto from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<1> /*unused*/) +-> decltype( + arr.reserve(std::declval()), + void()) +{ + using std::end; + + arr.reserve(j.size()); + std::transform(j.begin(), j.end(), + std::inserter(arr, end(arr)), [](const BasicJsonType & i) + { + // get() returns *this, this won't call a from_json + // method when value_type is BasicJsonType + return i.template get(); + }); +} + +template +void from_json_array_impl(const BasicJsonType& j, std::array& arr, priority_tag<2> /*unused*/) +{ + for (std::size_t i = 0; i < N; ++i) + { + arr[i] = j.at(i).template get(); + } +} + +template::value and + std::is_convertible::value and + not std::is_same::value, int> = 0> +void from_json(const BasicJsonType& j, CompatibleArrayType& arr) +{ + if (JSON_UNLIKELY(not j.is_array())) + { + JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()))); + } + + from_json_array_impl(j, arr, priority_tag<2> {}); +} + +template::value, int> = 0> +void from_json(const BasicJsonType& j, CompatibleObjectType& obj) +{ + if (JSON_UNLIKELY(not j.is_object())) + { + JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name()))); + } + + auto inner_object = j.template get_ptr(); + using value_type = typename CompatibleObjectType::value_type; + std::transform( + inner_object->begin(), inner_object->end(), + std::inserter(obj, obj.begin()), + [](typename BasicJsonType::object_t::value_type const & p) + { + return value_type(p.first, p.second.template get()); + }); +} + +// 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::value and + not std::is_same::value and + not std::is_same::value and + not std::is_same::value and + not std::is_same::value, + int> = 0> +void from_json(const BasicJsonType& j, ArithmeticType& val) +{ + switch (static_cast(j)) + { + case value_t::number_unsigned: + { + val = static_cast(*j.template get_ptr()); + break; + } + case value_t::number_integer: + { + val = static_cast(*j.template get_ptr()); + break; + } + case value_t::number_float: + { + val = static_cast(*j.template get_ptr()); + break; + } + case value_t::boolean: + { + val = static_cast(*j.template get_ptr()); + break; + } + + default: + JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()))); + } +} + +template +void from_json(const BasicJsonType& j, std::pair& p) +{ + p = {j.at(0).template get(), j.at(1).template get()}; +} + +template +void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence) +{ + t = std::make_tuple(j.at(Idx).template get::type>()...); +} + +template +void from_json(const BasicJsonType& j, std::tuple& t) +{ + from_json_tuple_impl(j, t, index_sequence_for {}); +} + +struct to_json_fn +{ + private: + template + auto call(BasicJsonType& j, T&& val, priority_tag<1> /*unused*/) const noexcept(noexcept(to_json(j, std::forward(val)))) + -> decltype(to_json(j, std::forward(val)), void()) + { + return to_json(j, std::forward(val)); + } + + template + void call(BasicJsonType& /*unused*/, T&& /*unused*/, priority_tag<0> /*unused*/) const noexcept + { + static_assert(sizeof(BasicJsonType) == 0, + "could not find to_json() method in T's namespace"); + } + + public: + template + void operator()(BasicJsonType& j, T&& val) const + noexcept(noexcept(std::declval().call(j, std::forward(val), priority_tag<1> {}))) + { + return call(j, std::forward(val), priority_tag<1> {}); + } +}; + +struct from_json_fn +{ + private: + template + auto call(const BasicJsonType& j, T& val, priority_tag<1> /*unused*/) const + noexcept(noexcept(from_json(j, val))) + -> decltype(from_json(j, val), void()) + { + return from_json(j, val); + } + + template + void call(const BasicJsonType& /*unused*/, T& /*unused*/, priority_tag<0> /*unused*/) const noexcept + { + static_assert(sizeof(BasicJsonType) == 0, + "could not find from_json() method in T's namespace"); + } + + public: + template + void operator()(const BasicJsonType& j, T& val) const + noexcept(noexcept(std::declval().call(j, val, priority_tag<1> {}))) + { + return call(j, val, priority_tag<1> {}); + } +}; + +// taken from ranges-v3 +template +struct static_const +{ + static constexpr T value{}; +}; + +template +constexpr T static_const::value; + +//////////////////// +// input adapters // +//////////////////// + +/*! +@brief abstract input adapter interface + +Produces a stream of std::char_traits::int_type characters from a +std::istream, a buffer, or some other input type. Accepts the return of exactly +one non-EOF character for future input. The int_type characters returned +consist of all valid char values as positive values (typically unsigned char), +plus an EOF value outside that range, specified by the value of the function +std::char_traits::eof(). This value is typically -1, but could be any +arbitrary value which is not a valid char value. +*/ +struct input_adapter_protocol +{ + /// get a character [0,255] or std::char_traits::eof(). + virtual std::char_traits::int_type get_character() = 0; + /// restore the last non-eof() character to input + virtual void unget_character() = 0; + virtual ~input_adapter_protocol() = default; +}; + +/// a type to simplify interfaces +using input_adapter_t = std::shared_ptr; + +/*! +Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at +beginning of input. Does not support changing the underlying std::streambuf +in mid-input. Maintains underlying std::istream and std::streambuf to support +subsequent use of standard std::istream operations to process any input +characters following those used in parsing the JSON input. Clears the +std::istream flags; any input errors (e.g., EOF) will be detected by the first +subsequent call for input from the std::istream. +*/ +class input_stream_adapter : public input_adapter_protocol +{ + public: + ~input_stream_adapter() override + { + // clear stream flags; we use underlying streambuf I/O, do not + // maintain ifstream flags + is.clear(); + } + + explicit input_stream_adapter(std::istream& i) + : is(i), sb(*i.rdbuf()) + { + // ignore Byte Order Mark at start of input + std::char_traits::int_type c; + if ((c = get_character()) == 0xEF) + { + if ((c = get_character()) == 0xBB) + { + if ((c = get_character()) == 0xBF) + { + return; // Ignore BOM + } + else if (c != std::char_traits::eof()) + { + is.unget(); + } + is.putback('\xBB'); + } + else if (c != std::char_traits::eof()) + { + is.unget(); + } + is.putback('\xEF'); + } + else if (c != std::char_traits::eof()) + { + is.unget(); // Not BOM. Process as usual. + } + } + + // delete because of pointer members + input_stream_adapter(const input_stream_adapter&) = delete; + input_stream_adapter& operator=(input_stream_adapter&) = delete; + + // std::istream/std::streambuf use std::char_traits::to_int_type, to + // ensure that std::char_traits::eof() and the character 0xff do not + // end up as the same value, eg. 0xffffffff. + std::char_traits::int_type get_character() override + { + return sb.sbumpc(); + } + + void unget_character() override + { + sb.sungetc(); // is.unget() avoided for performance + } + + private: + /// the associated input stream + std::istream& is; + std::streambuf& sb; +}; + +/// input adapter for buffer input +class input_buffer_adapter : public input_adapter_protocol +{ + public: + input_buffer_adapter(const char* b, const std::size_t l) + : cursor(b), limit(b + l), start(b) + { + // skip byte order mark + if (l >= 3 and b[0] == '\xEF' and b[1] == '\xBB' and b[2] == '\xBF') + { + cursor += 3; + } + } + + // delete because of pointer members + input_buffer_adapter(const input_buffer_adapter&) = delete; + input_buffer_adapter& operator=(input_buffer_adapter&) = delete; + + std::char_traits::int_type get_character() noexcept override + { + if (JSON_LIKELY(cursor < limit)) + { + return std::char_traits::to_int_type(*(cursor++)); + } + + return std::char_traits::eof(); + } + + void unget_character() noexcept override + { + if (JSON_LIKELY(cursor > start)) + { + --cursor; + } + } + + private: + /// pointer to the current character + const char* cursor; + /// pointer past the last character + const char* limit; + /// pointer to the first character + const char* start; +}; + +class input_adapter +{ + public: + // native support + + /// input adapter for input stream + input_adapter(std::istream& i) + : ia(std::make_shared(i)) {} + + /// input adapter for input stream + input_adapter(std::istream&& i) + : ia(std::make_shared(i)) {} + + /// input adapter for buffer + template::value and + std::is_integral< + typename std::remove_pointer::type>::value and + sizeof(typename std::remove_pointer::type) == 1, + int>::type = 0> + input_adapter(CharT b, std::size_t l) + : ia(std::make_shared(reinterpret_cast(b), l)) {} + + // derived support + + /// input adapter for string literal + template::value and + std::is_integral< + typename std::remove_pointer::type>::value and + sizeof(typename std::remove_pointer::type) == 1, + int>::type = 0> + input_adapter(CharT b) + : input_adapter(reinterpret_cast(b), + std::strlen(reinterpret_cast(b))) {} + + /// input adapter for iterator range with contiguous storage + template::iterator_category, + std::random_access_iterator_tag>::value, + int>::type = 0> + input_adapter(IteratorType first, IteratorType last) + { + // 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(true, 0), + [&first](std::pair 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::value_type) == 1, + "each element in the iterator range must have the size of 1 byte"); + + const auto len = static_cast(std::distance(first, last)); + if (JSON_LIKELY(len > 0)) + { + // there is at least one element: use the address of first + ia = std::make_shared(reinterpret_cast(&(*first)), len); + } + else + { + // the address of first cannot be used: use nullptr + ia = std::make_shared(nullptr, len); + } + } + + /// input adapter for array + template + input_adapter(T (&array)[N]) + : input_adapter(std::begin(array), std::end(array)) {} + + /// input adapter for contiguous container + template < + class ContiguousContainer, + typename std::enable_if < + not std::is_pointer::value and + std::is_base_of()))>::iterator_category>::value, + int >::type = 0 > + input_adapter(const ContiguousContainer& c) + : input_adapter(std::begin(c), std::end(c)) {} + + operator input_adapter_t() + { + return ia; + } + + private: + /// the actual adapter + input_adapter_t ia = nullptr; +}; + +////////////////////// +// lexer and parser // +////////////////////// + +/*! +@brief lexical analysis + +This class organizes the lexical analysis during JSON deserialization. +*/ +template +class lexer +{ + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + using number_float_t = typename BasicJsonType::number_float_t; + + 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_unsigned() for actual value + value_integer, ///< a signed integer -- use get_number_integer() for actual value + value_float, ///< an floating point number -- use get_number_float() 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 + literal_or_value ///< a literal or the begin of a value (only for diagnostics) + }; + + /// return name of values of type token_type (only used for errors) + static const char* token_type_name(const token_type t) noexcept + { + switch (t) + { + case token_type::uninitialized: + return ""; + 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 ""; + case token_type::end_of_input: + return "end of input"; + case token_type::literal_or_value: + return "'[', '{', or a literal"; + default: // catch non-enum values + return "unknown token"; // LCOV_EXCL_LINE + } + } + + explicit lexer(detail::input_adapter_t adapter) + : ia(std::move(adapter)), decimal_point_char(get_decimal_point()) {} + + // delete because of pointer members + lexer(const lexer&) = delete; + lexer& operator=(lexer&) = delete; + + private: + ///////////////////// + // locales + ///////////////////// + + /// return the locale-dependent decimal point + static char get_decimal_point() noexcept + { + const auto loc = localeconv(); + assert(loc != nullptr); + return (loc->decimal_point == nullptr) ? '.' : loc->decimal_point[0]; + } + + ///////////////////// + // scan functions + ///////////////////// + + /*! + @brief get codepoint from 4 hex characters following `\u` + + For input "\u c1 c2 c3 c4" the codepoint is: + (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4 + = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0) + + Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f' + must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The + conversion is done by subtracting the offset (0x30, 0x37, and 0x57) + between the ASCII value of the character and the desired integer value. + + @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or + non-hex character) + */ + int get_codepoint() + { + // this function only makes sense after reading `\u` + assert(current == 'u'); + int codepoint = 0; + + const auto factors = { 12, 8, 4, 0 }; + for (const auto factor : factors) + { + get(); + + if (current >= '0' and current <= '9') + { + codepoint += ((current - 0x30) << factor); + } + else if (current >= 'A' and current <= 'F') + { + codepoint += ((current - 0x37) << factor); + } + else if (current >= 'a' and current <= 'f') + { + codepoint += ((current - 0x57) << factor); + } + else + { + return -1; + } + } + + assert(0x0000 <= codepoint and codepoint <= 0xFFFF); + return codepoint; + } + + /*! + @brief check if the next byte(s) are inside a given range + + Adds the current byte and, for each passed range, reads a new byte and + checks if it is inside the range. If a violation was detected, set up an + error message and return false. Otherwise, return true. + + @return true if and only if no range violation was detected + */ + bool next_byte_in_range(std::initializer_list ranges) + { + assert(ranges.size() == 2 or ranges.size() == 4 or ranges.size() == 6); + add(current); + + for (auto range = ranges.begin(); range != ranges.end(); ++range) + { + get(); + if (JSON_LIKELY(*range <= current and current <= *(++range))) + { + add(current); + } + else + { + error_message = "invalid string: ill-formed UTF-8 byte"; + return false; + } + } + + return true; + } + + /*! + @brief scan a string literal + + This function scans a string according to Sect. 7 of RFC 7159. While + scanning, bytes are escaped and copied into buffer yytext. Then the function + returns successfully, yytext is *not* null-terminated (as it may contain \0 + bytes), and yytext.size() is the number of bytes in the string. + + @return token_type::value_string if string could be successfully scanned, + token_type::parse_error otherwise + + @note In case of errors, variable error_message contains a textual + description. + */ + token_type scan_string() + { + // reset yytext (ignore opening quote) + reset(); + + // we entered the function by reading an open quote + assert(current == '\"'); + + while (true) + { + // get next character + switch (get()) + { + // end of file while parsing string + case std::char_traits::eof(): + { + error_message = "invalid string: missing closing quote"; + return token_type::parse_error; + } + + // closing quote + case '\"': + { + return token_type::value_string; + } + + // escapes + case '\\': + { + switch (get()) + { + // quotation mark + case '\"': + add('\"'); + break; + // reverse solidus + case '\\': + add('\\'); + break; + // solidus + case '/': + add('/'); + break; + // backspace + case 'b': + add('\b'); + break; + // form feed + case 'f': + add('\f'); + break; + // line feed + case 'n': + add('\n'); + break; + // carriage return + case 'r': + add('\r'); + break; + // tab + case 't': + add('\t'); + break; + + // unicode escapes + case 'u': + { + int codepoint; + const int codepoint1 = get_codepoint(); + + if (JSON_UNLIKELY(codepoint1 == -1)) + { + error_message = "invalid string: '\\u' must be followed by 4 hex digits"; + return token_type::parse_error; + } + + // check if code point is a high surrogate + if (0xD800 <= codepoint1 and codepoint1 <= 0xDBFF) + { + // expect next \uxxxx entry + if (JSON_LIKELY(get() == '\\' and get() == 'u')) + { + const int codepoint2 = get_codepoint(); + + if (JSON_UNLIKELY(codepoint2 == -1)) + { + error_message = "invalid string: '\\u' must be followed by 4 hex digits"; + return token_type::parse_error; + } + + // check if codepoint2 is a low surrogate + if (JSON_LIKELY(0xDC00 <= codepoint2 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 + { + error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF"; + return token_type::parse_error; + } + } + else + { + error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF"; + return token_type::parse_error; + } + } + else + { + if (JSON_UNLIKELY(0xDC00 <= codepoint1 and codepoint1 <= 0xDFFF)) + { + error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF"; + return token_type::parse_error; + } + + // only work with first code point + codepoint = codepoint1; + } + + // result of the above calculation yields a proper codepoint + assert(0x00 <= codepoint and codepoint <= 0x10FFFF); + + // translate code point to bytes + if (codepoint < 0x80) + { + // 1-byte characters: 0xxxxxxx (ASCII) + add(codepoint); + } + else if (codepoint <= 0x7ff) + { + // 2-byte characters: 110xxxxx 10xxxxxx + add(0xC0 | (codepoint >> 6)); + add(0x80 | (codepoint & 0x3F)); + } + else if (codepoint <= 0xffff) + { + // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx + add(0xE0 | (codepoint >> 12)); + add(0x80 | ((codepoint >> 6) & 0x3F)); + add(0x80 | (codepoint & 0x3F)); + } + else + { + // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + add(0xF0 | (codepoint >> 18)); + add(0x80 | ((codepoint >> 12) & 0x3F)); + add(0x80 | ((codepoint >> 6) & 0x3F)); + add(0x80 | (codepoint & 0x3F)); + } + + break; + } + + // other characters after escape + default: + error_message = "invalid string: forbidden character after backslash"; + return token_type::parse_error; + } + + break; + } + + // invalid control characters + 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: + case 0x18: + case 0x19: + case 0x1a: + case 0x1b: + case 0x1c: + case 0x1d: + case 0x1e: + case 0x1f: + { + error_message = "invalid string: control character must be escaped"; + return token_type::parse_error; + } + + // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace)) + case 0x20: + case 0x21: + 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: + case 0x38: + case 0x39: + case 0x3a: + case 0x3b: + case 0x3c: + case 0x3d: + case 0x3e: + case 0x3f: + case 0x40: + case 0x41: + case 0x42: + case 0x43: + case 0x44: + case 0x45: + case 0x46: + case 0x47: + case 0x48: + case 0x49: + case 0x4a: + case 0x4b: + case 0x4c: + case 0x4d: + case 0x4e: + case 0x4f: + case 0x50: + case 0x51: + case 0x52: + case 0x53: + case 0x54: + case 0x55: + case 0x56: + case 0x57: + case 0x58: + case 0x59: + case 0x5a: + case 0x5b: + case 0x5d: + case 0x5e: + case 0x5f: + 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: + case 0x78: + case 0x79: + case 0x7a: + case 0x7b: + case 0x7c: + case 0x7d: + case 0x7e: + case 0x7f: + { + add(current); + break; + } + + // U+0080..U+07FF: bytes C2..DF 80..BF + case 0xc2: + case 0xc3: + case 0xc4: + case 0xc5: + case 0xc6: + case 0xc7: + case 0xc8: + case 0xc9: + case 0xca: + case 0xcb: + case 0xcc: + case 0xcd: + case 0xce: + case 0xcf: + case 0xd0: + case 0xd1: + case 0xd2: + case 0xd3: + case 0xd4: + case 0xd5: + case 0xd6: + case 0xd7: + case 0xd8: + case 0xd9: + case 0xda: + case 0xdb: + case 0xdc: + case 0xdd: + case 0xde: + case 0xdf: + { + if (JSON_UNLIKELY(not next_byte_in_range({0x80, 0xBF}))) + { + return token_type::parse_error; + } + break; + } + + // U+0800..U+0FFF: bytes E0 A0..BF 80..BF + case 0xe0: + { + if (JSON_UNLIKELY(not (next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF})))) + { + return token_type::parse_error; + } + break; + } + + // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF + // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF + case 0xe1: + case 0xe2: + case 0xe3: + case 0xe4: + case 0xe5: + case 0xe6: + case 0xe7: + case 0xe8: + case 0xe9: + case 0xea: + case 0xeb: + case 0xec: + case 0xee: + case 0xef: + { + if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF})))) + { + return token_type::parse_error; + } + break; + } + + // U+D000..U+D7FF: bytes ED 80..9F 80..BF + case 0xed: + { + if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0x9F, 0x80, 0xBF})))) + { + return token_type::parse_error; + } + break; + } + + // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF + case 0xf0: + { + if (JSON_UNLIKELY(not (next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF})))) + { + return token_type::parse_error; + } + break; + } + + // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF + case 0xf1: + case 0xf2: + case 0xf3: + { + if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF})))) + { + return token_type::parse_error; + } + break; + } + + // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF + case 0xf4: + { + if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF})))) + { + return token_type::parse_error; + } + break; + } + + // remaining bytes (80..C1 and F5..FF) are ill-formed + default: + { + error_message = "invalid string: ill-formed UTF-8 byte"; + return token_type::parse_error; + } + } + } + } + + static void strtof(float& f, const char* str, char** endptr) noexcept + { + f = std::strtof(str, endptr); + } + + static void strtof(double& f, const char* str, char** endptr) noexcept + { + f = std::strtod(str, endptr); + } + + static void strtof(long double& f, const char* str, char** endptr) noexcept + { + f = std::strtold(str, endptr); + } + + /*! + @brief scan a number literal + + This function scans a string according to Sect. 6 of RFC 7159. + + The function is realized with a deterministic finite state machine derived + from the grammar described in RFC 7159. Starting in state "init", the + input is read and used to determined the next state. Only state "done" + accepts the number. State "error" is a trap state to model errors. In the + table below, "anything" means any character but the ones listed before. + + state | 0 | 1-9 | e E | + | - | . | anything + ---------|----------|----------|----------|---------|---------|----------|----------- + init | zero | any1 | [error] | [error] | minus | [error] | [error] + minus | zero | any1 | [error] | [error] | [error] | [error] | [error] + zero | done | done | exponent | done | done | decimal1 | done + any1 | any1 | any1 | exponent | done | done | decimal1 | done + decimal1 | decimal2 | [error] | [error] | [error] | [error] | [error] | [error] + decimal2 | decimal2 | decimal2 | exponent | done | done | done | done + exponent | any2 | any2 | [error] | sign | sign | [error] | [error] + sign | any2 | any2 | [error] | [error] | [error] | [error] | [error] + any2 | any2 | any2 | done | done | done | done | done + + The state machine is realized with one label per state (prefixed with + "scan_number_") and `goto` statements between them. The state machine + contains cycles, but any cycle can be left when EOF is read. Therefore, + the function is guaranteed to terminate. + + During scanning, the read bytes are stored in yytext. This string is + then converted to a signed integer, an unsigned integer, or a + floating-point number. + + @return token_type::value_unsigned, token_type::value_integer, or + token_type::value_float if number could be successfully scanned, + token_type::parse_error otherwise + + @note The scanner is independent of the current locale. Internally, the + locale's decimal point is used instead of `.` to work with the + locale-dependent converters. + */ + token_type scan_number() + { + // reset yytext to store the number's bytes + reset(); + + // the type of the parsed number; initially set to unsigned; will be + // changed if minus sign, decimal point or exponent is read + token_type number_type = token_type::value_unsigned; + + // state (init): we just found out we need to scan a number + switch (current) + { + case '-': + { + add(current); + goto scan_number_minus; + } + + case '0': + { + add(current); + goto scan_number_zero; + } + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_any1; + } + + default: + { + // all other characters are rejected outside scan_number() + assert(false); // LCOV_EXCL_LINE + } + } + +scan_number_minus: + // state: we just parsed a leading minus sign + number_type = token_type::value_integer; + switch (get()) + { + case '0': + { + add(current); + goto scan_number_zero; + } + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_any1; + } + + default: + { + error_message = "invalid number; expected digit after '-'"; + return token_type::parse_error; + } + } + +scan_number_zero: + // state: we just parse a zero (maybe with a leading minus sign) + switch (get()) + { + case '.': + { + add(decimal_point_char); + goto scan_number_decimal1; + } + + case 'e': + case 'E': + { + add(current); + goto scan_number_exponent; + } + + default: + goto scan_number_done; + } + +scan_number_any1: + // state: we just parsed a number 0-9 (maybe with a leading minus sign) + switch (get()) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_any1; + } + + case '.': + { + add(decimal_point_char); + goto scan_number_decimal1; + } + + case 'e': + case 'E': + { + add(current); + goto scan_number_exponent; + } + + default: + goto scan_number_done; + } + +scan_number_decimal1: + // state: we just parsed a decimal point + number_type = token_type::value_float; + switch (get()) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_decimal2; + } + + default: + { + error_message = "invalid number; expected digit after '.'"; + return token_type::parse_error; + } + } + +scan_number_decimal2: + // we just parsed at least one number after a decimal point + switch (get()) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_decimal2; + } + + case 'e': + case 'E': + { + add(current); + goto scan_number_exponent; + } + + default: + goto scan_number_done; + } + +scan_number_exponent: + // we just parsed an exponent + number_type = token_type::value_float; + switch (get()) + { + case '+': + case '-': + { + add(current); + goto scan_number_sign; + } + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_any2; + } + + default: + { + error_message = + "invalid number; expected '+', '-', or digit after exponent"; + return token_type::parse_error; + } + } + +scan_number_sign: + // we just parsed an exponent sign + switch (get()) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_any2; + } + + default: + { + error_message = "invalid number; expected digit after exponent sign"; + return token_type::parse_error; + } + } + +scan_number_any2: + // we just parsed a number after the exponent or exponent sign + switch (get()) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + add(current); + goto scan_number_any2; + } + + default: + goto scan_number_done; + } + +scan_number_done: + // unget the character after the number (we only read it to know that + // we are done scanning a number) + unget(); + + char* endptr = nullptr; + errno = 0; + + // try to parse integers first and fall back to floats + if (number_type == token_type::value_unsigned) + { + const auto x = std::strtoull(yytext.data(), &endptr, 10); + + // we checked the number format before + assert(endptr == yytext.data() + yytext.size()); + + if (errno == 0) + { + value_unsigned = static_cast(x); + if (value_unsigned == x) + { + return token_type::value_unsigned; + } + } + } + else if (number_type == token_type::value_integer) + { + const auto x = std::strtoll(yytext.data(), &endptr, 10); + + // we checked the number format before + assert(endptr == yytext.data() + yytext.size()); + + if (errno == 0) + { + value_integer = static_cast(x); + if (value_integer == x) + { + return token_type::value_integer; + } + } + } + + // this code is reached if we parse a floating-point number or if an + // integer conversion above failed + strtof(value_float, yytext.data(), &endptr); + + // we checked the number format before + assert(endptr == yytext.data() + yytext.size()); + + return token_type::value_float; + } + + /*! + @param[in] literal_text the literal text to expect + @param[in] length the length of the passed literal text + @param[in] return_type the token type to return on success + */ + token_type scan_literal(const char* literal_text, const std::size_t length, + token_type return_type) + { + assert(current == literal_text[0]); + for (std::size_t i = 1; i < length; ++i) + { + if (JSON_UNLIKELY(get() != literal_text[i])) + { + error_message = "invalid literal"; + return token_type::parse_error; + } + } + return return_type; + } + + ///////////////////// + // input management + ///////////////////// + + /// reset yytext; current character is beginning of token + void reset() noexcept + { + yytext.clear(); + token_string.clear(); + token_string.push_back(std::char_traits::to_char_type(current)); + } + + /* + @brief get next character from the input + + This function provides the interface to the used input adapter. It does + not throw in case the input reached EOF, but returns a + `std::char_traits::eof()` in that case. Stores the scanned characters + for use in error messages. + + @return character read from the input + */ + std::char_traits::int_type get() + { + ++chars_read; + current = ia->get_character(); + if (JSON_LIKELY(current != std::char_traits::eof())) + { + token_string.push_back(std::char_traits::to_char_type(current)); + } + return current; + } + + /// unget current character (return it again on next get) + void unget() + { + --chars_read; + if (JSON_LIKELY(current != std::char_traits::eof())) + { + ia->unget_character(); + assert(token_string.size() != 0); + token_string.pop_back(); + } + } + + /// add a character to yytext + void add(int c) + { + yytext.push_back(std::char_traits::to_char_type(c)); + } + + public: + ///////////////////// + // value getters + ///////////////////// + + /// return integer value + constexpr number_integer_t get_number_integer() const noexcept + { + return value_integer; + } + + /// return unsigned integer value + constexpr number_unsigned_t get_number_unsigned() const noexcept + { + return value_unsigned; + } + + /// return floating-point value + constexpr number_float_t get_number_float() const noexcept + { + return value_float; + } + + /// return current string value (implicitly resets the token; useful only once) + std::string move_string() + { + return std::move(yytext); + } + + ///////////////////// + // diagnostics + ///////////////////// + + /// return position of last read token + constexpr std::size_t get_position() const noexcept + { + return chars_read; + } + + /// return the last read token (for errors only). Will never contain EOF + /// (an arbitrary value that is not a valid char value, often -1), because + /// 255 may legitimately occur. May contain NUL, which should be escaped. + std::string get_token_string() const + { + // escape control characters + std::string result; + for (auto c : token_string) + { + if ('\x00' <= c and c <= '\x1f') + { + // escape control characters + std::stringstream ss; + ss << "(c) << ">"; + result += ss.str(); + } + else + { + // add character as is + result.push_back(c); + } + } + + return result; + } + + /// return syntax error message + constexpr const char* get_error_message() const noexcept + { + return error_message; + } + + ///////////////////// + // actual scanner + ///////////////////// + + token_type scan() + { + // read next character and ignore whitespace + do + { + get(); + } + while (current == ' ' or current == '\t' or current == '\n' or current == '\r'); + + switch (current) + { + // structural characters + case '[': + return token_type::begin_array; + case ']': + return token_type::end_array; + case '{': + return token_type::begin_object; + case '}': + return token_type::end_object; + case ':': + return token_type::name_separator; + case ',': + return token_type::value_separator; + + // literals + case 't': + return scan_literal("true", 4, token_type::literal_true); + case 'f': + return scan_literal("false", 5, token_type::literal_false); + case 'n': + return scan_literal("null", 4, token_type::literal_null); + + // string + case '\"': + return scan_string(); + + // number + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + return scan_number(); + + // end of input (the null byte is needed when parsing from + // string literals) + case '\0': + case std::char_traits::eof(): + return token_type::end_of_input; + + // error + default: + error_message = "invalid literal"; + return token_type::parse_error; + } + } + + private: + /// input adapter + detail::input_adapter_t ia = nullptr; + + /// the current character + std::char_traits::int_type current = std::char_traits::eof(); + + /// the number of characters read + std::size_t chars_read = 0; + + /// raw input token string (for error messages) + std::vector token_string { }; + + /// buffer for variable-length tokens (numbers, strings) + std::string yytext { }; + + /// a description of occurred lexer errors + const char* error_message = ""; + + // number values + number_integer_t value_integer = 0; + number_unsigned_t value_unsigned = 0; + number_float_t value_float = 0; + + /// the decimal point + const char decimal_point_char = '.'; +}; + +/*! +@brief syntax analysis + +This class implements a recursive decent parser. +*/ +template +class parser +{ + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + using number_float_t = typename BasicJsonType::number_float_t; + using lexer_t = lexer; + using token_type = typename lexer_t::token_type; + + public: + 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 + }; + + using parser_callback_t = + std::function; + + /// a parser reading from an input adapter + explicit parser(detail::input_adapter_t adapter, + const parser_callback_t cb = nullptr, + const bool allow_exceptions_ = true) + : callback(cb), m_lexer(adapter), allow_exceptions(allow_exceptions_) + {} + + /*! + @brief public parser interface + + @param[in] strict whether to expect the last token to be EOF + @param[in,out] result parsed JSON value + + @throw parse_error.101 in case of an unexpected token + @throw parse_error.102 if to_unicode fails or surrogate error + @throw parse_error.103 if to_unicode fails + */ + void parse(const bool strict, BasicJsonType& result) + { + // read first token + get_token(); + + parse_internal(true, result); + result.assert_invariant(); + + // in strict mode, input must be completely read + if (strict) + { + get_token(); + expect(token_type::end_of_input); + } + + // in case of an error, return discarded value + if (errored) + { + result = value_t::discarded; + return; + } + + // set top-level value to null if it was discarded by the callback + // function + if (result.is_discarded()) + { + result = nullptr; + } + } + + /*! + @brief public accept interface + + @param[in] strict whether to expect the last token to be EOF + @return whether the input is a proper JSON text + */ + bool accept(const bool strict = true) + { + // read first token + get_token(); + + if (not accept_internal()) + { + return false; + } + + // strict => last token must be EOF + return not strict or (get_token() == token_type::end_of_input); + } + + private: + /*! + @brief the actual parser + @throw parse_error.101 in case of an unexpected token + @throw parse_error.102 if to_unicode fails or surrogate error + @throw parse_error.103 if to_unicode fails + */ + void parse_internal(bool keep, BasicJsonType& result) + { + // never parse after a parse error was detected + assert(not errored); + + // start with a discarded value + if (not result.is_discarded()) + { + result.m_value.destroy(result.m_type); + result.m_type = value_t::discarded; + } + + switch (last_token) + { + case token_type::begin_object: + { + if (keep) + { + if (callback) + { + keep = callback(depth++, parse_event_t::object_start, result); + } + + if (not callback or keep) + { + // 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 == token_type::end_object) + { + if (keep and callback and not callback(--depth, parse_event_t::object_end, result)) + { + result.m_value.destroy(result.m_type); + result.m_type = value_t::discarded; + } + break; + } + + // parse values + std::string key; + BasicJsonType value; + while (true) + { + // store key + if (not expect(token_type::value_string)) + { + return; + } + key = m_lexer.move_string(); + + bool keep_tag = false; + if (keep) + { + if (callback) + { + BasicJsonType k(key); + keep_tag = callback(depth, parse_event_t::key, k); + } + else + { + keep_tag = true; + } + } + + // parse separator (:) + get_token(); + if (not expect(token_type::name_separator)) + { + return; + } + + // parse and add value + get_token(); + value.m_value.destroy(value.m_type); + value.m_type = value_t::discarded; + parse_internal(keep, value); + + if (JSON_UNLIKELY(errored)) + { + return; + } + + if (keep and keep_tag and not value.is_discarded()) + { + result.m_value.object->emplace(std::move(key), std::move(value)); + } + + // comma -> next value + get_token(); + if (last_token == token_type::value_separator) + { + get_token(); + continue; + } + + // closing } + if (not expect(token_type::end_object)) + { + return; + } + break; + } + + if (keep and callback and not callback(--depth, parse_event_t::object_end, result)) + { + result.m_value.destroy(result.m_type); + result.m_type = value_t::discarded; + } + break; + } + + case token_type::begin_array: + { + if (keep) + { + if (callback) + { + keep = callback(depth++, parse_event_t::array_start, result); + } + + if (not callback or keep) + { + // explicitly set result to array 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 == token_type::end_array) + { + if (callback and not callback(--depth, parse_event_t::array_end, result)) + { + result.m_value.destroy(result.m_type); + result.m_type = value_t::discarded; + } + break; + } + + // parse values + BasicJsonType value; + while (true) + { + // parse value + value.m_value.destroy(value.m_type); + value.m_type = value_t::discarded; + parse_internal(keep, value); + + if (JSON_UNLIKELY(errored)) + { + return; + } + + if (keep and not value.is_discarded()) + { + result.m_value.array->push_back(std::move(value)); + } + + // comma -> next value + get_token(); + if (last_token == token_type::value_separator) + { + get_token(); + continue; + } + + // closing ] + if (not expect(token_type::end_array)) + { + return; + } + break; + } + + if (keep and callback and not callback(--depth, parse_event_t::array_end, result)) + { + result.m_value.destroy(result.m_type); + result.m_type = value_t::discarded; + } + break; + } + + case token_type::literal_null: + { + result.m_type = value_t::null; + break; + } + + case token_type::value_string: + { + result.m_type = value_t::string; + result.m_value = m_lexer.move_string(); + break; + } + + case token_type::literal_true: + { + result.m_type = value_t::boolean; + result.m_value = true; + break; + } + + case token_type::literal_false: + { + result.m_type = value_t::boolean; + result.m_value = false; + break; + } + + case token_type::value_unsigned: + { + result.m_type = value_t::number_unsigned; + result.m_value = m_lexer.get_number_unsigned(); + break; + } + + case token_type::value_integer: + { + result.m_type = value_t::number_integer; + result.m_value = m_lexer.get_number_integer(); + break; + } + + case token_type::value_float: + { + result.m_type = value_t::number_float; + result.m_value = m_lexer.get_number_float(); + + // throw in case of infinity or NAN + if (JSON_UNLIKELY(not std::isfinite(result.m_value.number_float))) + { + if (allow_exceptions) + { + JSON_THROW(out_of_range::create(406, "number overflow parsing '" + + m_lexer.get_token_string() + "'")); + } + expect(token_type::uninitialized); + } + break; + } + + case token_type::parse_error: + { + // using "uninitialized" to avoid "expected" message + if (not expect(token_type::uninitialized)) + { + return; + } + break; // LCOV_EXCL_LINE + } + + default: + { + // the last token was unexpected; we expected a value + if (not expect(token_type::literal_or_value)) + { + return; + } + break; // LCOV_EXCL_LINE + } + } + + if (keep and callback and not callback(depth, parse_event_t::value, result)) + { + result.m_type = value_t::discarded; + } + } + + /*! + @brief the acutal acceptor + + @invariant 1. The last token is not yet processed. Therefore, the caller + of this function must make sure a token has been read. + 2. When this function returns, the last token is processed. + That is, the last read character was already considered. + + This invariant makes sure that no token needs to be "unput". + */ + bool accept_internal() + { + switch (last_token) + { + case token_type::begin_object: + { + // read next token + get_token(); + + // closing } -> we are done + if (last_token == token_type::end_object) + { + return true; + } + + // parse values + while (true) + { + // parse key + if (last_token != token_type::value_string) + { + return false; + } + + // parse separator (:) + get_token(); + if (last_token != token_type::name_separator) + { + return false; + } + + // parse value + get_token(); + if (not accept_internal()) + { + return false; + } + + // comma -> next value + get_token(); + if (last_token == token_type::value_separator) + { + get_token(); + continue; + } + + // closing } + return (last_token == token_type::end_object); + } + } + + case token_type::begin_array: + { + // read next token + get_token(); + + // closing ] -> we are done + if (last_token == token_type::end_array) + { + return true; + } + + // parse values + while (true) + { + // parse value + if (not accept_internal()) + { + return false; + } + + // comma -> next value + get_token(); + if (last_token == token_type::value_separator) + { + get_token(); + continue; + } + + // closing ] + return (last_token == token_type::end_array); + } + } + + case token_type::value_float: + { + // reject infinity or NAN + return std::isfinite(m_lexer.get_number_float()); + } + + case token_type::literal_false: + case token_type::literal_null: + case token_type::literal_true: + case token_type::value_integer: + case token_type::value_string: + case token_type::value_unsigned: + return true; + + default: // the last token was unexpected + return false; + } + } + + /// get next token from lexer + token_type get_token() + { + return (last_token = m_lexer.scan()); + } + + /*! + @throw parse_error.101 if expected token did not occur + */ + bool expect(token_type t) + { + if (JSON_UNLIKELY(t != last_token)) + { + errored = true; + expected = t; + if (allow_exceptions) + { + throw_exception(); + } + else + { + return false; + } + } + + return true; + } + + [[noreturn]] void throw_exception() const + { + std::string error_msg = "syntax error - "; + if (last_token == token_type::parse_error) + { + error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" + + m_lexer.get_token_string() + "'"; + } + else + { + error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token)); + } + + if (expected != token_type::uninitialized) + { + error_msg += "; expected " + std::string(lexer_t::token_type_name(expected)); + } + + JSON_THROW(parse_error::create(101, m_lexer.get_position(), 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 + token_type last_token = token_type::uninitialized; + /// the lexer + lexer_t m_lexer; + /// whether a syntax error occurred + bool errored = false; + /// possible reason for the syntax error + token_type expected = token_type::uninitialized; + /// whether to throw exceptions in case of errors + const bool allow_exceptions = true; +}; + +/////////////// +// 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: + using difference_type = std::ptrdiff_t; + + constexpr 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.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::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. +*/ +template struct internal_iterator +{ + /// iterator for JSON objects + typename BasicJsonType::object_t::iterator object_iterator {}; + /// iterator for JSON arrays + typename BasicJsonType::array_t::iterator array_iterator {}; + /// generic iterator for all other types + primitive_iterator_t primitive_iterator {}; +}; + +template class iteration_proxy; + +/*! +@brief a template for a bidirectional 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: +- +[BidirectionalIterator](http://en.cppreference.com/w/cpp/concept/BidirectionalIterator): + The iterator that can be moved can be moved in both directions (i.e. + incremented and decremented). + +@since version 1.0.0, simplified in version 2.0.9, change to bidirectional + iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593) +*/ +template +class iter_impl : public std::iterator +{ + /// allow basic_json to access private members + friend iter_impl::value, typename std::remove_const::type, const BasicJsonType>::type>; + friend BasicJsonType; + friend iteration_proxy; + + using object_t = typename BasicJsonType::object_t; + using array_t = typename BasicJsonType::array_t; + // make sure BasicJsonType is basic_json or const basic_json + static_assert(is_basic_json::type>::value, + "iter_impl only accepts (const) basic_json"); + + public: + /// the type of the values when the iterator is dereferenced + using value_type = typename BasicJsonType::value_type; + /// a type to represent differences between iterators + using difference_type = typename BasicJsonType::difference_type; + /// defines a pointer to the type iterated over (value_type) + using pointer = typename std::conditional::value, + typename BasicJsonType::const_pointer, + typename BasicJsonType::pointer>::type; + /// defines a reference to the type iterated over (value_type) + using reference = + typename std::conditional::value, + typename BasicJsonType::const_reference, + typename BasicJsonType::reference>::type; + + /// 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 value_t::object: + { + m_it.object_iterator = typename object_t::iterator(); + break; + } + + case value_t::array: + { + m_it.array_iterator = typename array_t::iterator(); + break; + } + + default: + { + m_it.primitive_iterator = primitive_iterator_t(); + break; + } + } + } + + /*! + @note The conventional copy constructor and copy assignment are implicitly + defined. Combined with the following converting constructor and + assignment, they support: (1) copy from iterator to iterator, (2) + copy from const iterator to const iterator, and (3) conversion from + iterator to const iterator. However conversion from const iterator + to iterator is not defined. + */ + + /*! + @brief converting constructor + @param[in] other non-const iterator to copy from + @note It is not checked whether @a other is initialized. + */ + iter_impl(const iter_impl::type>& other) noexcept + : m_object(other.m_object), m_it(other.m_it) {} + + /*! + @brief converting assignment + @param[in,out] other non-const iterator to copy from + @return const/non-const iterator + @note It is not checked whether @a other is initialized. + */ + iter_impl& operator=(const iter_impl::type>& other) noexcept + { + m_object = other.m_object; + 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 value_t::object: + { + m_it.object_iterator = m_object->m_value.object->begin(); + break; + } + + case value_t::array: + { + m_it.array_iterator = m_object->m_value.array->begin(); + break; + } + + case 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 value_t::object: + { + m_it.object_iterator = m_object->m_value.object->end(); + break; + } + + case 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 value_t::object: + { + assert(m_it.object_iterator != m_object->m_value.object->end()); + return m_it.object_iterator->second; + } + + case value_t::array: + { + assert(m_it.array_iterator != m_object->m_value.array->end()); + return *m_it.array_iterator; + } + + case value_t::null: + JSON_THROW(invalid_iterator::create(214, "cannot get value")); + + default: + { + if (JSON_LIKELY(m_it.primitive_iterator.is_begin())) + { + return *m_object; + } + + JSON_THROW(invalid_iterator::create(214, "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 value_t::object: + { + assert(m_it.object_iterator != m_object->m_value.object->end()); + return &(m_it.object_iterator->second); + } + + case value_t::array: + { + assert(m_it.array_iterator != m_object->m_value.array->end()); + return &*m_it.array_iterator; + } + + default: + { + if (JSON_LIKELY(m_it.primitive_iterator.is_begin())) + { + return m_object; + } + + JSON_THROW(invalid_iterator::create(214, "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 value_t::object: + { + std::advance(m_it.object_iterator, 1); + break; + } + + case 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 value_t::object: + { + std::advance(m_it.object_iterator, -1); + break; + } + + case 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 (JSON_UNLIKELY(m_object != other.m_object)) + { + JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers")); + } + + assert(m_object != nullptr); + + switch (m_object->m_type) + { + case value_t::object: + return (m_it.object_iterator == other.m_it.object_iterator); + + case 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 (JSON_UNLIKELY(m_object != other.m_object)) + { + JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers")); + } + + assert(m_object != nullptr); + + switch (m_object->m_type) + { + case value_t::object: + JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators")); + + case 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 value_t::object: + JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators")); + + case 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) const + { + auto result = *this; + result += i; + return result; + } + + /*! + @brief addition of distance and iterator + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + friend iter_impl operator+(difference_type i, const iter_impl& it) + { + auto result = it; + result += i; + return result; + } + + /*! + @brief subtract from iterator + @pre The iterator is initialized; i.e. `m_object != nullptr`. + */ + iter_impl operator-(difference_type i) const + { + 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 value_t::object: + JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators")); + + case 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 value_t::object: + JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators")); + + case value_t::array: + return *std::next(m_it.array_iterator, n); + + case value_t::null: + JSON_THROW(invalid_iterator::create(214, "cannot get value")); + + default: + { + if (JSON_LIKELY(m_it.primitive_iterator.get_value() == -n)) + { + return *m_object; + } + + JSON_THROW(invalid_iterator::create(214, "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 (JSON_LIKELY(m_object->is_object())) + { + return m_it.object_iterator->first; + } + + JSON_THROW(invalid_iterator::create(207, "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::type> m_it = {}; +}; + +/// proxy class for the iterator_wrapper functions +template 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) + std::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 noexcept + { + return anchor != o.anchor; + } + + /// return key of the iterator + std::string 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()); + } +}; + +/*! +@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: +- +[BidirectionalIterator](http://en.cppreference.com/w/cpp/concept/BidirectionalIterator): + The iterator that can be moved can be moved in both directions (i.e. + incremented and decremented). +- [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 +class json_reverse_iterator : public std::reverse_iterator +{ + public: + using difference_type = std::ptrdiff_t; + /// shortcut to the reverse iterator adaptor + using base_iterator = std::reverse_iterator; + /// 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 static_cast(base_iterator::operator++(1)); + } + + /// pre-increment (++it) + json_reverse_iterator& operator++() + { + return static_cast(base_iterator::operator++()); + } + + /// post-decrement (it--) + json_reverse_iterator operator--(int) + { + return static_cast(base_iterator::operator--(1)); + } + + /// pre-decrement (--it) + json_reverse_iterator& operator--() + { + return static_cast(base_iterator::operator--()); + } + + /// add to iterator + json_reverse_iterator& operator+=(difference_type i) + { + return static_cast(base_iterator::operator+=(i)); + } + + /// add to iterator + json_reverse_iterator operator+(difference_type i) const + { + return static_cast(base_iterator::operator+(i)); + } + + /// subtract from iterator + json_reverse_iterator operator-(difference_type i) const + { + return static_cast(base_iterator::operator-(i)); + } + + /// return difference + difference_type operator-(const json_reverse_iterator& other) const + { + return base_iterator(*this) - base_iterator(other); + } + + /// access to successor + reference operator[](difference_type n) const + { + return *(this->operator+(n)); + } + + /// return the key of an object iterator + auto key() const -> decltype(std::declval().key()) + { + auto it = --this->base(); + return it.key(); + } + + /// return the value of an iterator + reference value() const + { + auto it = --this->base(); + return it.operator * (); + } +}; + +///////////////////// +// output adapters // +///////////////////// + +/// abstract output adapter interface +template struct output_adapter_protocol +{ + virtual void write_character(CharType c) = 0; + virtual void write_characters(const CharType* s, std::size_t length) = 0; + virtual ~output_adapter_protocol() = default; +}; + +/// a type to simplify interfaces +template +using output_adapter_t = std::shared_ptr>; + +/// output adapter for byte vectors +template +class output_vector_adapter : public output_adapter_protocol +{ + public: + explicit output_vector_adapter(std::vector& vec) : v(vec) {} + + void write_character(CharType c) override + { + v.push_back(c); + } + + void write_characters(const CharType* s, std::size_t length) override + { + std::copy(s, s + length, std::back_inserter(v)); + } + + private: + std::vector& v; +}; + +/// output adapter for output streams +template +class output_stream_adapter : public output_adapter_protocol +{ + public: + explicit output_stream_adapter(std::basic_ostream& s) : stream(s) {} + + void write_character(CharType c) override + { + stream.put(c); + } + + void write_characters(const CharType* s, std::size_t length) override + { + stream.write(s, static_cast(length)); + } + + private: + std::basic_ostream& stream; +}; + +/// output adapter for basic_string +template +class output_string_adapter : public output_adapter_protocol +{ + public: + explicit output_string_adapter(std::basic_string& s) : str(s) {} + + void write_character(CharType c) override + { + str.push_back(c); + } + + void write_characters(const CharType* s, std::size_t length) override + { + str.append(s, length); + } + + private: + std::basic_string& str; +}; + +template +class output_adapter +{ + public: + output_adapter(std::vector& vec) + : oa(std::make_shared>(vec)) {} + + output_adapter(std::basic_ostream& s) + : oa(std::make_shared>(s)) {} + + output_adapter(std::basic_string& s) + : oa(std::make_shared>(s)) {} + + operator output_adapter_t() + { + return oa; + } + + private: + output_adapter_t oa = nullptr; +}; + +////////////////////////////// +// binary reader and writer // +////////////////////////////// + +/*! +@brief deserialization of CBOR and MessagePack values +*/ +template +class binary_reader +{ + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + + public: + /*! + @brief create a binary reader + + @param[in] adapter input adapter to read from + */ + explicit binary_reader(input_adapter_t adapter) : ia(std::move(adapter)) + { + assert(ia); + } + + /*! + @brief create a JSON value from CBOR input + + @param[in] strict whether to expect the input to be consumed completed + @return JSON value created from CBOR input + + @throw parse_error.110 if input ended unexpectedly or the end of file was + not reached when @a strict was set to true + @throw parse_error.112 if unsupported byte was read + */ + BasicJsonType parse_cbor(const bool strict) + { + const auto res = parse_cbor_internal(); + if (strict) + { + get(); + check_eof(true); + } + return res; + } + + /*! + @brief create a JSON value from MessagePack input + + @param[in] strict whether to expect the input to be consumed completed + @return JSON value created from MessagePack input + + @throw parse_error.110 if input ended unexpectedly or the end of file was + not reached when @a strict was set to true + @throw parse_error.112 if unsupported byte was read + */ + BasicJsonType parse_msgpack(const bool strict) + { + const auto res = parse_msgpack_internal(); + if (strict) + { + get(); + check_eof(true); + } + return res; + } + + /*! + @brief determine system byte order + + @return true if and only if system's byte order is little endian + + @note from http://stackoverflow.com/a/1001328/266378 + */ + static constexpr bool little_endianess(int num = 1) noexcept + { + return (*reinterpret_cast(&num) == 1); + } + + private: + /*! + @param[in] get_char whether a new character should be retrieved from the + input (true, default) or whether the last read + character should be considered instead + */ + BasicJsonType parse_cbor_internal(const bool get_char = true) + { + switch (get_char ? get() : current) + { + // EOF + case std::char_traits::eof(): + JSON_THROW(parse_error::create(110, chars_read, "unexpected end of input")); + + // 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 static_cast(current); + + case 0x18: // Unsigned integer (one-byte uint8_t follows) + return get_number(); + + case 0x19: // Unsigned integer (two-byte uint16_t follows) + return get_number(); + + case 0x1a: // Unsigned integer (four-byte uint32_t follows) + return get_number(); + + case 0x1b: // Unsigned integer (eight-byte uint64_t follows) + return get_number(); + + // 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(0x20 - 1 - current); + + case 0x38: // Negative integer (one-byte uint8_t follows) + { + // must be uint8_t ! + return static_cast(-1) - get_number(); + } + + case 0x39: // Negative integer -1-n (two-byte uint16_t follows) + { + return static_cast(-1) - get_number(); + } + + case 0x3a: // Negative integer -1-n (four-byte uint32_t follows) + { + return static_cast(-1) - get_number(); + } + + case 0x3b: // Negative integer -1-n (eight-byte uint64_t follows) + { + return static_cast(-1) - + static_cast(get_number()); + } + + // 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: + case 0x78: // UTF-8 string (one-byte uint8_t for n follows) + case 0x79: // UTF-8 string (two-byte uint16_t for n follow) + case 0x7a: // UTF-8 string (four-byte uint32_t for n follow) + case 0x7b: // UTF-8 string (eight-byte uint64_t for n follow) + case 0x7f: // UTF-8 string (indefinite length) + { + return get_cbor_string(); + } + + // 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: + { + return get_cbor_array(current & 0x1f); + } + + case 0x98: // array (one-byte uint8_t for n follows) + { + return get_cbor_array(get_number()); + } + + case 0x99: // array (two-byte uint16_t for n follow) + { + return get_cbor_array(get_number()); + } + + case 0x9a: // array (four-byte uint32_t for n follow) + { + return get_cbor_array(get_number()); + } + + case 0x9b: // array (eight-byte uint64_t for n follow) + { + return get_cbor_array(get_number()); + } + + case 0x9f: // array (indefinite length) + { + BasicJsonType result = value_t::array; + while (get() != 0xff) + { + result.push_back(parse_cbor_internal(false)); + } + 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: + { + return get_cbor_object(current & 0x1f); + } + + case 0xb8: // map (one-byte uint8_t for n follows) + { + return get_cbor_object(get_number()); + } + + case 0xb9: // map (two-byte uint16_t for n follow) + { + return get_cbor_object(get_number()); + } + + case 0xba: // map (four-byte uint32_t for n follow) + { + return get_cbor_object(get_number()); + } + + case 0xbb: // map (eight-byte uint64_t for n follow) + { + return get_cbor_object(get_number()); + } + + case 0xbf: // map (indefinite length) + { + BasicJsonType result = value_t::object; + while (get() != 0xff) + { + auto key = get_cbor_string(); + result[key] = parse_cbor_internal(); + } + 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) + { + const int byte1 = get(); + check_eof(); + const int byte2 = get(); + check_eof(); + + // 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 = (byte1 << 8) + byte2; + 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::infinity() + : std::numeric_limits::quiet_NaN(); + } + return (half & 0x8000) != 0 ? -val : val; + } + + case 0xfa: // Single-Precision Float (four-byte IEEE 754) + { + return get_number(); + } + + case 0xfb: // Double-Precision Float (eight-byte IEEE 754) + { + return get_number(); + } + + default: // anything else (0xFF is handled inside the other types) + { + std::stringstream ss; + ss << std::setw(2) << std::setfill('0') << std::hex << current; + JSON_THROW(parse_error::create(112, chars_read, "error reading CBOR; last byte: 0x" + ss.str())); + } + } + } + + BasicJsonType parse_msgpack_internal() + { + switch (get()) + { + // EOF + case std::char_traits::eof(): + JSON_THROW(parse_error::create(110, chars_read, "unexpected end of input")); + + // positive fixint + 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: + case 0x18: + case 0x19: + case 0x1a: + case 0x1b: + case 0x1c: + case 0x1d: + case 0x1e: + case 0x1f: + 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: + case 0x38: + case 0x39: + case 0x3a: + case 0x3b: + case 0x3c: + case 0x3d: + case 0x3e: + case 0x3f: + case 0x40: + case 0x41: + case 0x42: + case 0x43: + case 0x44: + case 0x45: + case 0x46: + case 0x47: + case 0x48: + case 0x49: + case 0x4a: + case 0x4b: + case 0x4c: + case 0x4d: + case 0x4e: + case 0x4f: + case 0x50: + case 0x51: + case 0x52: + case 0x53: + case 0x54: + case 0x55: + case 0x56: + case 0x57: + case 0x58: + case 0x59: + case 0x5a: + case 0x5b: + case 0x5c: + case 0x5d: + case 0x5e: + case 0x5f: + 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: + case 0x78: + case 0x79: + case 0x7a: + case 0x7b: + case 0x7c: + case 0x7d: + case 0x7e: + case 0x7f: + return static_cast(current); + + // fixmap + 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: + { + return get_msgpack_object(current & 0x0f); + } + + // fixarray + case 0x90: + case 0x91: + case 0x92: + case 0x93: + case 0x94: + case 0x95: + case 0x96: + case 0x97: + case 0x98: + case 0x99: + case 0x9a: + case 0x9b: + case 0x9c: + case 0x9d: + case 0x9e: + case 0x9f: + { + return get_msgpack_array(current & 0x0f); + } + + // fixstr + 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: + case 0xb8: + case 0xb9: + case 0xba: + case 0xbb: + case 0xbc: + case 0xbd: + case 0xbe: + case 0xbf: + return get_msgpack_string(); + + case 0xc0: // nil + return value_t::null; + + case 0xc2: // false + return false; + + case 0xc3: // true + return true; + + case 0xca: // float 32 + return get_number(); + + case 0xcb: // float 64 + return get_number(); + + case 0xcc: // uint 8 + return get_number(); + + case 0xcd: // uint 16 + return get_number(); + + case 0xce: // uint 32 + return get_number(); + + case 0xcf: // uint 64 + return get_number(); + + case 0xd0: // int 8 + return get_number(); + + case 0xd1: // int 16 + return get_number(); + + case 0xd2: // int 32 + return get_number(); + + case 0xd3: // int 64 + return get_number(); + + case 0xd9: // str 8 + case 0xda: // str 16 + case 0xdb: // str 32 + return get_msgpack_string(); + + case 0xdc: // array 16 + { + return get_msgpack_array(get_number()); + } + + case 0xdd: // array 32 + { + return get_msgpack_array(get_number()); + } + + case 0xde: // map 16 + { + return get_msgpack_object(get_number()); + } + + case 0xdf: // map 32 + { + return get_msgpack_object(get_number()); + } + + // positive fixint + case 0xe0: + case 0xe1: + case 0xe2: + case 0xe3: + case 0xe4: + case 0xe5: + case 0xe6: + case 0xe7: + case 0xe8: + case 0xe9: + case 0xea: + case 0xeb: + case 0xec: + case 0xed: + case 0xee: + case 0xef: + case 0xf0: + case 0xf1: + case 0xf2: + case 0xf3: + case 0xf4: + case 0xf5: + case 0xf6: + case 0xf7: + case 0xf8: + case 0xf9: + case 0xfa: + case 0xfb: + case 0xfc: + case 0xfd: + case 0xfe: + case 0xff: + return static_cast(current); + + default: // anything else + { + std::stringstream ss; + ss << std::setw(2) << std::setfill('0') << std::hex << current; + JSON_THROW(parse_error::create(112, chars_read, + "error reading MessagePack; last byte: 0x" + ss.str())); + } + } + } + + /*! + @brief get next character from the input + + This function provides the interface to the used input adapter. It does + not throw in case the input reached EOF, but returns a -'ve valued + `std::char_traits::eof()` in that case. + + @return character read from the input + */ + int get() + { + ++chars_read; + return (current = ia->get_character()); + } + + /* + @brief read a number from the input + + @tparam NumberType the type of the number + + @return number of type @a NumberType + + @note This function needs to respect the system's endianess, because + bytes in CBOR and MessagePack are stored in network order (big + endian) and therefore need reordering on little endian systems. + + @throw parse_error.110 if input has less than `sizeof(NumberType)` bytes + */ + template NumberType get_number() + { + // step 1: read input into array with system's byte order + std::array vec; + for (std::size_t i = 0; i < sizeof(NumberType); ++i) + { + get(); + check_eof(); + + // reverse byte order prior to conversion if necessary + if (is_little_endian) + { + vec[sizeof(NumberType) - i - 1] = static_cast(current); + } + else + { + vec[i] = static_cast(current); // LCOV_EXCL_LINE + } + } + + // step 2: convert array into number of type T and return + NumberType result; + std::memcpy(&result, vec.data(), sizeof(NumberType)); + return result; + } + + /*! + @brief create a string by reading characters from the input + + @param[in] len number of bytes to read + + @note We can not reserve @a len bytes for the result, because @a len + may be too large. Usually, @ref check_eof() detects the end of + the input before we run out of string memory. + + @return string created by reading @a len bytes + + @throw parse_error.110 if input has less than @a len bytes + */ + template + std::string get_string(const NumberType len) + { + std::string result; + std::generate_n(std::back_inserter(result), len, [this]() + { + get(); + check_eof(); + return static_cast(current); + }); + return result; + } + + /*! + @brief reads a CBOR string + + This function first reads starting bytes to determine the expected + string length and then copies this number of bytes into a string. + Additionally, CBOR's strings with indefinite lengths are supported. + + @return string + + @throw parse_error.110 if input ended + @throw parse_error.113 if an unexpected byte is read + */ + std::string get_cbor_string() + { + check_eof(); + + switch (current) + { + // 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: + { + return get_string(current & 0x1f); + } + + case 0x78: // UTF-8 string (one-byte uint8_t for n follows) + { + return get_string(get_number()); + } + + case 0x79: // UTF-8 string (two-byte uint16_t for n follow) + { + return get_string(get_number()); + } + + case 0x7a: // UTF-8 string (four-byte uint32_t for n follow) + { + return get_string(get_number()); + } + + case 0x7b: // UTF-8 string (eight-byte uint64_t for n follow) + { + return get_string(get_number()); + } + + case 0x7f: // UTF-8 string (indefinite length) + { + std::string result; + while (get() != 0xff) + { + check_eof(); + result.push_back(static_cast(current)); + } + return result; + } + + default: + { + std::stringstream ss; + ss << std::setw(2) << std::setfill('0') << std::hex << current; + JSON_THROW(parse_error::create(113, chars_read, "expected a CBOR string; last byte: 0x" + ss.str())); + } + } + } + + template + BasicJsonType get_cbor_array(const NumberType len) + { + BasicJsonType result = value_t::array; + std::generate_n(std::back_inserter(*result.m_value.array), len, [this]() + { + return parse_cbor_internal(); + }); + return result; + } + + template + BasicJsonType get_cbor_object(const NumberType len) + { + BasicJsonType result = value_t::object; + std::generate_n(std::inserter(*result.m_value.object, + result.m_value.object->end()), + len, [this]() + { + get(); + auto key = get_cbor_string(); + auto val = parse_cbor_internal(); + return std::make_pair(std::move(key), std::move(val)); + }); + return result; + } + + /*! + @brief reads a MessagePack string + + This function first reads starting bytes to determine the expected + string length and then copies this number of bytes into a string. + + @return string + + @throw parse_error.110 if input ended + @throw parse_error.113 if an unexpected byte is read + */ + std::string get_msgpack_string() + { + check_eof(); + + switch (current) + { + // fixstr + 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: + case 0xb8: + case 0xb9: + case 0xba: + case 0xbb: + case 0xbc: + case 0xbd: + case 0xbe: + case 0xbf: + { + return get_string(current & 0x1f); + } + + case 0xd9: // str 8 + { + return get_string(get_number()); + } + + case 0xda: // str 16 + { + return get_string(get_number()); + } + + case 0xdb: // str 32 + { + return get_string(get_number()); + } + + default: + { + std::stringstream ss; + ss << std::setw(2) << std::setfill('0') << std::hex << current; + JSON_THROW(parse_error::create(113, chars_read, + "expected a MessagePack string; last byte: 0x" + ss.str())); + } + } + } + + template + BasicJsonType get_msgpack_array(const NumberType len) + { + BasicJsonType result = value_t::array; + std::generate_n(std::back_inserter(*result.m_value.array), len, [this]() + { + return parse_msgpack_internal(); + }); + return result; + } + + template + BasicJsonType get_msgpack_object(const NumberType len) + { + BasicJsonType result = value_t::object; + std::generate_n(std::inserter(*result.m_value.object, + result.m_value.object->end()), + len, [this]() + { + get(); + auto key = get_msgpack_string(); + auto val = parse_msgpack_internal(); + return std::make_pair(std::move(key), std::move(val)); + }); + return result; + } + + /*! + @brief check if input ended + @throw parse_error.110 if input ended + */ + void check_eof(const bool expect_eof = false) const + { + if (expect_eof) + { + if (JSON_UNLIKELY(current != std::char_traits::eof())) + { + JSON_THROW(parse_error::create(110, chars_read, "expected end of input")); + } + } + else + { + if (JSON_UNLIKELY(current == std::char_traits::eof())) + { + JSON_THROW(parse_error::create(110, chars_read, "unexpected end of input")); + } + } + } + + private: + /// input adapter + input_adapter_t ia = nullptr; + + /// the current character + int current = std::char_traits::eof(); + + /// the number of characters read + std::size_t chars_read = 0; + + /// whether we can assume little endianess + const bool is_little_endian = little_endianess(); +}; + +/*! +@brief serialization to CBOR and MessagePack values +*/ +template +class binary_writer +{ + public: + /*! + @brief create a binary writer + + @param[in] adapter output adapter to write to + */ + explicit binary_writer(output_adapter_t adapter) : oa(adapter) + { + assert(oa); + } + + /*! + @brief[in] j JSON value to serialize + */ + void write_cbor(const BasicJsonType& j) + { + switch (j.type()) + { + case value_t::null: + { + oa->write_character(static_cast(0xf6)); + break; + } + + case value_t::boolean: + { + oa->write_character(j.m_value.boolean + ? static_cast(0xf5) + : static_cast(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) + { + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_integer <= (std::numeric_limits::max)()) + { + oa->write_character(static_cast(0x18)); + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_integer <= (std::numeric_limits::max)()) + { + oa->write_character(static_cast(0x19)); + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_integer <= (std::numeric_limits::max)()) + { + oa->write_character(static_cast(0x1a)); + write_number(static_cast(j.m_value.number_integer)); + } + else + { + oa->write_character(static_cast(0x1b)); + write_number(static_cast(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) + { + write_number(static_cast(0x20 + positive_number)); + } + else if (positive_number <= (std::numeric_limits::max)()) + { + oa->write_character(static_cast(0x38)); + write_number(static_cast(positive_number)); + } + else if (positive_number <= (std::numeric_limits::max)()) + { + oa->write_character(static_cast(0x39)); + write_number(static_cast(positive_number)); + } + else if (positive_number <= (std::numeric_limits::max)()) + { + oa->write_character(static_cast(0x3a)); + write_number(static_cast(positive_number)); + } + else + { + oa->write_character(static_cast(0x3b)); + write_number(static_cast(positive_number)); + } + } + break; + } + + case value_t::number_unsigned: + { + if (j.m_value.number_unsigned <= 0x17) + { + write_number(static_cast(j.m_value.number_unsigned)); + } + else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) + { + oa->write_character(static_cast(0x18)); + write_number(static_cast(j.m_value.number_unsigned)); + } + else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) + { + oa->write_character(static_cast(0x19)); + write_number(static_cast(j.m_value.number_unsigned)); + } + else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) + { + oa->write_character(static_cast(0x1a)); + write_number(static_cast(j.m_value.number_unsigned)); + } + else + { + oa->write_character(static_cast(0x1b)); + write_number(static_cast(j.m_value.number_unsigned)); + } + break; + } + + case value_t::number_float: // Double-Precision Float + { + oa->write_character(static_cast(0xfb)); + write_number(j.m_value.number_float); + break; + } + + case value_t::string: + { + // step 1: write control byte and the string length + const auto N = j.m_value.string->size(); + if (N <= 0x17) + { + write_number(static_cast(0x60 + N)); + } + else if (N <= 0xff) + { + oa->write_character(static_cast(0x78)); + write_number(static_cast(N)); + } + else if (N <= 0xffff) + { + oa->write_character(static_cast(0x79)); + write_number(static_cast(N)); + } + else if (N <= 0xffffffff) + { + oa->write_character(static_cast(0x7a)); + write_number(static_cast(N)); + } + // LCOV_EXCL_START + else if (N <= 0xffffffffffffffff) + { + oa->write_character(static_cast(0x7b)); + write_number(static_cast(N)); + } + // LCOV_EXCL_STOP + + // step 2: write the string + oa->write_characters( + reinterpret_cast(j.m_value.string->c_str()), + j.m_value.string->size()); + break; + } + + case value_t::array: + { + // step 1: write control byte and the array size + const auto N = j.m_value.array->size(); + if (N <= 0x17) + { + write_number(static_cast(0x80 + N)); + } + else if (N <= 0xff) + { + oa->write_character(static_cast(0x98)); + write_number(static_cast(N)); + } + else if (N <= 0xffff) + { + oa->write_character(static_cast(0x99)); + write_number(static_cast(N)); + } + else if (N <= 0xffffffff) + { + oa->write_character(static_cast(0x9a)); + write_number(static_cast(N)); + } + // LCOV_EXCL_START + else if (N <= 0xffffffffffffffff) + { + oa->write_character(static_cast(0x9b)); + write_number(static_cast(N)); + } + // LCOV_EXCL_STOP + + // step 2: write each element + for (const auto& el : *j.m_value.array) + { + write_cbor(el); + } + break; + } + + case value_t::object: + { + // step 1: write control byte and the object size + const auto N = j.m_value.object->size(); + if (N <= 0x17) + { + write_number(static_cast(0xa0 + N)); + } + else if (N <= 0xff) + { + oa->write_character(static_cast(0xb8)); + write_number(static_cast(N)); + } + else if (N <= 0xffff) + { + oa->write_character(static_cast(0xb9)); + write_number(static_cast(N)); + } + else if (N <= 0xffffffff) + { + oa->write_character(static_cast(0xba)); + write_number(static_cast(N)); + } + // LCOV_EXCL_START + else if (N <= 0xffffffffffffffff) + { + oa->write_character(static_cast(0xbb)); + write_number(static_cast(N)); + } + // LCOV_EXCL_STOP + + // step 2: write each element + for (const auto& el : *j.m_value.object) + { + write_cbor(el.first); + write_cbor(el.second); + } + break; + } + + default: + break; + } + } + + /*! + @brief[in] j JSON value to serialize + */ + void write_msgpack(const BasicJsonType& j) + { + switch (j.type()) + { + case value_t::null: // nil + { + oa->write_character(static_cast(0xc0)); + break; + } + + case value_t::boolean: // true and false + { + oa->write_character(j.m_value.boolean + ? static_cast(0xc3) + : static_cast(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 + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) + { + // uint 8 + oa->write_character(static_cast(0xcc)); + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) + { + // uint 16 + oa->write_character(static_cast(0xcd)); + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) + { + // uint 32 + oa->write_character(static_cast(0xce)); + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) + { + // uint 64 + oa->write_character(static_cast(0xcf)); + write_number(static_cast(j.m_value.number_integer)); + } + } + else + { + if (j.m_value.number_integer >= -32) + { + // negative fixnum + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_integer >= (std::numeric_limits::min)() and + j.m_value.number_integer <= (std::numeric_limits::max)()) + { + // int 8 + oa->write_character(static_cast(0xd0)); + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_integer >= (std::numeric_limits::min)() and + j.m_value.number_integer <= (std::numeric_limits::max)()) + { + // int 16 + oa->write_character(static_cast(0xd1)); + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_integer >= (std::numeric_limits::min)() and + j.m_value.number_integer <= (std::numeric_limits::max)()) + { + // int 32 + oa->write_character(static_cast(0xd2)); + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_integer >= (std::numeric_limits::min)() and + j.m_value.number_integer <= (std::numeric_limits::max)()) + { + // int 64 + oa->write_character(static_cast(0xd3)); + write_number(static_cast(j.m_value.number_integer)); + } + } + break; + } + + case value_t::number_unsigned: + { + if (j.m_value.number_unsigned < 128) + { + // positive fixnum + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) + { + // uint 8 + oa->write_character(static_cast(0xcc)); + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) + { + // uint 16 + oa->write_character(static_cast(0xcd)); + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) + { + // uint 32 + oa->write_character(static_cast(0xce)); + write_number(static_cast(j.m_value.number_integer)); + } + else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) + { + // uint 64 + oa->write_character(static_cast(0xcf)); + write_number(static_cast(j.m_value.number_integer)); + } + break; + } + + case value_t::number_float: // float 64 + { + oa->write_character(static_cast(0xcb)); + write_number(j.m_value.number_float); + break; + } + + case value_t::string: + { + // step 1: write control byte and the string length + const auto N = j.m_value.string->size(); + if (N <= 31) + { + // fixstr + write_number(static_cast(0xa0 | N)); + } + else if (N <= 255) + { + // str 8 + oa->write_character(static_cast(0xd9)); + write_number(static_cast(N)); + } + else if (N <= 65535) + { + // str 16 + oa->write_character(static_cast(0xda)); + write_number(static_cast(N)); + } + else if (N <= 4294967295) + { + // str 32 + oa->write_character(static_cast(0xdb)); + write_number(static_cast(N)); + } + + // step 2: write the string + oa->write_characters( + reinterpret_cast(j.m_value.string->c_str()), + j.m_value.string->size()); + break; + } + + case value_t::array: + { + // step 1: write control byte and the array size + const auto N = j.m_value.array->size(); + if (N <= 15) + { + // fixarray + write_number(static_cast(0x90 | N)); + } + else if (N <= 0xffff) + { + // array 16 + oa->write_character(static_cast(0xdc)); + write_number(static_cast(N)); + } + else if (N <= 0xffffffff) + { + // array 32 + oa->write_character(static_cast(0xdd)); + write_number(static_cast(N)); + } + + // step 2: write each element + for (const auto& el : *j.m_value.array) + { + write_msgpack(el); + } + break; + } + + case value_t::object: + { + // step 1: write control byte and the object size + const auto N = j.m_value.object->size(); + if (N <= 15) + { + // fixmap + write_number(static_cast(0x80 | (N & 0xf))); + } + else if (N <= 65535) + { + // map 16 + oa->write_character(static_cast(0xde)); + write_number(static_cast(N)); + } + else if (N <= 4294967295) + { + // map 32 + oa->write_character(static_cast(0xdf)); + write_number(static_cast(N)); + } + + // step 2: write each element + for (const auto& el : *j.m_value.object) + { + write_msgpack(el.first); + write_msgpack(el.second); + } + break; + } + + default: + break; + } + } + + private: + /* + @brief write a number to output input + + @param[in] n number of type @a NumberType + @tparam NumberType the type of the number + + @note This function needs to respect the system's endianess, because bytes + in CBOR and MessagePack are stored in network order (big endian) and + therefore need reordering on little endian systems. + */ + template void write_number(NumberType n) + { + // step 1: write number to array of length NumberType + std::array vec; + std::memcpy(vec.data(), &n, sizeof(NumberType)); + + // step 2: write array to output (with possible reordering) + if (is_little_endian) + { + // reverse byte order prior to conversion if necessary + std::reverse(vec.begin(), vec.end()); + } + + oa->write_characters(vec.data(), sizeof(NumberType)); + } + + private: + /// whether we can assume little endianess + const bool is_little_endian = binary_reader::little_endianess(); + + /// the output + output_adapter_t oa = nullptr; +}; + +/////////////////// +// serialization // +/////////////////// + +template +class serializer +{ + using string_t = typename BasicJsonType::string_t; + using number_float_t = typename BasicJsonType::number_float_t; + using number_integer_t = typename BasicJsonType::number_integer_t; + using number_unsigned_t = typename BasicJsonType::number_unsigned_t; + public: + /*! + @param[in] s output stream to serialize to + @param[in] ichar indentation character to use + */ + serializer(output_adapter_t s, const char ichar) + : o(std::move(s)), loc(std::localeconv()), + thousands_sep(loc->thousands_sep == nullptr ? '\0' : loc->thousands_sep[0]), + decimal_point(loc->decimal_point == nullptr ? '\0' : loc->decimal_point[0]), + indent_char(ichar), indent_string(512, indent_char) {} + + // delete because of pointer members + serializer(const serializer&) = delete; + serializer& operator=(const serializer&) = delete; + + /*! + @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. + + - 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[in] val value to serialize + @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(const BasicJsonType& val, const bool pretty_print, + const bool ensure_ascii, + const unsigned int indent_step, + const unsigned int current_indent = 0) + { + switch (val.m_type) + { + case value_t::object: + { + if (val.m_value.object->empty()) + { + o->write_characters("{}", 2); + return; + } + + if (pretty_print) + { + o->write_characters("{\n", 2); + + // variable to hold indentation for recursive calls + const auto new_indent = current_indent + indent_step; + if (JSON_UNLIKELY(indent_string.size() < new_indent)) + { + indent_string.resize(indent_string.size() * 2, ' '); + } + + // first n-1 elements + auto i = val.m_value.object->cbegin(); + for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i) + { + o->write_characters(indent_string.c_str(), new_indent); + o->write_character('\"'); + dump_escaped(i->first, ensure_ascii); + o->write_characters("\": ", 3); + dump(i->second, true, ensure_ascii, indent_step, new_indent); + o->write_characters(",\n", 2); + } + + // last element + assert(i != val.m_value.object->cend()); + assert(std::next(i) == val.m_value.object->cend()); + o->write_characters(indent_string.c_str(), new_indent); + o->write_character('\"'); + dump_escaped(i->first, ensure_ascii); + o->write_characters("\": ", 3); + dump(i->second, true, ensure_ascii, indent_step, new_indent); + + o->write_character('\n'); + o->write_characters(indent_string.c_str(), current_indent); + o->write_character('}'); + } + else + { + o->write_character('{'); + + // first n-1 elements + auto i = val.m_value.object->cbegin(); + for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i) + { + o->write_character('\"'); + dump_escaped(i->first, ensure_ascii); + o->write_characters("\":", 2); + dump(i->second, false, ensure_ascii, indent_step, current_indent); + o->write_character(','); + } + + // last element + assert(i != val.m_value.object->cend()); + assert(std::next(i) == val.m_value.object->cend()); + o->write_character('\"'); + dump_escaped(i->first, ensure_ascii); + o->write_characters("\":", 2); + dump(i->second, false, ensure_ascii, indent_step, current_indent); + + o->write_character('}'); + } + + return; + } + + case value_t::array: + { + if (val.m_value.array->empty()) + { + o->write_characters("[]", 2); + return; + } + + if (pretty_print) + { + o->write_characters("[\n", 2); + + // variable to hold indentation for recursive calls + const auto new_indent = current_indent + indent_step; + if (JSON_UNLIKELY(indent_string.size() < new_indent)) + { + indent_string.resize(indent_string.size() * 2, ' '); + } + + // first n-1 elements + for (auto i = val.m_value.array->cbegin(); + i != val.m_value.array->cend() - 1; ++i) + { + o->write_characters(indent_string.c_str(), new_indent); + dump(*i, true, ensure_ascii, indent_step, new_indent); + o->write_characters(",\n", 2); + } + + // last element + assert(not val.m_value.array->empty()); + o->write_characters(indent_string.c_str(), new_indent); + dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent); + + o->write_character('\n'); + o->write_characters(indent_string.c_str(), current_indent); + o->write_character(']'); + } + else + { + o->write_character('['); + + // first n-1 elements + for (auto i = val.m_value.array->cbegin(); + i != val.m_value.array->cend() - 1; ++i) + { + dump(*i, false, ensure_ascii, indent_step, current_indent); + o->write_character(','); + } + + // last element + assert(not val.m_value.array->empty()); + dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent); + + o->write_character(']'); + } + + return; + } + + case value_t::string: + { + o->write_character('\"'); + dump_escaped(*val.m_value.string, ensure_ascii); + o->write_character('\"'); + return; + } + + case value_t::boolean: + { + if (val.m_value.boolean) + { + o->write_characters("true", 4); + } + else + { + o->write_characters("false", 5); + } + return; + } + + case value_t::number_integer: + { + dump_integer(val.m_value.number_integer); + return; + } + + case value_t::number_unsigned: + { + dump_integer(val.m_value.number_unsigned); + return; + } + + case value_t::number_float: + { + dump_float(val.m_value.number_float); + return; + } + + case value_t::discarded: + { + o->write_characters("", 11); + return; + } + + case value_t::null: + { + o->write_characters("null", 4); + return; + } + } + } + + private: + /*! + @brief returns the number of expected bytes following in UTF-8 string + + @param[in] u the first byte of a UTF-8 string + @return the number of expected bytes following + */ + static constexpr std::size_t bytes_following(const uint8_t u) + { + return ((u <= 127) ? 0 + : ((192 <= u and u <= 223) ? 1 + : ((224 <= u and u <= 239) ? 2 + : ((240 <= u and u <= 247) ? 3 : std::string::npos)))); + } + + /*! + @brief calculates the extra space to escape a JSON string + + @param[in] s the string to escape + @param[in] ensure_ascii whether to escape non-ASCII characters with + \uXXXX sequences + @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, + const bool ensure_ascii) noexcept + { + std::size_t res = 0; + + for (std::size_t i = 0; i < s.size(); ++i) + { + switch (s[i]) + { + // control characters that can be escaped with a backslash + case '"': + case '\\': + case '\b': + case '\f': + case '\n': + case '\r': + case '\t': + { + // from c (1 byte) to \x (2 bytes) + res += 1; + break; + } + + // control characters that need \uxxxx escaping + case 0x00: + case 0x01: + case 0x02: + case 0x03: + case 0x04: + case 0x05: + case 0x06: + case 0x07: + case 0x0b: + case 0x0e: + case 0x0f: + case 0x10: + case 0x11: + case 0x12: + case 0x13: + case 0x14: + case 0x15: + case 0x16: + case 0x17: + case 0x18: + case 0x19: + case 0x1a: + case 0x1b: + case 0x1c: + case 0x1d: + case 0x1e: + case 0x1f: + { + // from c (1 byte) to \uxxxx (6 bytes) + res += 5; + break; + } + + default: + { + if (ensure_ascii and (s[i] & 0x80 or s[i] == 0x7F)) + { + const auto bytes = bytes_following(static_cast(s[i])); + if (bytes == std::string::npos) + { + // invalid characters are treated as is, so no + // additional space will be used + break; + } + + if (bytes == 3) + { + // codepoints that need 4 bytes (i.e., 3 additional + // bytes) in UTF-8 need a surrogate pair when \u + // escaping is used: from 4 bytes to \uxxxx\uxxxx + // (12 bytes) + res += (12 - bytes - 1); + } + else + { + // from x bytes to \uxxxx (6 bytes) + res += (6 - bytes - 1); + } + + // skip the additional bytes + i += bytes; + } + break; + } + } + } + + return res; + } + + static void escape_codepoint(int codepoint, string_t& result, std::size_t& pos) + { + // expecting a proper codepoint + assert(0x00 <= codepoint and codepoint <= 0x10FFFF); + + // the last written character was the backslash before the 'u' + assert(result[pos] == '\\'); + + // write the 'u' + result[++pos] = 'u'; + + // convert a number 0..15 to its hex representation (0..f) + static const std::array hexify = + { + { + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' + } + }; + + if (codepoint < 0x10000) + { + // codepoints U+0000..U+FFFF can be represented as \uxxxx. + result[++pos] = hexify[(codepoint >> 12) & 0x0F]; + result[++pos] = hexify[(codepoint >> 8) & 0x0F]; + result[++pos] = hexify[(codepoint >> 4) & 0x0F]; + result[++pos] = hexify[codepoint & 0x0F]; + } + else + { + // codepoints U+10000..U+10FFFF need a surrogate pair to be + // represented as \uxxxx\uxxxx. + // http://www.unicode.org/faq/utf_bom.html#utf16-4 + codepoint -= 0x10000; + const int high_surrogate = 0xD800 | ((codepoint >> 10) & 0x3FF); + const int low_surrogate = 0xDC00 | (codepoint & 0x3FF); + result[++pos] = hexify[(high_surrogate >> 12) & 0x0F]; + result[++pos] = hexify[(high_surrogate >> 8) & 0x0F]; + result[++pos] = hexify[(high_surrogate >> 4) & 0x0F]; + result[++pos] = hexify[high_surrogate & 0x0F]; + ++pos; // backslash is already in output + result[++pos] = 'u'; + result[++pos] = hexify[(low_surrogate >> 12) & 0x0F]; + result[++pos] = hexify[(low_surrogate >> 8) & 0x0F]; + result[++pos] = hexify[(low_surrogate >> 4) & 0x0F]; + result[++pos] = hexify[low_surrogate & 0x0F]; + } + + ++pos; + } + + /*! + @brief dump escaped 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. The escaped string is written to output stream @a o. + + @param[in] s the string to escape + @param[in] ensure_ascii whether to escape non-ASCII characters with + \uXXXX sequences + + @complexity Linear in the length of string @a s. + */ + void dump_escaped(const string_t& s, const bool ensure_ascii) const + { + const auto space = extra_space(s, ensure_ascii); + if (space == 0) + { + o->write_characters(s.c_str(), s.size()); + return; + } + + // create a result string of necessary size + string_t result(s.size() + space, '\\'); + std::size_t pos = 0; + + for (std::size_t i = 0; i < s.size(); ++i) + { + switch (s[i]) + { + case '"': // quotation mark (0x22) + { + result[pos + 1] = '"'; + pos += 2; + break; + } + + case '\\': // reverse solidus (0x5c) + { + // nothing to change + pos += 2; + break; + } + + case '\b': // backspace (0x08) + { + result[pos + 1] = 'b'; + pos += 2; + break; + } + + case '\f': // formfeed (0x0c) + { + result[pos + 1] = 'f'; + pos += 2; + break; + } + + case '\n': // newline (0x0a) + { + result[pos + 1] = 'n'; + pos += 2; + break; + } + + case '\r': // carriage return (0x0d) + { + result[pos + 1] = 'r'; + pos += 2; + break; + } + + case '\t': // horizontal tab (0x09) + { + result[pos + 1] = 't'; + pos += 2; + break; + } + + default: + { + // escape control characters (0x00..0x1F) or, if + // ensure_ascii parameter is used, non-ASCII characters + if ((0x00 <= s[i] and s[i] <= 0x1F) or + (ensure_ascii and (s[i] & 0x80 or s[i] == 0x7F))) + { + const auto bytes = bytes_following(static_cast(s[i])); + if (bytes == std::string::npos) + { + // copy invalid character as is + result[pos++] = s[i]; + break; + } + + // check that the additional bytes are present + assert(i + bytes < s.size()); + + // to use \uxxxx escaping, we first need to caluclate + // the codepoint from the UTF-8 bytes + int codepoint = 0; + + assert(0 <= bytes and bytes <= 3); + switch (bytes) + { + case 0: + { + codepoint = s[i] & 0xFF; + break; + } + + case 1: + { + codepoint = ((s[i] & 0x3F) << 6) + + (s[i + 1] & 0x7F); + break; + } + + case 2: + { + codepoint = ((s[i] & 0x1F) << 12) + + ((s[i + 1] & 0x7F) << 6) + + (s[i + 2] & 0x7F); + break; + } + + case 3: + { + codepoint = ((s[i] & 0xF) << 18) + + ((s[i + 1] & 0x7F) << 12) + + ((s[i + 2] & 0x7F) << 6) + + (s[i + 3] & 0x7F); + break; + } + + default: + break; // LCOV_EXCL_LINE + } + + escape_codepoint(codepoint, result, pos); + i += bytes; + } + else + { + // all other characters are added as-is + result[pos++] = s[i]; + } + break; + } + } + } + + assert(pos == result.size()); + o->write_characters(result.c_str(), result.size()); + } + + /*! + @brief dump an integer + + Dump a given integer to output stream @a o. Works internally with + @a number_buffer. + + @param[in] x integer number (signed or unsigned) to dump + @tparam NumberType either @a number_integer_t or @a number_unsigned_t + */ + template < + typename NumberType, + detail::enable_if_t::value or + std::is_same::value, + int> = 0 > + void dump_integer(NumberType x) + { + // special case for "0" + if (x == 0) + { + o->write_character('0'); + return; + } + + const bool is_negative = (x <= 0) and (x != 0); // see issue #755 + std::size_t i = 0; + + while (x != 0) + { + // spare 1 byte for '\0' + assert(i < number_buffer.size() - 1); + + const auto digit = std::labs(static_cast(x % 10)); + number_buffer[i++] = static_cast('0' + digit); + x /= 10; + } + + if (is_negative) + { + // make sure there is capacity for the '-' + assert(i < number_buffer.size() - 2); + number_buffer[i++] = '-'; + } + + std::reverse(number_buffer.begin(), number_buffer.begin() + i); + o->write_characters(number_buffer.data(), i); + } + + /*! + @brief dump a floating-point number + + Dump a given floating-point number to output stream @a o. Works internally + with @a number_buffer. + + @param[in] x floating-point number to dump + */ + void dump_float(number_float_t x) + { + // NaN / inf + if (not std::isfinite(x) or std::isnan(x)) + { + o->write_characters("null", 4); + return; + } + + // get number of digits for a text -> float -> text round-trip + static constexpr auto d = std::numeric_limits::digits10; + + // the actual conversion + std::ptrdiff_t len = snprintf(number_buffer.data(), number_buffer.size(), "%.*g", d, x); + + // negative value indicates an error + assert(len > 0); + // check if buffer was large enough + assert(static_cast(len) < number_buffer.size()); + + // erase thousands separator + if (thousands_sep != '\0') + { + const auto end = std::remove(number_buffer.begin(), + number_buffer.begin() + len, thousands_sep); + std::fill(end, number_buffer.end(), '\0'); + assert((end - number_buffer.begin()) <= len); + len = (end - number_buffer.begin()); + } + + // convert decimal point to '.' + if (decimal_point != '\0' and decimal_point != '.') + { + const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point); + if (dec_pos != number_buffer.end()) + { + *dec_pos = '.'; + } + } + + o->write_characters(number_buffer.data(), static_cast(len)); + + // determine if need to append ".0" + const bool value_is_int_like = + std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1, + [](char c) + { + return (c == '.' or c == 'e'); + }); + + if (value_is_int_like) + { + o->write_characters(".0", 2); + } + } + + private: + /// the output of the serializer + output_adapter_t o = nullptr; + + /// a (hopefully) large enough character buffer + std::array number_buffer{{}}; + + /// the locale + const std::lconv* loc = nullptr; + /// the locale's thousand separator character + const char thousands_sep = '\0'; + /// the locale's decimal point character + const char decimal_point = '\0'; + + /// the indentation character + const char indent_char; + + /// the indentation string + string_t indent_string; +}; + +template +class json_ref +{ + public: + using value_type = BasicJsonType; + + json_ref(value_type&& value) + : owned_value(std::move(value)), + value_ref(&owned_value), + is_rvalue(true) + {} + + json_ref(const value_type& value) + : value_ref(const_cast(&value)), + is_rvalue(false) + {} + + json_ref(std::initializer_list init) + : owned_value(init), + value_ref(&owned_value), + is_rvalue(true) + {} + + template + json_ref(Args&&... args) + : owned_value(std::forward(args)...), + value_ref(&owned_value), + is_rvalue(true) + {} + + // class should be movable only + json_ref(json_ref&&) = default; + json_ref(const json_ref&) = delete; + json_ref& operator=(const json_ref&) = delete; + + value_type moved_or_copied() const + { + if (is_rvalue) + { + return std::move(*value_ref); + } + return *value_ref; + } + + value_type const& operator*() const + { + return *static_cast(value_ref); + } + + value_type const* operator->() const + { + return static_cast(value_ref); + } + + private: + mutable value_type owned_value = nullptr; + value_type* value_ref = nullptr; + const bool is_rvalue; +}; + +} // namespace detail + +/// namespace to hold default `to_json` / `from_json` functions +namespace +{ +constexpr const auto& to_json = detail::static_const::value; +constexpr const auto& from_json = detail::static_const::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 +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 + static void from_json(BasicJsonType&& j, ValueType& val) noexcept( + noexcept(::nlohmann::from_json(std::forward(j), val))) + { + ::nlohmann::from_json(std::forward(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 + static void to_json(BasicJsonType& j, ValueType&& val) noexcept( + noexcept(::nlohmann::to_json(j, std::forward(val)))) + { + ::nlohmann::to_json(j, std::forward(val)); + } +}; + +/*! +@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 + NLOHMANN_BASIC_JSON_TPL_DECLARATION + 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 parse_error.107 if the given JSON pointer @a s is nonempty and + does not begin with a slash (`/`); see example below + + @throw parse_error.108 if a tilde (`~`) in the given JSON pointer @a s + is not followed by `0` (representing `~`) or `1` (representing `/`); + see example below + + @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: + /*! + @brief remove and return last reference pointer + @throw out_of_range.405 if JSON pointer has no parent + */ + std::string pop_back() + { + if (JSON_UNLIKELY(is_root())) + { + JSON_THROW(detail::out_of_range::create(405, "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 (JSON_UNLIKELY(is_root())) + { + JSON_THROW(detail::out_of_range::create(405, "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. + + @throw parse_error.109 if array index is not a number + @throw type_error.313 if value cannot be unflattened + */ + NLOHMANN_BASIC_JSON_TPL_DECLARATION + NLOHMANN_BASIC_JSON_TPL& get_and_create(NLOHMANN_BASIC_JSON_TPL& j) const; + + /*! + @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 parse_error.106 if an array index begins with '0' + @throw parse_error.109 if an array index was not a number + @throw out_of_range.404 if the JSON pointer can not be resolved + */ + NLOHMANN_BASIC_JSON_TPL_DECLARATION + NLOHMANN_BASIC_JSON_TPL& get_unchecked(NLOHMANN_BASIC_JSON_TPL* ptr) const; + + /*! + @throw parse_error.106 if an array index begins with '0' + @throw parse_error.109 if an array index was not a number + @throw out_of_range.402 if the array index '-' is used + @throw out_of_range.404 if the JSON pointer can not be resolved + */ + NLOHMANN_BASIC_JSON_TPL_DECLARATION + NLOHMANN_BASIC_JSON_TPL& get_checked(NLOHMANN_BASIC_JSON_TPL* ptr) const; + + /*! + @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 + + @throw parse_error.106 if an array index begins with '0' + @throw parse_error.109 if an array index was not a number + @throw out_of_range.402 if the array index '-' is used + @throw out_of_range.404 if the JSON pointer can not be resolved + */ + NLOHMANN_BASIC_JSON_TPL_DECLARATION + const NLOHMANN_BASIC_JSON_TPL& get_unchecked(const NLOHMANN_BASIC_JSON_TPL* ptr) const; + + /*! + @throw parse_error.106 if an array index begins with '0' + @throw parse_error.109 if an array index was not a number + @throw out_of_range.402 if the array index '-' is used + @throw out_of_range.404 if the JSON pointer can not be resolved + */ + NLOHMANN_BASIC_JSON_TPL_DECLARATION + const NLOHMANN_BASIC_JSON_TPL& get_checked(const NLOHMANN_BASIC_JSON_TPL* ptr) const; + + /*! + @brief split the string input to reference tokens + + @note This function is only called by the json_pointer constructor. + All exceptions below are documented there. + + @throw parse_error.107 if the pointer is not empty or begins with '/' + @throw parse_error.108 if character '~' is not followed by '0' or '1' + */ + static std::vector split(const std::string& reference_string) + { + std::vector result; + + // special case: empty reference string -> no reference tokens + if (reference_string.empty()) + { + return result; + } + + // check if nonempty reference string begins with slash + if (JSON_UNLIKELY(reference_string[0] != '/')) + { + JSON_THROW(detail::parse_error::create(107, 1, + "JSON pointer must be empty or begin with '/' - was: '" + + reference_string + "'")); + } + + // 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 + std::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 (std::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 (JSON_UNLIKELY(pos == reference_token.size() - 1 or + (reference_token[pos + 1] != '0' and + reference_token[pos + 1] != '1'))) + { + JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'")); + } + } + + // finally, store the reference token + unescape(reference_token); + result.push_back(reference_token); + } + + return result; + } + + /*! + @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. **This precondition is + enforced with an assertion.** + + @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 (auto 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, and + pos = s.find(f, pos + t.size())) // find next occurrence of f + {} + } + + /// escape "~"" to "~0" and "/" to "~1" + static std::string escape(std::string s) + { + replace_substring(s, "~", "~0"); + replace_substring(s, "/", "~1"); + return s; + } + + /// unescape "~1" to tilde and "~0" to slash (order is important!) + static void unescape(std::string& s) + { + replace_substring(s, "~1", "/"); + 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`. + */ + NLOHMANN_BASIC_JSON_TPL_DECLARATION + static void flatten(const std::string& reference_string, + const NLOHMANN_BASIC_JSON_TPL& value, + NLOHMANN_BASIC_JSON_TPL& result); + + /*! + @param[in] value flattened JSON + + @return unflattened JSON + + @throw parse_error.109 if array index is not a number + @throw type_error.314 if value is not an object + @throw type_error.315 if object values are not primitive + @throw type_error.313 if value cannot be unflattened + */ + NLOHMANN_BASIC_JSON_TPL_DECLARATION + static NLOHMANN_BASIC_JSON_TPL + unflatten(const NLOHMANN_BASIC_JSON_TPL& value); + + friend bool operator==(json_pointer const& lhs, + json_pointer const& rhs) noexcept; + + friend bool operator!=(json_pointer const& lhs, + json_pointer const& rhs) noexcept; + + /// the reference tokens + std::vector reference_tokens; +}; + +/*! +@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 +*/ +NLOHMANN_BASIC_JSON_TPL_DECLARATION +class basic_json +{ + private: + template friend struct detail::external_constructor; + friend ::nlohmann::json_pointer; + friend ::nlohmann::detail::parser; + friend ::nlohmann::detail::serializer; + template + friend class ::nlohmann::detail::iter_impl; + template + friend class ::nlohmann::detail::binary_writer; + template + friend class ::nlohmann::detail::binary_reader; + + /// workaround type for MSVC + using basic_json_t = NLOHMANN_BASIC_JSON_TPL; + + // convenience aliases for types residing in namespace detail; + using lexer = ::nlohmann::detail::lexer; + using parser = ::nlohmann::detail::parser; + + using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t; + template + using internal_iterator = ::nlohmann::detail::internal_iterator; + template + using iter_impl = ::nlohmann::detail::iter_impl; + template + using iteration_proxy = ::nlohmann::detail::iteration_proxy; + template using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator; + + template + using output_adapter_t = ::nlohmann::detail::output_adapter_t; + + using binary_reader = ::nlohmann::detail::binary_reader; + template using binary_writer = ::nlohmann::detail::binary_writer; + + using serializer = ::nlohmann::detail::serializer; + + public: + using value_t = detail::value_t; + // forward declarations + using json_pointer = ::nlohmann::json_pointer; + template + using json_serializer = JSONSerializer; + + using initializer_list_t = std::initializer_list>; + + //////////////// + // exceptions // + //////////////// + + /// @name exceptions + /// Classes to implement user-defined exceptions. + /// @{ + + /// @copydoc detail::exception + using exception = detail::exception; + /// @copydoc detail::parse_error + using parse_error = detail::parse_error; + /// @copydoc detail::invalid_iterator + using invalid_iterator = detail::invalid_iterator; + /// @copydoc detail::type_error + using type_error = detail::type_error; + /// @copydoc detail::out_of_range + using out_of_range = detail::out_of_range; + /// @copydoc detail::other_error + using other_error = detail::other_error; + + /// @} + + + ///////////////////// + // 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; + + /// the type of an element pointer + using pointer = typename std::allocator_traits::pointer; + /// the type of an element const pointer + using const_pointer = typename std::allocator_traits::const_pointer; + + /// an iterator for a basic_json container + using iterator = iter_impl; + /// a const iterator for a basic_json container + using const_iterator = iter_impl; + /// a reverse iterator for a basic_json container + using reverse_iterator = json_reverse_iterator; + /// a const reverse iterator for a basic_json container + using const_reverse_iterator = json_reverse_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} + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes to any JSON value. + + @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(__ICC) || defined(__INTEL_COMPILER) + result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}}; +#elif defined(__clang__) + result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}}; +#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` 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, // key_compare + std::allocator> // 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 explicitly constrained. + 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. + */ + +#if defined(JSON_HAS_CPP_14) + // Use transparent comparator if possible, combined with perfect forwarding + // on find() and count() calls prevents unnecessary string construction. + using object_comparator_t = std::less<>; +#else + using object_comparator_t = std::less; +#endif + using object_t = ObjectType>>; + + /*! + @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 // 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 explicitly constrained. + 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>; + + /*! + @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 + static T* create(Args&& ... args) + { + AllocatorType alloc; + auto deleter = [&](T * object) + { + alloc.deallocate(object, 1); + }; + std::unique_ptr object(alloc.allocate(1), deleter); + alloc.construct(object.get(), std::forward(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(); + break; + } + + case value_t::array: + { + array = create(); + break; + } + + case value_t::string: + { + string = create(""); + 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 (JSON_UNLIKELY(t == value_t::null)) + { + JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 2.1.1")); // LCOV_EXCL_LINE + } + break; + } + } + } + + /// constructor for strings + json_value(const string_t& value) + { + string = create(value); + } + + /// constructor for rvalue strings + json_value(string_t&& value) + { + string = create(std::move(value)); + } + + /// constructor for objects + json_value(const object_t& value) + { + object = create(value); + } + + /// constructor for rvalue objects + json_value(object_t&& value) + { + object = create(std::move(value)); + } + + /// constructor for arrays + json_value(const array_t& value) + { + array = create(value); + } + + /// constructor for rvalue arrays + json_value(array_t&& value) + { + array = create(std::move(value)); + } + + void destroy(value_t t) + { + switch (t) + { + case value_t::object: + { + AllocatorType alloc; + alloc.destroy(object); + alloc.deallocate(object, 1); + break; + } + + case value_t::array: + { + AllocatorType alloc; + alloc.destroy(array); + alloc.deallocate(array, 1); + break; + } + + case value_t::string: + { + AllocatorType alloc; + alloc.destroy(string); + alloc.deallocate(string, 1); + break; + } + + default: + { + break; + } + } + } + }; + + /*! + @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 // + ////////////////////////// + + using parse_event_t = typename parser::parse_event_t; + + /*! + @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, 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 for examples + + @since version 1.0.0 + */ + using parser_callback_t = typename parser::parser_callback_t; + + + ////////////////// + // 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] v the type of the value to create + + @complexity Constant. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes to any JSON value. + + @liveexample{The following code shows the constructor for different @ref + value_t values,basic_json__value_t} + + @sa @ref clear() -- restores the postcondition of this constructor + + @since version 1.0.0 + */ + basic_json(const value_t v) + : m_type(v), m_value(v) + { + 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::to_json` method + with `U = uncvref_t`, 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::valarray`, `std::set`, `std::unordered_set`, + `std::multiset`, and `std::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 has a + `to_json(basic_json_t&, CompatibleType&&)` method + + @tparam U = `uncvref_t` + + @param[in] val the value to be forwarded to the respective constructor + + @complexity Usually linear in the size of the passed @a val, also + depending on the implementation of the called `to_json()` + method. + + @exceptionsafety Depends on the called constructor. For types directly + supported by the library (i.e., all types for which no `to_json()` function + was provided), strong guarantee holds: if an exception is thrown, there are + no changes to any JSON value. + + @liveexample{The following code shows the constructor with several + compatible types.,basic_json__CompatibleType} + + @since version 2.1.0 + */ + template, + detail::enable_if_t::value and + not std::is_same::value and + not detail::is_basic_json_nested_type< + basic_json_t, U>::value and + detail::has_to_json::value, + int> = 0> + basic_json(CompatibleType && val) noexcept(noexcept(JSONSerializer::to_json( + std::declval(), std::forward(val)))) + { + JSONSerializer::to_json(*this, std::forward(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 no 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(initializer_list_t) + with an empty initializer list in this case + - arrays whose elements satisfy rule 2: use @ref + array(initializer_list_t) 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(initializer_list_t) and + @ref object(initializer_list_t). + + @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 type_error.301 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. In this case, the constructor could not + create an object. If @a type_deduction would have be `true`, an array + would have been created. See @ref object(initializer_list_t) + for an example. + + @complexity Linear in the size of the initializer list @a init. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes to any JSON value. + + @liveexample{The example below shows how JSON values are created from + initializer lists.,basic_json__list_init_t} + + @sa @ref array(initializer_list_t) -- create a JSON array + value from an initializer list + @sa @ref object(initializer_list_t) -- create a JSON object + value from an initializer list + + @since version 1.0.0 + */ + basic_json(initializer_list_t 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 detail::json_ref& element_ref) + { + return (element_ref->is_array() and element_ref->size() == 2 and (*element_ref)[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 (JSON_UNLIKELY(manual_type == value_t::object and not is_an_object)) + { + JSON_THROW(type_error::create(301, "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 detail::json_ref& element_ref) + { + auto element = element_ref.moved_or_copied(); + m_value.object->emplace( + std::move(*((*element.m_value.array)[0].m_value.string)), + std::move((*element.m_value.array)[1])); + }); + } + else + { + // the initializer list describes an array -> create array + m_type = value_t::array; + m_value.array = create(init.begin(), init.end()); + } + + 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(initializer_list_t, 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. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes to any JSON value. + + @liveexample{The following code shows an example for the `array` + function.,array} + + @sa @ref basic_json(initializer_list_t, bool, value_t) -- + create a JSON value from an initializer list + @sa @ref object(initializer_list_t) -- create a JSON object + value from an initializer list + + @since version 1.0.0 + */ + static basic_json array(initializer_list_t init = {}) + { + 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(initializer_list_t), 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(initializer_list_t, bool, value_t). + + @param[in] init initializer list to create an object from (optional) + + @return JSON object value + + @throw type_error.301 if @a init is not a list of pairs whose first + elements are strings. In this case, no object can be created. When such a + value is passed to @ref basic_json(initializer_list_t, bool, value_t), + an array would have been created from the passed initializer list @a init. + See example below. + + @complexity Linear in the size of @a init. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes to any JSON value. + + @liveexample{The following code shows an example for the `object` + function.,object} + + @sa @ref basic_json(initializer_list_t, bool, value_t) -- + create a JSON value from an initializer list + @sa @ref array(initializer_list_t) -- create a JSON array + value from an initializer list + + @since version 1.0.0 + */ + static basic_json object(initializer_list_t init = {}) + { + 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. + + @param[in] cnt the number of JSON copies of @a val to create + @param[in] val the JSON value to copy + + @post `std::distance(begin(),end()) == cnt` holds. + + @complexity Linear in @a cnt. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes to any JSON value. + + @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(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 a null type, invalid_iterator.206 is thrown. + - In case of other 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, invalid_iterator.204 is thrown. + - In case of structured types (array, object), the constructor behaves as + similar versions for `std::vector` or `std::map`; that is, a JSON array + or object is constructed from the values in the range. + + @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 (see warning).** If + assertions are switched off, a violation of this precondition yields + undefined behavior. + + @pre Range `[first, last)` is valid. Usually, this precondition cannot be + checked efficiently. Only certain edge cases are detected; see the + description of the exceptions below. A violation of this precondition + yields undefined behavior. + + @warning A precondition is enforced with a runtime assertion that will + result in calling `std::abort` if this precondition is not met. + Assertions can be disabled by defining `NDEBUG` at compile time. + See http://en.cppreference.com/w/cpp/error/assert for more + information. + + @throw invalid_iterator.201 if iterators @a first and @a last are not + compatible (i.e., do not belong to the same JSON value). In this case, + the range `[first, last)` is undefined. + @throw invalid_iterator.204 if iterators @a first and @a last belong to a + primitive type (number, boolean, or string), but @a first does not point + to the first element any more. In this case, the range `[first, last)` is + undefined. See example code below. + @throw invalid_iterator.206 if iterators @a first and @a last belong to a + null value. In this case, the range `[first, last)` is undefined. + + @complexity Linear in distance between @a first and @a last. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes to any JSON value. + + @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::value or + std::is_same::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 (JSON_UNLIKELY(first.m_object != last.m_object)) + { + JSON_THROW(invalid_iterator::create(201, "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 (JSON_UNLIKELY(not first.m_it.primitive_iterator.is_begin() + or not last.m_it.primitive_iterator.is_end())) + { + JSON_THROW(invalid_iterator::create(204, "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(first.m_it.object_iterator, + last.m_it.object_iterator); + break; + } + + case value_t::array: + { + m_value.array = create(first.m_it.array_iterator, + last.m_it.array_iterator); + break; + } + + default: + JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " + + std::string(first.m_object->type_name()))); + } + + assert_invariant(); + } + + + /////////////////////////////////////// + // other constructors and destructor // + /////////////////////////////////////// + + /// @private + basic_json(const detail::json_ref& ref) + : basic_json(ref.moved_or_copied()) + {} + + /*! + @brief copy constructor + + Creates a copy of a given JSON value. + + @param[in] other the JSON value to copy + + @post `*this == other` + + @complexity Linear in the size of @a other. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes to any JSON value. + + @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)`. + + @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 `*this` has the same value as @a other before the call. + @post @a other is a JSON null value. + + @complexity Constant. + + @exceptionsafety No-throw guarantee: this constructor never throws + exceptions. + + @requirement This function helps `basic_json` satisfying the + [MoveConstructible](http://en.cppreference.com/w/cpp/concept/MoveConstructible) + requirements. + + @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 and + std::is_nothrow_move_assignable::value and + std::is_nothrow_move_constructible::value and + std::is_nothrow_move_assignable::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(); + m_value.destroy(m_type); + } + + /// @} + + 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 + and @a ensure_ascii parameters. + + @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. + @param[in] indent_char The character to use for indentation if @a indent is + greater than `0`. The default is ` ` (space). + @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters + in the output are escaped with \uXXXX sequences, and the result consists + of ASCII characters only. + + @return string containing the serialization of the JSON value + + @complexity Linear. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes in the JSON value. + + @liveexample{The following example shows the effect of different @a indent\, + @a indent_char\, and @a ensure_ascii parameters to the result of the + serialization.,dump} + + @see https://docs.python.org/2/library/json.html#json.dump + + @since version 1.0.0; indentation character @a indent_char and option + @a ensure_ascii added in version 3.0.0 + */ + string_t dump(const int indent = -1, const char indent_char = ' ', + const bool ensure_ascii = false) const + { + string_t result; + serializer s(detail::output_adapter(result), indent_char); + + if (indent >= 0) + { + s.dump(*this, true, ensure_ascii, static_cast(indent)); + } + else + { + s.dump(*this, false, ensure_ascii, 0); + } + + return result; + } + + /*! + @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 + Value type | return value + ------------------------- | ------------------------- + null | value_t::null + boolean | value_t::boolean + string | value_t::string + number (integer) | value_t::number_integer + number (unsigned integer) | value_t::number_unsigned + number (foating-point) | value_t::number_float + object | value_t::object + array | value_t::array + discarded | value_t::discarded + + @complexity Constant. + + @exceptionsafety No-throw guarantee: this member function never throws + exceptions. + + @liveexample{The following code exemplifies `type()` for all JSON + types.,type} + + @sa @ref operator value_t() -- return the type of the JSON value (implicit) + @sa @ref type_name() -- return the type as string + + @since version 1.0.0 + */ + constexpr value_t type() const noexcept + { + return m_type; + } + + /*! + @brief return whether type is primitive + + This function returns true if and only if 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 if and only if 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 if and only if 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 if and only if 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 if and only if the JSON value is a number. This + includes both integer (signed and unsigned) 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 if and only if the JSON value is a signed 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 if and only if 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 if and only if the JSON value is a + floating-point number. This excludes signed 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 if and only if 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 if and only if 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 if and only if 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 if and only if 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} + + @sa @ref type() -- return the type of the JSON value (explicit) + @sa @ref type_name() -- return the type as string + + @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 (JSON_LIKELY(is_boolean())) + { + return m_value.boolean; + } + + JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(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 function 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 type_error.303 if ReferenceType does not match underlying value + type of the current JSON + */ + template + static ReferenceType get_ref_impl(ThisType& obj) + { + // delegate the call to get_ptr<>() + auto ptr = obj.template get_ptr::type>(); + + if (JSON_LIKELY(ptr != nullptr)) + { + return *ptr; + } + + JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(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::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 + `from_json()` method. + + The function is equivalent to executing + @code {.cpp} + ValueType ret; + JSONSerializer::from_json(*this, ret); + return ret; + @endcode + + This overloads is chosen if: + - @a ValueType is not @ref basic_json, + - @ref json_serializer has a `from_json()` method of the form + `void from_json(const basic_json&, ValueType&)`, and + - @ref json_serializer does not have a `from_json()` method of + the form `ValueType from_json(const 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 `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`\, (3) A JSON object can be converted to C++ + associative containers such as `std::unordered_map`.,get__ValueType_const} + + @since version 2.1.0 + */ + template < + typename ValueTypeCV, + typename ValueType = detail::uncvref_t, + detail::enable_if_t < + not std::is_same::value and + detail::has_from_json::value and + not detail::has_non_default_from_json::value, + int > = 0 > + ValueType get() const noexcept(noexcept( + JSONSerializer::from_json(std::declval(), std::declval()))) + { + // we cannot static_assert on ValueTypeCV being non-const, because + // there is support for get(), which is why we + // still need the uncvref + static_assert(not std::is_reference::value, + "get() cannot be used with reference types, you might want to use get_ref()"); + static_assert(std::is_default_constructible::value, + "types must be DefaultConstructible when used with get()"); + + ValueType ret; + JSONSerializer::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 + `from_json()` method. + + The function is equivalent to executing + @code {.cpp} + return JSONSerializer::from_json(*this); + @endcode + + This overloads is chosen if: + - @a ValueType is not @ref basic_json and + - @ref json_serializer has a `from_json()` method of the form + `ValueType from_json(const basic_json&)` + + @note If @ref json_serializer 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 `from_json()` method throws + + @since version 2.1.0 + */ + template < + typename ValueTypeCV, + typename ValueType = detail::uncvref_t, + detail::enable_if_t::value and + detail::has_non_default_from_json::value, int> = 0 > + ValueType get() const noexcept(noexcept( + JSONSerializer::from_json(std::declval()))) + { + static_assert(not std::is_reference::value, + "get() cannot be used with reference types, you might want to use get_ref()"); + return JSONSerializer::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::value, int>::type = 0> + PointerType get() noexcept + { + // delegate the call to get_ptr + return get_ptr(); + } + + /*! + @brief get a pointer value (explicit) + @copydoc get() + */ + template::value, int>::type = 0> + constexpr const PointerType get() const noexcept + { + // delegate the call to get_ptr + return get_ptr(); + } + + /*! + @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::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::type>::type>::type; + // make sure the type matches the allowed types + static_assert( + std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + , "incompatible pointer type"); + + // delegate the call to get_impl_ptr<>() + return get_impl_ptr(static_cast(nullptr)); + } + + /*! + @brief get a pointer value (implicit) + @copydoc get_ptr() + */ + template::value and + std::is_const::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::type>::type>::type; + // make sure the type matches the allowed types + static_assert( + std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + or std::is_same::value + , "incompatible pointer type"); + + // delegate the call to get_impl_ptr<>() const + return get_impl_ptr(static_cast(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 + type_error.303 otherwise + + @throw type_error.303 in case passed type @a ReferenceType is incompatible + with the stored JSON value; see example below + + @complexity Constant. + + @liveexample{The example shows several calls to `get_ref()`.,get_ref} + + @since version 1.1.0 + */ + template::value, int>::type = 0> + ReferenceType get_ref() + { + // delegate call to get_ref_impl + return get_ref_impl(*this); + } + + /*! + @brief get a reference value (implicit) + @copydoc get_ref() + */ + template::value and + std::is_const::type>::value, int>::type = 0> + ReferenceType get_ref() const + { + // delegate call to get_ref_impl + return get_ref_impl(*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 type_error.302 in case passed type @a ValueType is incompatible + to the JSON value type (e.g., the JSON value is of type boolean, but a + string is requested); see example below + + @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`\, (3) A JSON object can be converted to C++ + associative containers such as `std::unordered_map`.,operator__ValueType} + + @since version 1.0.0 + */ + template < typename ValueType, typename std::enable_if < + not std::is_pointer::value and + not std::is_same>::value and + not std::is_same::value +#ifndef _MSC_VER // fix for issue #167 operator<< ambiguity under VS2015 + and not std::is_same>::value +#endif +#if defined(JSON_HAS_CPP_17) + and not std::is_same::value +#endif + , int >::type = 0 > + operator ValueType() const + { + // delegate the call to get<>() const + return get(); + } + + /// @} + + + //////////////////// + // 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 type_error.304 if the JSON value is not an array; in this case, + calling `at` with an index makes no sense. See example below. + @throw out_of_range.401 if the index @a idx is out of range of the array; + that is, `idx >= size()`. See example below. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes in the JSON value. + + @complexity Constant. + + @since version 1.0.0 + + @liveexample{The example below shows how array elements can be read and + written using `at()`. It also demonstrates the different exceptions that + can be thrown.,at__size_type} + */ + reference at(size_type idx) + { + // at only works for arrays + if (JSON_LIKELY(is_array())) + { + JSON_TRY + { + return m_value.array->at(idx); + } + JSON_CATCH (std::out_of_range&) + { + // create better exception explanation + JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range")); + } + } + else + { + JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(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 type_error.304 if the JSON value is not an array; in this case, + calling `at` with an index makes no sense. See example below. + @throw out_of_range.401 if the index @a idx is out of range of the array; + that is, `idx >= size()`. See example below. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes in the JSON value. + + @complexity Constant. + + @since version 1.0.0 + + @liveexample{The example below shows how array elements can be read using + `at()`. It also demonstrates the different exceptions that can be thrown., + at__size_type_const} + */ + const_reference at(size_type idx) const + { + // at only works for arrays + if (JSON_LIKELY(is_array())) + { + JSON_TRY + { + return m_value.array->at(idx); + } + JSON_CATCH (std::out_of_range&) + { + // create better exception explanation + JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range")); + } + } + else + { + JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(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 type_error.304 if the JSON value is not an object; in this case, + calling `at` with a key makes no sense. See example below. + @throw out_of_range.403 if the key @a key is is not stored in the object; + that is, `find(key) == end()`. See example below. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes in the JSON value. + + @complexity Logarithmic in the size of the container. + + @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 + + @liveexample{The example below shows how object elements can be read and + written using `at()`. It also demonstrates the different exceptions that + can be thrown.,at__object_t_key_type} + */ + reference at(const typename object_t::key_type& key) + { + // at only works for objects + if (JSON_LIKELY(is_object())) + { + JSON_TRY + { + return m_value.object->at(key); + } + JSON_CATCH (std::out_of_range&) + { + // create better exception explanation + JSON_THROW(out_of_range::create(403, "key '" + key + "' not found")); + } + } + else + { + JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(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 type_error.304 if the JSON value is not an object; in this case, + calling `at` with a key makes no sense. See example below. + @throw out_of_range.403 if the key @a key is is not stored in the object; + that is, `find(key) == end()`. See example below. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes in the JSON value. + + @complexity Logarithmic in the size of the container. + + @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 + + @liveexample{The example below shows how object elements can be read using + `at()`. It also demonstrates the different exceptions that can be thrown., + at__object_t_key_type_const} + */ + const_reference at(const typename object_t::key_type& key) const + { + // at only works for objects + if (JSON_LIKELY(is_object())) + { + JSON_TRY + { + return m_value.object->at(key); + } + JSON_CATCH (std::out_of_range&) + { + // create better exception explanation + JSON_THROW(out_of_range::create(403, "key '" + key + "' not found")); + } + } + else + { + JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(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 type_error.305 if the JSON value is not an array or null; in that + cases, using the [] operator with an index makes no sense. + + @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(); + assert_invariant(); + } + + // operator[] only works for arrays + if (JSON_LIKELY(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(type_error::create(305, "cannot use operator[] with " + std::string(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 type_error.305 if the JSON value is not an array; in that cases, + using the [] operator with an index makes no sense. + + @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 (JSON_LIKELY(is_array())) + { + return m_value.array->operator[](idx); + } + + JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(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 type_error.305 if the JSON value is not an object or null; in that + cases, using the [] operator with a key makes no sense. + + @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(); + assert_invariant(); + } + + // operator[] only works for objects + if (JSON_LIKELY(is_object())) + { + return m_value.object->operator[](key); + } + + JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(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 type_error.305 if the JSON value is not an object; in that cases, + using the [] operator with a key makes no sense. + + @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 (JSON_LIKELY(is_object())) + { + assert(m_value.object->find(key) != m_value.object->end()); + return m_value.object->find(key)->second; + } + + JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(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 type_error.305 if the JSON value is not an object or null; in that + cases, using the [] operator with a key makes no sense. + + @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 + 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 (JSON_LIKELY(is_object())) + { + return m_value.object->operator[](key); + } + + JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(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 type_error.305 if the JSON value is not an object; in that cases, + using the [] operator with a key makes no sense. + + @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 + const_reference operator[](T* key) const + { + // at only works for objects + if (JSON_LIKELY(is_object())) + { + assert(m_value.object->find(key) != m_value.object->end()); + return m_value.object->find(key)->second; + } + + JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(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(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 type_error.306 if the JSON value is not an objec; in that cases, + using `value()` with a key makes no sense. + + @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::value, int>::type = 0> + ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const + { + // at only works for objects + if (JSON_LIKELY(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; + } + + JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(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(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 type_error.306 if the JSON value is not an objec; in that cases, + using `value()` with a key makes no sense. + + @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::value, int>::type = 0> + ValueType value(const json_pointer& ptr, const ValueType& default_value) const + { + // at only works for objects + if (JSON_LIKELY(is_object())) + { + // if pointer resolves a value, return it or use default value + JSON_TRY + { + return ptr.get_checked(this); + } + JSON_CATCH (out_of_range&) + { + return default_value; + } + } + + JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(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 invalid_iterator.214 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 invalid_iterator.214 when called on a `null` value. See example + below. + + @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 type_error.307 if called on a `null` value; example: `"cannot use + erase() with null"` + @throw invalid_iterator.202 if called on an iterator which does not belong + to the current JSON value; example: `"iterator does not fit current + value"` + @throw invalid_iterator.205 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::value or + std::is_same::value, int>::type + = 0> + IteratorType erase(IteratorType pos) + { + // make sure iterator fits the current value + if (JSON_UNLIKELY(this != pos.m_object)) + { + JSON_THROW(invalid_iterator::create(202, "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 (JSON_UNLIKELY(not pos.m_it.primitive_iterator.is_begin())) + { + JSON_THROW(invalid_iterator::create(205, "iterator out of range")); + } + + if (is_string()) + { + AllocatorType 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(type_error::create(307, "cannot use erase() with " + std::string(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 type_error.307 if called on a `null` value; example: `"cannot use + erase() with null"` + @throw invalid_iterator.203 if called on iterators which does not belong + to the current JSON value; example: `"iterators do not fit current value"` + @throw invalid_iterator.204 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::value or + std::is_same::value, int>::type + = 0> + IteratorType erase(IteratorType first, IteratorType last) + { + // make sure iterator fits the current value + if (JSON_UNLIKELY(this != first.m_object or this != last.m_object)) + { + JSON_THROW(invalid_iterator::create(203, "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 (JSON_LIKELY(not first.m_it.primitive_iterator.is_begin() + or not last.m_it.primitive_iterator.is_end())) + { + JSON_THROW(invalid_iterator::create(204, "iterators out of range")); + } + + if (is_string()) + { + AllocatorType 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(type_error::create(307, "cannot use erase() with " + std::string(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 type_error.307 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 (JSON_LIKELY(is_object())) + { + return m_value.object->erase(key); + } + + JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(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 type_error.307 when called on a type other than JSON object; + example: `"cannot use erase() with null"` + @throw out_of_range.401 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 (JSON_LIKELY(is_array())) + { + if (JSON_UNLIKELY(idx >= size())) + { + JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range")); + } + + m_value.array->erase(m_value.array->begin() + static_cast(idx)); + } + else + { + JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(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 + */ + template + iterator find(KeyT&& key) + { + auto result = end(); + + if (is_object()) + { + result.m_it.object_iterator = m_value.object->find(std::forward(key)); + } + + return result; + } + + /*! + @brief find an element in a JSON object + @copydoc find(KeyT&&) + */ + template + const_iterator find(KeyT&& key) const + { + auto result = cend(); + + if (is_object()) + { + result.m_it.object_iterator = m_value.object->find(std::forward(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 + */ + template + size_type count(KeyT&& key) const + { + // return 0 for all nonobject types + return is_object() ? m_value.object->count(std::forward(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(*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(*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(*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(*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()); + } + + 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. + + @liveexample{The following code shows how the wrapper is used,iterator_wrapper} + + @note The name of this function is not yet final and may change in the + future. + */ + static iteration_proxy iterator_wrapper(reference cont) + { + return iteration_proxy(cont); + } + + /*! + @copydoc iterator_wrapper(reference) + */ + static iteration_proxy iterator_wrapper(const_reference cont) + { + return iteration_proxy(cont); + } + + /// @} + + + ////////////// + // capacity // + ////////////// + + /// @name capacity + /// @{ + + /*! + @brief checks whether the container is empty. + + Checks if a JSON value has no elements (i.e. whether its @ref size is `0`). + + @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()` + + @liveexample{The following code uses `empty()` to check if a JSON + object contains any elements.,empty} + + @complexity Constant, as long as @ref array_t and @ref object_t satisfy + the Container concept; that is, their `empty()` functions have constant + complexity. + + @iterators No changes. + + @exceptionsafety No-throw guarantee: this function never throws exceptions. + + @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. + + @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()`. + + @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() + + @liveexample{The following code calls `size()` on the different value + types.,size} + + @complexity Constant, as long as @ref array_t and @ref object_t satisfy + the Container concept; that is, their size() functions have constant + complexity. + + @iterators No changes. + + @exceptionsafety No-throw guarantee: this function never throws exceptions. + + @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. + + @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())`. + + @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()` + + @liveexample{The following code calls `max_size()` on the different value + types. Note the output is implementation specific.,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. + + @iterators No changes. + + @exceptionsafety No-throw guarantee: this function never throws exceptions. + + @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. + + @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 with the current value + type from @ref type(): + + Value type | initial value + ----------- | ------------- + null | `null` + boolean | `false` + string | `""` + number | `0` + object | `{}` + array | `[]` + + @post Has the same effect as calling + @code {.cpp} + *this = basic_json(type()); + @endcode + + @liveexample{The example below shows the effect of `clear()` to different + JSON types.,clear} + + @complexity Linear in the size of the JSON value. + + @iterators All iterators, pointers and references related to this container + are invalidated. + + @exceptionsafety No-throw guarantee: this function never throws exceptions. + + @sa @ref basic_json(value_t) -- constructor that creates an object with the + same value than calling `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 type_error.308 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 (JSON_UNLIKELY(not(is_null() or is_array()))) + { + JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(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 (JSON_UNLIKELY(not(is_null() or is_array()))) + { + JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(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 type_error.308 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 (JSON_UNLIKELY(not(is_null() or is_object()))) + { + JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(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[in] 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`, 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(initializer_list_t init) + { + if (is_object() and init.size() == 2 and (*init.begin())->is_string()) + { + basic_json&& key = init.begin()->moved_or_copied(); + push_back(typename object_t::value_type( + std::move(key.get_ref()), (init.begin() + 1)->moved_or_copied())); + } + else + { + push_back(basic_json(init)); + } + } + + /*! + @brief add an object to an object + @copydoc push_back(initializer_list_t) + */ + reference operator+=(initializer_list_t 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 type_error.311 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 + void emplace_back(Args&& ... args) + { + // emplace_back only works for null objects or arrays + if (JSON_UNLIKELY(not(is_null() or is_array()))) + { + JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(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)...); + } + + /*! + @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 type_error.311 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 + std::pair emplace(Args&& ... args) + { + // emplace only works for null objects or arrays + if (JSON_UNLIKELY(not(is_null() or is_object()))) + { + JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(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)...); + // 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 type_error.309 if called on JSON values other than arrays; + example: `"cannot use insert() with string"` + @throw invalid_iterator.202 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 (JSON_LIKELY(is_array())) + { + // check if iterator pos fits to this JSON value + if (JSON_UNLIKELY(pos.m_object != this)) + { + JSON_THROW(invalid_iterator::create(202, "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(type_error::create(309, "cannot use insert() with " + std::string(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 type_error.309 if called on JSON values other than arrays; example: + `"cannot use insert() with string"` + @throw invalid_iterator.202 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 (JSON_LIKELY(is_array())) + { + // check if iterator pos fits to this JSON value + if (JSON_UNLIKELY(pos.m_object != this)) + { + JSON_THROW(invalid_iterator::create(202, "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(type_error::create(309, "cannot use insert() with " + std::string(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 type_error.309 if called on JSON values other than arrays; example: + `"cannot use insert() with string"` + @throw invalid_iterator.202 if @a pos is not an iterator of *this; + example: `"iterator does not fit current value"` + @throw invalid_iterator.210 if @a first and @a last do not belong to the + same JSON value; example: `"iterators do not fit"` + @throw invalid_iterator.211 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 (JSON_UNLIKELY(not is_array())) + { + JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()))); + } + + // check if iterator pos fits to this JSON value + if (JSON_UNLIKELY(pos.m_object != this)) + { + JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value")); + } + + // check if range iterators belong to the same JSON object + if (JSON_UNLIKELY(first.m_object != last.m_object)) + { + JSON_THROW(invalid_iterator::create(210, "iterators do not fit")); + } + + if (JSON_UNLIKELY(first.m_object == this)) + { + JSON_THROW(invalid_iterator::create(211, "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 type_error.309 if called on JSON values other than arrays; example: + `"cannot use insert() with string"` + @throw invalid_iterator.202 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, initializer_list_t ilist) + { + // insert only works for arrays + if (JSON_UNLIKELY(not is_array())) + { + JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()))); + } + + // check if iterator pos fits to this JSON value + if (JSON_UNLIKELY(pos.m_object != this)) + { + JSON_THROW(invalid_iterator::create(202, "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.begin(), ilist.end()); + return result; + } + + /*! + @brief inserts elements + + Inserts elements from range `[first, last)`. + + @param[in] first begin of the range of elements to insert + @param[in] last end of the range of elements to insert + + @throw type_error.309 if called on JSON values other than objects; example: + `"cannot use insert() with string"` + @throw invalid_iterator.202 if iterator @a first or @a last does does not + point to an object; example: `"iterators first and last must point to + objects"` + @throw invalid_iterator.210 if @a first and @a last do not belong to the + same JSON value; example: `"iterators do not fit"` + + @complexity Logarithmic: `O(N*log(size() + N))`, where `N` is the number + of elements to insert. + + @liveexample{The example shows how `insert()` is used.,insert__range_object} + + @since version 3.0.0 + */ + void insert(const_iterator first, const_iterator last) + { + // insert only works for objects + if (JSON_UNLIKELY(not is_object())) + { + JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()))); + } + + // check if range iterators belong to the same JSON object + if (JSON_UNLIKELY(first.m_object != last.m_object)) + { + JSON_THROW(invalid_iterator::create(210, "iterators do not fit")); + } + + // passed iterators must belong to objects + if (JSON_UNLIKELY(not first.m_object->is_object())) + { + JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects")); + } + + m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator); + } + + /*! + @brief updates a JSON object from another object, overwriting existing keys + + Inserts all values from JSON object @a j and overwrites existing keys. + + @param[in] j JSON object to read values from + + @throw type_error.312 if called on JSON values other than objects; example: + `"cannot use update() with string"` + + @complexity O(N*log(size() + N)), where N is the number of elements to + insert. + + @liveexample{The example shows how `update()` is used.,update} + + @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update + + @since version 3.0.0 + */ + void update(const_reference j) + { + // implicitly convert null value to an empty object + if (is_null()) + { + m_type = value_t::object; + m_value.object = create(); + assert_invariant(); + } + + if (JSON_UNLIKELY(not is_object())) + { + JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name()))); + } + if (JSON_UNLIKELY(not j.is_object())) + { + JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name()))); + } + + for (auto it = j.begin(); it != j.end(); ++it) + { + m_value.object->operator[](it.key()) = it.value(); + } + } + + /*! + @brief updates a JSON object from another object, overwriting existing keys + + Inserts all values from from range `[first, last)` and overwrites existing + keys. + + @param[in] first begin of the range of elements to insert + @param[in] last end of the range of elements to insert + + @throw type_error.312 if called on JSON values other than objects; example: + `"cannot use update() with string"` + @throw invalid_iterator.202 if iterator @a first or @a last does does not + point to an object; example: `"iterators first and last must point to + objects"` + @throw invalid_iterator.210 if @a first and @a last do not belong to the + same JSON value; example: `"iterators do not fit"` + + @complexity O(N*log(size() + N)), where N is the number of elements to + insert. + + @liveexample{The example shows how `update()` is used__range.,update} + + @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update + + @since version 3.0.0 + */ + void update(const_iterator first, const_iterator last) + { + // implicitly convert null value to an empty object + if (is_null()) + { + m_type = value_t::object; + m_value.object = create(); + assert_invariant(); + } + + if (JSON_UNLIKELY(not is_object())) + { + JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name()))); + } + + // check if range iterators belong to the same JSON object + if (JSON_UNLIKELY(first.m_object != last.m_object)) + { + JSON_THROW(invalid_iterator::create(210, "iterators do not fit")); + } + + // passed iterators must belong to objects + if (JSON_UNLIKELY(not first.m_object->is_object() + or not first.m_object->is_object())) + { + JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects")); + } + + for (auto it = first; it != last; ++it) + { + m_value.object->operator[](it.key()) = it.value(); + } + } + + /*! + @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 and + std::is_nothrow_move_assignable::value and + std::is_nothrow_move_constructible::value and + std::is_nothrow_move_assignable::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 type_error.310 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 (JSON_LIKELY(is_array())) + { + std::swap(*(m_value.array), other); + } + else + { + JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(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 type_error.310 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 (JSON_LIKELY(is_object())) + { + std::swap(*(m_value.object), other); + } + else + { + JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(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 type_error.310 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 (JSON_LIKELY(is_string())) + { + std::swap(*(m_value.string), other); + } + else + { + JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(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 according to their respective + `operator==`. + - Integer and floating-point numbers are automatically converted before + comparison. Note than two NaN values are always treated as unequal. + - Two JSON null values are equal. + + @note Floating-point inside JSON values numbers are compared with + `json::number_float_t::operator==` which is `double::operator==` by + default. To compare floating-point while respecting an epsilon, an alternative + [comparison function](https://github.com/mariokonrad/marnav/blob/master/src/marnav/math/floatingpoint.hpp#L34-#L39) + could be used, for instance + @code {.cpp} + template ::value, T>::type> + inline bool is_same(T a, T b, T epsilon = std::numeric_limits::epsilon()) noexcept + { + return std::abs(a - b) <= epsilon; + } + @endcode + + @note NaN values never compare equal to themselves or to other NaN values. + + @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 + + @exceptionsafety No-throw guarantee: this function never throws exceptions. + + @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(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(rhs.m_value.number_integer)); + } + else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float) + { + return (static_cast(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(rhs.m_value.number_unsigned)); + } + else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer) + { + return (static_cast(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(rhs.m_value.number_unsigned)); + } + + return false; + } + + /*! + @brief comparison: equal + @copydoc operator==(const_reference, const_reference) + */ + template::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::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. + + @exceptionsafety No-throw guarantee: this function never throws exceptions. + + @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::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::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. + + @exceptionsafety No-throw guarantee: this function never throws exceptions. + + @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(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(rhs.m_value.number_integer); + } + else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float) + { + return static_cast(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(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(rhs.m_value.number_unsigned); + } + else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer) + { + return static_cast(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 + @copydoc operator<(const_reference, const_reference) + */ + template::value, int>::type = 0> + friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept + { + return (lhs < basic_json(rhs)); + } + + /*! + @brief comparison: less than + @copydoc operator<(const_reference, const_reference) + */ + template::value, int>::type = 0> + friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept + { + return (basic_json(lhs) < rhs); + } + + /*! + @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. + + @exceptionsafety No-throw guarantee: this function never throws exceptions. + + @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: less than or equal + @copydoc operator<=(const_reference, const_reference) + */ + template::value, int>::type = 0> + friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept + { + return (lhs <= basic_json(rhs)); + } + + /*! + @brief comparison: less than or equal + @copydoc operator<=(const_reference, const_reference) + */ + template::value, int>::type = 0> + friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept + { + return (basic_json(lhs) <= rhs); + } + + /*! + @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. + + @exceptionsafety No-throw guarantee: this function never throws exceptions. + + @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 + @copydoc operator>(const_reference, const_reference) + */ + template::value, int>::type = 0> + friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept + { + return (lhs > basic_json(rhs)); + } + + /*! + @brief comparison: greater than + @copydoc operator>(const_reference, const_reference) + */ + template::value, int>::type = 0> + friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept + { + return (basic_json(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. + + @exceptionsafety No-throw guarantee: this function never throws exceptions. + + @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); + } + + /*! + @brief comparison: greater than or equal + @copydoc operator>=(const_reference, const_reference) + */ + template::value, int>::type = 0> + friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept + { + return (lhs >= basic_json(rhs)); + } + + /*! + @brief comparison: greater than or equal + @copydoc operator>=(const_reference, const_reference) + */ + template::value, int>::type = 0> + friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept + { + return (basic_json(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)`. + + - The indentation characrer can be controlled with the member variable + `fill` of the output stream @a o. For instance, the manipulator + `std::setfill('\\t')` sets indentation to use a tab character rather than + the default space character. + + @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; indentaction character added in version 3.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 + serializer s(detail::output_adapter(o), o.fill()); + s.dump(j, pretty_print, false, static_cast(indentation)); + return o; + } + + /*! + @brief serialize to stream + @deprecated This stream operator is deprecated and will be removed in a + future version of the library. Please use + @ref operator<<(std::ostream&, const basic_json&) + instead; that is, replace calls like `j >> o;` with `o << j;`. + @since version 1.0.0; deprecated since version 3.0.0 + */ + JSON_DEPRECATED + friend std::ostream& operator>>(const basic_json& j, std::ostream& o) + { + return o << j; + } + + /// @} + + + ///////////////////// + // deserialization // + ///////////////////// + + /// @name deserialization + /// @{ + + /*! + @brief deserialize from a compatible input + + This function reads from a compatible input. Examples are: + - an array of 1-byte values + - strings with character/literal type with size of 1 byte + - input streams + - 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 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.** + + @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. + + @param[in] i input 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 + + @throw parse_error.101 if a parse error occurs; example: `""unexpected end + of input; expected string literal""` + @throw parse_error.102 if to_unicode fails or surrogate error + @throw parse_error.103 if to_unicode fails + + @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} + + @liveexample{The example below demonstrates the `parse()` function with + and without callback function.,parse__string__parser_callback_t} + + @liveexample{The example below demonstrates the `parse()` function with + and without callback function.,parse__istream__parser_callback_t} + + @liveexample{The example below demonstrates the `parse()` function reading + from a contiguous container.,parse__contiguouscontainer__parser_callback_t} + + @since version 2.0.3 (contiguous containers) + */ + static basic_json parse(detail::input_adapter i, + const parser_callback_t cb = nullptr, + const bool allow_exceptions = true) + { + basic_json result; + parser(i, cb, allow_exceptions).parse(true, result); + return result; + } + + /*! + @copydoc basic_json parse(detail::input_adapter, const parser_callback_t) + */ + static basic_json parse(detail::input_adapter& i, + const parser_callback_t cb = nullptr, + const bool allow_exceptions = true) + { + basic_json result; + parser(i, cb, allow_exceptions).parse(true, result); + return result; + } + + static bool accept(detail::input_adapter i) + { + return parser(i).accept(true); + } + + static bool accept(detail::input_adapter& i) + { + return parser(i).accept(true); + } + + /*! + @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) + @param[in] allow_exceptions whether to throw exceptions in case of a + parse error (optional, true by default) + + @return result of the deserialization + + @throw parse_error.101 in case of an unexpected token + @throw parse_error.102 if to_unicode fails or surrogate error + @throw parse_error.103 if to_unicode fails + + @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::iterator_category>::value, int>::type = 0> + static basic_json parse(IteratorType first, IteratorType last, + const parser_callback_t cb = nullptr, + const bool allow_exceptions = true) + { + basic_json result; + parser(detail::input_adapter(first, last), cb, allow_exceptions).parse(true, result); + return result; + } + + template::iterator_category>::value, int>::type = 0> + static bool accept(IteratorType first, IteratorType last) + { + return parser(detail::input_adapter(first, last)).accept(true); + } + + /*! + @brief deserialize from stream + @deprecated This stream operator is deprecated and will be removed in a + future version of the library. Please use + @ref operator>>(std::istream&, basic_json&) + instead; that is, replace calls like `j << i;` with `i >> j;`. + @since version 1.0.0; deprecated since version 3.0.0 + */ + JSON_DEPRECATED + friend std::istream& operator<<(basic_json& j, std::istream& i) + { + return operator>>(i, j); + } + + /*! + @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 parse_error.101 in case of an unexpected token + @throw parse_error.102 if to_unicode fails or surrogate error + @throw parse_error.103 if to_unicode fails + + @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>>(std::istream& i, basic_json& j) + { + parser(detail::input_adapter(i)).parse(false, j); + return 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 a string representation of a the @a m_type member: + Value type | return value + ----------- | ------------- + null | `"null"` + boolean | `"boolean"` + string | `"string"` + number | `"number"` (for all number types) + object | `"object"` + array | `"array"` + discarded | `"discarded"` + + @exceptionsafety No-throw guarantee: this function never throws exceptions. + + @complexity Constant. + + @liveexample{The following code exemplifies `type_name()` for all JSON + types.,type_name} + + @sa @ref type() -- return the type of the JSON value + @sa @ref operator value_t() -- return the type of the JSON value (implicit) + + @since version 1.0.0, public since 2.1.0, `const char*` and `noexcept` + since 3.0.0 + */ + const char* type_name() const noexcept + { + { + 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: + ////////////////////// + // 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 = {}; + + ////////////////////////////////////////// + // binary serialization/deserialization // + ////////////////////////////////////////// + + /// @name binary serialization/deserialization support + /// @{ + + public: + /*! + @brief create a CBOR 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. + + The library uses the following mapping from JSON values types to + CBOR types according to the CBOR specification (RFC 7049): + + JSON value type | value/range | CBOR type | first byte + --------------- | ------------------------------------------ | ---------------------------------- | --------------- + null | `null` | Null | 0xf6 + boolean | `true` | True | 0xf5 + boolean | `false` | False | 0xf4 + number_integer | -9223372036854775808..-2147483649 | Negative integer (8 bytes follow) | 0x3b + number_integer | -2147483648..-32769 | Negative integer (4 bytes follow) | 0x3a + number_integer | -32768..-129 | Negative integer (2 bytes follow) | 0x39 + number_integer | -128..-25 | Negative integer (1 byte follow) | 0x38 + number_integer | -24..-1 | Negative integer | 0x20..0x37 + number_integer | 0..23 | Integer | 0x00..0x17 + number_integer | 24..255 | Unsigned integer (1 byte follow) | 0x18 + number_integer | 256..65535 | Unsigned integer (2 bytes follow) | 0x19 + number_integer | 65536..4294967295 | Unsigned integer (4 bytes follow) | 0x1a + number_integer | 4294967296..18446744073709551615 | Unsigned integer (8 bytes follow) | 0x1b + number_unsigned | 0..23 | Integer | 0x00..0x17 + number_unsigned | 24..255 | Unsigned integer (1 byte follow) | 0x18 + number_unsigned | 256..65535 | Unsigned integer (2 bytes follow) | 0x19 + number_unsigned | 65536..4294967295 | Unsigned integer (4 bytes follow) | 0x1a + number_unsigned | 4294967296..18446744073709551615 | Unsigned integer (8 bytes follow) | 0x1b + number_float | *any value* | Double-Precision Float | 0xfb + string | *length*: 0..23 | UTF-8 string | 0x60..0x77 + string | *length*: 23..255 | UTF-8 string (1 byte follow) | 0x78 + string | *length*: 256..65535 | UTF-8 string (2 bytes follow) | 0x79 + string | *length*: 65536..4294967295 | UTF-8 string (4 bytes follow) | 0x7a + string | *length*: 4294967296..18446744073709551615 | UTF-8 string (8 bytes follow) | 0x7b + array | *size*: 0..23 | array | 0x80..0x97 + array | *size*: 23..255 | array (1 byte follow) | 0x98 + array | *size*: 256..65535 | array (2 bytes follow) | 0x99 + array | *size*: 65536..4294967295 | array (4 bytes follow) | 0x9a + array | *size*: 4294967296..18446744073709551615 | array (8 bytes follow) | 0x9b + object | *size*: 0..23 | map | 0xa0..0xb7 + object | *size*: 23..255 | map (1 byte follow) | 0xb8 + object | *size*: 256..65535 | map (2 bytes follow) | 0xb9 + object | *size*: 65536..4294967295 | map (4 bytes follow) | 0xba + object | *size*: 4294967296..18446744073709551615 | map (8 bytes follow) | 0xbb + + @note The mapping is **complete** in the sense that any JSON value type + can be converted to a CBOR value. + + @note If NaN or Infinity are stored inside a JSON number, they are + serialized properly. This behavior differs from the @ref dump() + function which serializes NaN or Infinity to `null`. + + @note The following CBOR types are not used in the conversion: + - byte strings (0x40..0x5f) + - UTF-8 strings terminated by "break" (0x7f) + - arrays terminated by "break" (0x9f) + - maps terminated by "break" (0xbf) + - date/time (0xc0..0xc1) + - bignum (0xc2..0xc3) + - decimal fraction (0xc4) + - bigfloat (0xc5) + - tagged items (0xc6..0xd4, 0xd8..0xdb) + - expected conversions (0xd5..0xd7) + - simple values (0xe0..0xf3, 0xf8) + - undefined (0xf7) + - half and single-precision floats (0xf9-0xfa) + - break (0xff) + + @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&, 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 to_cbor(const basic_json& j) + { + std::vector result; + to_cbor(j, result); + return result; + } + + static void to_cbor(const basic_json& j, detail::output_adapter o) + { + binary_writer(o).write_cbor(j); + } + + static void to_cbor(const basic_json& j, detail::output_adapter o) + { + binary_writer(o).write_cbor(j); + } + + /*! + @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. + + The library uses the following mapping from JSON values types to + MessagePack types according to the MessagePack specification: + + JSON value type | value/range | MessagePack type | first byte + --------------- | --------------------------------- | ---------------- | ---------- + null | `null` | nil | 0xc0 + boolean | `true` | true | 0xc3 + boolean | `false` | false | 0xc2 + number_integer | -9223372036854775808..-2147483649 | int64 | 0xd3 + number_integer | -2147483648..-32769 | int32 | 0xd2 + number_integer | -32768..-129 | int16 | 0xd1 + number_integer | -128..-33 | int8 | 0xd0 + number_integer | -32..-1 | negative fixint | 0xe0..0xff + number_integer | 0..127 | positive fixint | 0x00..0x7f + number_integer | 128..255 | uint 8 | 0xcc + number_integer | 256..65535 | uint 16 | 0xcd + number_integer | 65536..4294967295 | uint 32 | 0xce + number_integer | 4294967296..18446744073709551615 | uint 64 | 0xcf + number_unsigned | 0..127 | positive fixint | 0x00..0x7f + number_unsigned | 128..255 | uint 8 | 0xcc + number_unsigned | 256..65535 | uint 16 | 0xcd + number_unsigned | 65536..4294967295 | uint 32 | 0xce + number_unsigned | 4294967296..18446744073709551615 | uint 64 | 0xcf + number_float | *any value* | float 64 | 0xcb + string | *length*: 0..31 | fixstr | 0xa0..0xbf + string | *length*: 32..255 | str 8 | 0xd9 + string | *length*: 256..65535 | str 16 | 0xda + string | *length*: 65536..4294967295 | str 32 | 0xdb + array | *size*: 0..15 | fixarray | 0x90..0x9f + array | *size*: 16..65535 | array 16 | 0xdc + array | *size*: 65536..4294967295 | array 32 | 0xdd + object | *size*: 0..15 | fix map | 0x80..0x8f + object | *size*: 16..65535 | map 16 | 0xde + object | *size*: 65536..4294967295 | map 32 | 0xdf + + @note The mapping is **complete** in the sense that any JSON value type + can be converted to a MessagePack value. + + @note The following values can **not** be converted to a MessagePack value: + - strings with more than 4294967295 bytes + - arrays with more than 4294967295 elements + - objects with more than 4294967295 elements + + @note The following MessagePack types are not used in the conversion: + - bin 8 - bin 32 (0xc4..0xc6) + - ext 8 - ext 32 (0xc7..0xc9) + - float 32 (0xca) + - fixext 1 - fixext 16 (0xd4..0xd8) + + @note Any MessagePack output created @ref to_msgpack can be successfully + parsed by @ref from_msgpack. + + @note If NaN or Infinity are stored inside a JSON number, they are + serialized properly. This behavior differs from the @ref dump() + function which serializes NaN or Infinity to `null`. + + @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&, 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 to_msgpack(const basic_json& j) + { + std::vector result; + to_msgpack(j, result); + return result; + } + + static void to_msgpack(const basic_json& j, detail::output_adapter o) + { + binary_writer(o).write_msgpack(j); + } + + static void to_msgpack(const basic_json& j, detail::output_adapter o) + { + binary_writer(o).write_msgpack(j); + } + + /*! + @brief create a JSON value from an input in CBOR format + + Deserializes a given input @a i to a JSON value using the CBOR (Concise + Binary Object Representation) serialization format. + + The library maps CBOR types to JSON value types as follows: + + CBOR type | JSON value type | first byte + ---------------------- | --------------- | ---------- + Integer | number_unsigned | 0x00..0x17 + Unsigned integer | number_unsigned | 0x18 + Unsigned integer | number_unsigned | 0x19 + Unsigned integer | number_unsigned | 0x1a + Unsigned integer | number_unsigned | 0x1b + Negative integer | number_integer | 0x20..0x37 + Negative integer | number_integer | 0x38 + Negative integer | number_integer | 0x39 + Negative integer | number_integer | 0x3a + Negative integer | number_integer | 0x3b + Negative integer | number_integer | 0x40..0x57 + UTF-8 string | string | 0x60..0x77 + UTF-8 string | string | 0x78 + UTF-8 string | string | 0x79 + UTF-8 string | string | 0x7a + UTF-8 string | string | 0x7b + UTF-8 string | string | 0x7f + array | array | 0x80..0x97 + array | array | 0x98 + array | array | 0x99 + array | array | 0x9a + array | array | 0x9b + array | array | 0x9f + map | object | 0xa0..0xb7 + map | object | 0xb8 + map | object | 0xb9 + map | object | 0xba + map | object | 0xbb + map | object | 0xbf + False | `false` | 0xf4 + True | `true` | 0xf5 + Nill | `null` | 0xf6 + Half-Precision Float | number_float | 0xf9 + Single-Precision Float | number_float | 0xfa + Double-Precision Float | number_float | 0xfb + + @warning The mapping is **incomplete** in the sense that not all CBOR + types can be converted to a JSON value. The following CBOR types + are not supported and will yield parse errors (parse_error.112): + - byte strings (0x40..0x5f) + - date/time (0xc0..0xc1) + - bignum (0xc2..0xc3) + - decimal fraction (0xc4) + - bigfloat (0xc5) + - tagged items (0xc6..0xd4, 0xd8..0xdb) + - expected conversions (0xd5..0xd7) + - simple values (0xe0..0xf3, 0xf8) + - undefined (0xf7) + + @warning CBOR allows map keys of any type, whereas JSON only allows + strings as keys in object values. Therefore, CBOR maps with keys + other than UTF-8 strings are rejected (parse_error.113). + + @note Any CBOR output created @ref to_cbor can be successfully parsed by + @ref from_cbor. + + @param[in] i an input in CBOR format convertible to an input adapter + @param[in] strict whether to expect the input to be consumed until EOF + (true by default) + @return deserialized JSON value + + @throw parse_error.110 if the given input ends prematurely or the end of + file was not reached when @a strict was set to true + @throw parse_error.112 if unsupported features from CBOR were + used in the given input @a v or if the input is not valid CBOR + @throw parse_error.113 if a string was expected as map key, but not found + + @complexity Linear in the size of the input @a i. + + @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(detail::input_adapter, const bool) for the + related MessagePack format + + @since version 2.0.9; parameter @a start_index since 2.1.1; changed to + consume input adapters, removed start_index parameter, and added + @a strict parameter since 3.0.0 + */ + static basic_json from_cbor(detail::input_adapter i, + const bool strict = true) + { + return binary_reader(i).parse_cbor(strict); + } + + /*! + @copydoc from_cbor(detail::input_adapter, const bool) + */ + template::value, int> = 0> + static basic_json from_cbor(A1 && a1, A2 && a2, const bool strict = true) + { + return binary_reader(detail::input_adapter(std::forward(a1), std::forward(a2))).parse_cbor(strict); + } + + /*! + @brief create a JSON value from an input in MessagePack format + + Deserializes a given input @a i to a JSON value using the MessagePack + serialization format. + + The library maps MessagePack types to JSON value types as follows: + + MessagePack type | JSON value type | first byte + ---------------- | --------------- | ---------- + positive fixint | number_unsigned | 0x00..0x7f + fixmap | object | 0x80..0x8f + fixarray | array | 0x90..0x9f + fixstr | string | 0xa0..0xbf + nil | `null` | 0xc0 + false | `false` | 0xc2 + true | `true` | 0xc3 + float 32 | number_float | 0xca + float 64 | number_float | 0xcb + uint 8 | number_unsigned | 0xcc + uint 16 | number_unsigned | 0xcd + uint 32 | number_unsigned | 0xce + uint 64 | number_unsigned | 0xcf + int 8 | number_integer | 0xd0 + int 16 | number_integer | 0xd1 + int 32 | number_integer | 0xd2 + int 64 | number_integer | 0xd3 + str 8 | string | 0xd9 + str 16 | string | 0xda + str 32 | string | 0xdb + array 16 | array | 0xdc + array 32 | array | 0xdd + map 16 | object | 0xde + map 32 | object | 0xdf + negative fixint | number_integer | 0xe0-0xff + + @warning The mapping is **incomplete** in the sense that not all + MessagePack types can be converted to a JSON value. The following + MessagePack types are not supported and will yield parse errors: + - bin 8 - bin 32 (0xc4..0xc6) + - ext 8 - ext 32 (0xc7..0xc9) + - fixext 1 - fixext 16 (0xd4..0xd8) + + @note Any MessagePack output created @ref to_msgpack can be successfully + parsed by @ref from_msgpack. + + @param[in] i an input in MessagePack format convertible to an input + adapter + @param[in] strict whether to expect the input to be consumed until EOF + (true by default) + + @throw parse_error.110 if the given input ends prematurely or the end of + file was not reached when @a strict was set to true + @throw parse_error.112 if unsupported features from MessagePack were + used in the given input @a i or if the input is not valid MessagePack + @throw parse_error.113 if a string was expected as map key, but not found + + @complexity Linear in the size of the input @a i. + + @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(detail::input_adapter, const bool) for the related CBOR + format + + @since version 2.0.9; parameter @a start_index since 2.1.1; changed to + consume input adapters, removed start_index parameter, and added + @a strict parameter since 3.0.0 + */ + static basic_json from_msgpack(detail::input_adapter i, + const bool strict = true) + { + return binary_reader(i).parse_msgpack(strict); + } + + /*! + @copydoc from_msgpack(detail::input_adapter, const bool) + */ + template::value, int> = 0> + static basic_json from_msgpack(A1 && a1, A2 && a2, const bool strict = true) + { + return binary_reader(detail::input_adapter(std::forward(a1), std::forward(a2))).parse_msgpack(strict); + } + + /// @} + + ////////////////////////// + // 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 parse_error.106 if an array index begins with '0' + @throw parse_error.109 if an array index was not a number + @throw out_of_range.404 if the JSON pointer can not be resolved + + @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 parse_error.106 if an array index begins with '0' + @throw parse_error.109 if an array index was not a number + @throw out_of_range.402 if the array index '-' is used + @throw out_of_range.404 if the JSON pointer can not be resolved + + @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 + + @throw parse_error.106 if an array index in the passed JSON pointer @a ptr + begins with '0'. See example below. + + @throw parse_error.109 if an array index in the passed JSON pointer @a ptr + is not a number. See example below. + + @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr + is out of range. See example below. + + @throw out_of_range.402 if the array index '-' is used in the passed JSON + pointer @a ptr. As `at` provides checked access (and no elements are + implicitly inserted), the index '-' is always invalid. See example below. + + @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved. + See example below. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes in the JSON value. + + @complexity Constant. + + @since version 2.0.0 + + @liveexample{The behavior is shown in the example.,at_json_pointer} + */ + 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 + + @throw parse_error.106 if an array index in the passed JSON pointer @a ptr + begins with '0'. See example below. + + @throw parse_error.109 if an array index in the passed JSON pointer @a ptr + is not a number. See example below. + + @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr + is out of range. See example below. + + @throw out_of_range.402 if the array index '-' is used in the passed JSON + pointer @a ptr. As `at` provides checked access (and no elements are + implicitly inserted), the index '-' is always invalid. See example below. + + @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved. + See example below. + + @exceptionsafety Strong guarantee: if an exception is thrown, there are no + changes in the JSON value. + + @complexity Constant. + + @since version 2.0.0 + + @liveexample{The behavior is shown in the example.,at_json_pointer_const} + */ + 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. + + @throw type_error.314 if value is not an object + @throw type_error.315 if object values are not primitive + + @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 parse_error.104 if the JSON patch does not consist of an array of + objects + + @throw parse_error.105 if the JSON patch is malformed (e.g., mandatory + attributes are missing); example: `"operation add must have member path"` + + @throw out_of_range.401 if an array index is out of range. + + @throw out_of_range.403 if a JSON pointer inside the patch could not be + resolved successfully in the current JSON value; example: `"key baz not + found"` + + @throw out_of_range.405 if JSON pointer has no parent ("add", "remove", + "move") + + @throw other_error.501 if "test" operation was unsuccessful + + @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 (JSON_UNLIKELY(static_cast(idx) > parent.size())) + { + // avoid undefined behavior + JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range")); + } + else + { + // default case: insert add offset + parent.insert(parent.begin() + static_cast(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 (JSON_LIKELY(it != parent.end())) + { + parent.erase(it); + } + else + { + JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found")); + } + } + else if (parent.is_array()) + { + // note erase performs range check + parent.erase(static_cast(std::stoi(last_path))); + } + }; + + // type check: top level value must be an array + if (JSON_UNLIKELY(not json_patch.is_array())) + { + JSON_THROW(parse_error::create(104, 0, "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 (JSON_UNLIKELY(it == val.m_value.object->end())) + { + JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'")); + } + + // check if result is of type string + if (JSON_UNLIKELY(string_type and not it->second.is_string())) + { + JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'")); + } + + // no error: return value + return it->second; + }; + + // type check: every element of the array must be an object + if (JSON_UNLIKELY(not val.is_object())) + { + JSON_THROW(parse_error::create(104, 0, "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 (out_of_range&) + { + // ignore out of range errors: success remains false + } + + // throw an exception if test fails + if (JSON_UNLIKELY(not success)) + { + JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump())); + } + + break; + } + + case patch_operations::invalid: + { + // op must be "add", "remove", "replace", "move", "copy", or + // "test" + JSON_THROW(parse_error::create(105, 0, "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 + std::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(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<>; + +////////////////// +// json_pointer // +////////////////// + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +NLOHMANN_BASIC_JSON_TPL& +json_pointer::get_and_create(NLOHMANN_BASIC_JSON_TPL& j) const +{ + using size_type = typename NLOHMANN_BASIC_JSON_TPL::size_type; + auto 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 detail::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 detail::value_t::object: + { + // create an entry in the object + result = &result->operator[](reference_token); + break; + } + + case detail::value_t::array: + { + // create an entry in the array + JSON_TRY + { + result = &result->operator[](static_cast(std::stoi(reference_token))); + } + JSON_CATCH(std::invalid_argument&) + { + JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number")); + } + 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(detail::type_error::create(313, "invalid value to unflatten")); + } + } + + return *result; +} + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +NLOHMANN_BASIC_JSON_TPL& +json_pointer::get_unchecked(NLOHMANN_BASIC_JSON_TPL* ptr) const +{ + using size_type = typename NLOHMANN_BASIC_JSON_TPL::size_type; + for (const auto& reference_token : reference_tokens) + { + // convert null values to arrays or objects before continuing + if (ptr->m_type == detail::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 (x >= '0' and x <= '9'); + }); + + // change value to array for numbers or "-" or to object otherwise + *ptr = (nums or reference_token == "-") + ? detail::value_t::array + : detail::value_t::object; + } + + switch (ptr->m_type) + { + case detail::value_t::object: + { + // use unchecked object access + ptr = &ptr->operator[](reference_token); + break; + } + + case detail::value_t::array: + { + // error condition (cf. RFC 6901, Sect. 4) + if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0')) + { + JSON_THROW(detail::parse_error::create(106, 0, + "array index '" + reference_token + + "' 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 + JSON_TRY + { + ptr = &ptr->operator[]( + static_cast(std::stoi(reference_token))); + } + JSON_CATCH(std::invalid_argument&) + { + JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number")); + } + } + break; + } + + default: + JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'")); + } + } + + return *ptr; +} + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +NLOHMANN_BASIC_JSON_TPL& +json_pointer::get_checked(NLOHMANN_BASIC_JSON_TPL* ptr) const +{ + using size_type = typename NLOHMANN_BASIC_JSON_TPL::size_type; + for (const auto& reference_token : reference_tokens) + { + switch (ptr->m_type) + { + case detail::value_t::object: + { + // note: at performs range check + ptr = &ptr->at(reference_token); + break; + } + + case detail::value_t::array: + { + if (JSON_UNLIKELY(reference_token == "-")) + { + // "-" always fails the range check + JSON_THROW(detail::out_of_range::create(402, + "array index '-' (" + std::to_string(ptr->m_value.array->size()) + + ") is out of range")); + } + + // error condition (cf. RFC 6901, Sect. 4) + if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0')) + { + JSON_THROW(detail::parse_error::create(106, 0, + "array index '" + reference_token + + "' must not begin with '0'")); + } + + // note: at performs range check + JSON_TRY + { + ptr = &ptr->at(static_cast(std::stoi(reference_token))); + } + JSON_CATCH(std::invalid_argument&) + { + JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number")); + } + break; + } + + default: + JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'")); + } + } + + return *ptr; +} + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +const NLOHMANN_BASIC_JSON_TPL& +json_pointer::get_unchecked(const NLOHMANN_BASIC_JSON_TPL* ptr) const +{ + using size_type = typename NLOHMANN_BASIC_JSON_TPL::size_type; + for (const auto& reference_token : reference_tokens) + { + switch (ptr->m_type) + { + case detail::value_t::object: + { + // use unchecked object access + ptr = &ptr->operator[](reference_token); + break; + } + + case detail::value_t::array: + { + if (JSON_UNLIKELY(reference_token == "-")) + { + // "-" cannot be used for const access + JSON_THROW(detail::out_of_range::create(402, + "array index '-' (" + std::to_string(ptr->m_value.array->size()) + + ") is out of range")); + } + + // error condition (cf. RFC 6901, Sect. 4) + if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0')) + { + JSON_THROW(detail::parse_error::create(106, 0, + "array index '" + reference_token + + "' must not begin with '0'")); + } + + // use unchecked array access + JSON_TRY + { + ptr = &ptr->operator[]( + static_cast(std::stoi(reference_token))); + } + JSON_CATCH(std::invalid_argument&) + { + JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number")); + } + break; + } + + default: + JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'")); + } + } + + return *ptr; +} + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +const NLOHMANN_BASIC_JSON_TPL& +json_pointer::get_checked(const NLOHMANN_BASIC_JSON_TPL* ptr) const +{ + using size_type = typename NLOHMANN_BASIC_JSON_TPL::size_type; + for (const auto& reference_token : reference_tokens) + { + switch (ptr->m_type) + { + case detail::value_t::object: + { + // note: at performs range check + ptr = &ptr->at(reference_token); + break; + } + + case detail::value_t::array: + { + if (JSON_UNLIKELY(reference_token == "-")) + { + // "-" always fails the range check + JSON_THROW(detail::out_of_range::create(402, + "array index '-' (" + std::to_string(ptr->m_value.array->size()) + + ") is out of range")); + } + + // error condition (cf. RFC 6901, Sect. 4) + if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0')) + { + JSON_THROW(detail::parse_error::create(106, 0, + "array index '" + reference_token + + "' must not begin with '0'")); + } + + // note: at performs range check + JSON_TRY + { + ptr = &ptr->at(static_cast(std::stoi(reference_token))); + } + JSON_CATCH(std::invalid_argument&) + { + JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number")); + } + break; + } + + default: + JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'")); + } + } + + return *ptr; +} + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +void json_pointer::flatten(const std::string& reference_string, + const NLOHMANN_BASIC_JSON_TPL& value, + NLOHMANN_BASIC_JSON_TPL& result) +{ + switch (value.m_type) + { + case detail::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 (std::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 detail::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; + } + } +} + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +NLOHMANN_BASIC_JSON_TPL +json_pointer::unflatten(const NLOHMANN_BASIC_JSON_TPL& value) +{ + if (JSON_UNLIKELY(not value.is_object())) + { + JSON_THROW(detail::type_error::create(314, "only objects can be unflattened")); + } + + NLOHMANN_BASIC_JSON_TPL result; + + // iterate the JSON object values + for (const auto& element : *value.m_value.object) + { + if (JSON_UNLIKELY(not element.second.is_primitive())) + { + JSON_THROW(detail::type_error::create(315, "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; +} + +inline bool operator==(json_pointer const& lhs, json_pointer const& rhs) noexcept +{ + return (lhs.reference_tokens == rhs.reference_tokens); +} + +inline bool operator!=(json_pointer const& lhs, json_pointer const& rhs) noexcept +{ + return not (lhs == rhs); +} +} // 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::value and + is_nothrow_move_assignable::value + ) +{ + j1.swap(j2); +} + +/// hash value for JSON objects +template<> +struct hash +{ + /*! + @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(); + return h(j.dump()); + } +}; + +/// specialization for std::less +/// @note: do not remove the space after '<', +/// see https://github.com/nlohmann/json/pull/679 +template<> +struct less< ::nlohmann::detail::value_t> +{ + /*! + @brief compare two value_t enum values + @since version 3.0.0 + */ + bool operator()(nlohmann::detail::value_t lhs, + nlohmann::detail::value_t rhs) const noexcept + { + return nlohmann::detail::operator<(lhs, rhs); + } +}; + +} // 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 +#if defined(__clang__) + #pragma GCC diagnostic pop +#endif + +// clean up +#undef JSON_CATCH +#undef JSON_THROW +#undef JSON_TRY +#undef JSON_LIKELY +#undef JSON_UNLIKELY +#undef JSON_DEPRECATED +#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION +#undef NLOHMANN_BASIC_JSON_TPL + +#endif diff --git a/3rdparty/tinygltf/loader_example.cc b/3rdparty/tinygltf/loader_example.cc new file mode 100644 index 0000000..139e956 --- /dev/null +++ b/3rdparty/tinygltf/loader_example.cc @@ -0,0 +1,570 @@ +#define TINYGLTF_IMPLEMENTATION +#define STB_IMAGE_IMPLEMENTATION +#include "tiny_gltf.h" + +#include +#include +#include + +static std::string GetFilePathExtension(const std::string &FileName) { + if (FileName.find_last_of(".") != std::string::npos) + return FileName.substr(FileName.find_last_of(".") + 1); + return ""; +} + +static std::string PrintMode(int mode) { + if (mode == TINYGLTF_MODE_POINTS) { + return "POINTS"; + } else if (mode == TINYGLTF_MODE_LINE) { + return "LINE"; + } else if (mode == TINYGLTF_MODE_LINE_LOOP) { + return "LINE_LOOP"; + } else if (mode == TINYGLTF_MODE_TRIANGLES) { + return "TRIANGLES"; + } else if (mode == TINYGLTF_MODE_TRIANGLE_FAN) { + return "TRIANGLE_FAN"; + } else if (mode == TINYGLTF_MODE_TRIANGLE_STRIP) { + return "TRIANGLE_STRIP"; + } + return "**UNKNOWN**"; +} + +static std::string PrintTarget(int target) { + if (target == 34962) { + return "GL_ARRAY_BUFFER"; + } else if (target == 34963) { + return "GL_ELEMENT_ARRAY_BUFFER"; + } else { + return "**UNKNOWN**"; + } +} + +static std::string PrintType(int ty) { + if (ty == TINYGLTF_TYPE_SCALAR) { + return "SCALAR"; + } else if (ty == TINYGLTF_TYPE_VECTOR) { + return "VECTOR"; + } else if (ty == TINYGLTF_TYPE_VEC2) { + return "VEC2"; + } else if (ty == TINYGLTF_TYPE_VEC3) { + return "VEC3"; + } else if (ty == TINYGLTF_TYPE_VEC4) { + return "VEC4"; + } else if (ty == TINYGLTF_TYPE_MATRIX) { + return "MATRIX"; + } else if (ty == TINYGLTF_TYPE_MAT2) { + return "MAT2"; + } else if (ty == TINYGLTF_TYPE_MAT3) { + return "MAT3"; + } else if (ty == TINYGLTF_TYPE_MAT4) { + return "MAT4"; + } + return "**UNKNOWN**"; +} + +static std::string PrintComponentType(int ty) { + if (ty == TINYGLTF_COMPONENT_TYPE_BYTE) { + return "BYTE"; + } else if (ty == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) { + return "UNSIGNED_BYTE"; + } else if (ty == TINYGLTF_COMPONENT_TYPE_SHORT) { + return "SHORT"; + } else if (ty == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) { + return "UNSIGNED_SHORT"; + } else if (ty == TINYGLTF_COMPONENT_TYPE_INT) { + return "INT"; + } else if (ty == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT) { + return "UNSIGNED_INT"; + } else if (ty == TINYGLTF_COMPONENT_TYPE_FLOAT) { + return "FLOAT"; + } else if (ty == TINYGLTF_COMPONENT_TYPE_DOUBLE) { + return "DOUBLE"; + } + + return "**UNKNOWN**"; +} + +#if 0 +static std::string PrintParameterType(int ty) { + if (ty == TINYGLTF_PARAMETER_TYPE_BYTE) { + return "BYTE"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_UNSIGNED_BYTE) { + return "UNSIGNED_BYTE"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_SHORT) { + return "SHORT"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_UNSIGNED_SHORT) { + return "UNSIGNED_SHORT"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_INT) { + return "INT"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_UNSIGNED_INT) { + return "UNSIGNED_INT"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT) { + return "FLOAT"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT_VEC2) { + return "FLOAT_VEC2"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT_VEC3) { + return "FLOAT_VEC3"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT_VEC4) { + return "FLOAT_VEC4"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_INT_VEC2) { + return "INT_VEC2"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_INT_VEC3) { + return "INT_VEC3"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_INT_VEC4) { + return "INT_VEC4"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_BOOL) { + return "BOOL"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_BOOL_VEC2) { + return "BOOL_VEC2"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_BOOL_VEC3) { + return "BOOL_VEC3"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_BOOL_VEC4) { + return "BOOL_VEC4"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT_MAT2) { + return "FLOAT_MAT2"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT_MAT3) { + return "FLOAT_MAT3"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_FLOAT_MAT4) { + return "FLOAT_MAT4"; + } else if (ty == TINYGLTF_PARAMETER_TYPE_SAMPLER_2D) { + return "SAMPLER_2D"; + } + + return "**UNKNOWN**"; +} +#endif + +static std::string PrintWrapMode(int mode) { + if (mode == TINYGLTF_TEXTURE_WRAP_REPEAT) { + return "REPEAT"; + } else if (mode == TINYGLTF_TEXTURE_WRAP_CLAMP_TO_EDGE) { + return "CLAMP_TO_EDGE"; + } else if (mode == TINYGLTF_TEXTURE_WRAP_MIRRORED_REPEAT) { + return "MIRRORED_REPEAT"; + } + + return "**UNKNOWN**"; +} + +static std::string PrintFilterMode(int mode) { + if (mode == TINYGLTF_TEXTURE_FILTER_NEAREST) { + return "NEAREST"; + } else if (mode == TINYGLTF_TEXTURE_FILTER_LINEAR) { + return "LINEAR"; + } else if (mode == TINYGLTF_TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST) { + return "NEAREST_MIPMAP_NEAREST"; + } else if (mode == TINYGLTF_TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR) { + return "NEAREST_MIPMAP_LINEAR"; + } else if (mode == TINYGLTF_TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST) { + return "LINEAR_MIPMAP_NEAREST"; + } else if (mode == TINYGLTF_TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR) { + return "LINEAR_MIPMAP_LINEAR"; + } + return "**UNKNOWN**"; +} + +static std::string PrintIntArray(const std::vector &arr) { + if (arr.size() == 0) { + return ""; + } + + std::stringstream ss; + ss << "[ "; + for (size_t i = 0; i < arr.size(); i++) { + ss << arr[i] << ((i != arr.size() - 1) ? ", " : ""); + } + ss << " ]"; + + return ss.str(); +} + +static std::string PrintFloatArray(const std::vector &arr) { + if (arr.size() == 0) { + return ""; + } + + std::stringstream ss; + ss << "[ "; + for (size_t i = 0; i < arr.size(); i++) { + ss << arr[i] << ((i != arr.size() - 1) ? ", " : ""); + } + ss << " ]"; + + return ss.str(); +} + +static std::string Indent(const int indent) { + std::string s; + for (int i = 0; i < indent; i++) { + s += " "; + } + + return s; +} + +static std::string PrintParameterValue(const tinygltf::Parameter ¶m) { + if (!param.number_array.empty()) { + return PrintFloatArray(param.number_array); + } else { + return param.string_value; + } +} + +static std::string PrintValue(const std::string &name, + const tinygltf::Value &value, const int indent) { + std::stringstream ss; + + if (value.IsObject()) { + const tinygltf::Value::Object &o = value.Get(); + tinygltf::Value::Object::const_iterator it(o.begin()); + tinygltf::Value::Object::const_iterator itEnd(o.end()); + for (; it != itEnd; it++) { + ss << PrintValue(name, it->second, indent + 1); + } + } else if (value.IsString()) { + ss << Indent(indent) << name << " : " << value.Get() + << std::endl; + } else if (value.IsBool()) { + ss << Indent(indent) << name << " : " << value.Get() << std::endl; + } else if (value.IsNumber()) { + ss << Indent(indent) << name << " : " << value.Get() << std::endl; + } else if (value.IsInt()) { + ss << Indent(indent) << name << " : " << value.Get() << std::endl; + } + // @todo { binary, array } + + return ss.str(); +} + +static void DumpNode(const tinygltf::Node &node, int indent) { + std::cout << Indent(indent) << "name : " << node.name << std::endl; + std::cout << Indent(indent) << "camera : " << node.camera << std::endl; + std::cout << Indent(indent) << "mesh : " << node.mesh << std::endl; + if (!node.rotation.empty()) { + std::cout << Indent(indent) + << "rotation : " << PrintFloatArray(node.rotation) + << std::endl; + } + if (!node.scale.empty()) { + std::cout << Indent(indent) + << "scale : " << PrintFloatArray(node.scale) << std::endl; + } + if (!node.translation.empty()) { + std::cout << Indent(indent) + << "translation : " << PrintFloatArray(node.translation) + << std::endl; + } + + if (!node.matrix.empty()) { + std::cout << Indent(indent) + << "matrix : " << PrintFloatArray(node.matrix) << std::endl; + } + + std::cout << Indent(indent) + << "children : " << PrintIntArray(node.children) << std::endl; +} + +static void DumpStringIntMap(const std::map &m, int indent) { + std::map::const_iterator it(m.begin()); + std::map::const_iterator itEnd(m.end()); + for (; it != itEnd; it++) { + std::cout << Indent(indent) << it->first << ": " << it->second << std::endl; + } +} + +static void DumpPrimitive(const tinygltf::Primitive &primitive, int indent) { + std::cout << Indent(indent) << "material : " << primitive.material + << std::endl; + std::cout << Indent(indent) << "indices : " << primitive.indices << std::endl; + std::cout << Indent(indent) << "mode : " << PrintMode(primitive.mode) + << "(" << primitive.mode << ")" << std::endl; + std::cout << Indent(indent) + << "attributes(items=" << primitive.attributes.size() << ")" + << std::endl; + DumpStringIntMap(primitive.attributes, indent + 1); + + std::cout << Indent(indent) << "extras :" << std::endl + << PrintValue("extras", primitive.extras, indent + 1) << std::endl; +} + +static void Dump(const tinygltf::Model &model) { + std::cout << "=== Dump glTF ===" << std::endl; + std::cout << "asset.copyright : " << model.asset.copyright + << std::endl; + std::cout << "asset.generator : " << model.asset.generator + << std::endl; + std::cout << "asset.version : " << model.asset.version + << std::endl; + std::cout << "asset.minVersion : " << model.asset.minVersion + << std::endl; + std::cout << std::endl; + + std::cout << "=== Dump scene ===" << std::endl; + std::cout << "defaultScene: " << model.defaultScene << std::endl; + + { + std::cout << "scenes(items=" << model.scenes.size() << ")" << std::endl; + for (size_t i = 0; i < model.scenes.size(); i++) { + std::cout << Indent(1) << "scene[" << i + << "] name : " << model.scenes[i].name << std::endl; + } + } + + { + std::cout << "meshes(item=" << model.meshes.size() << ")" << std::endl; + for (size_t i = 0; i < model.meshes.size(); i++) { + std::cout << Indent(1) << "name : " << model.meshes[i].name + << std::endl; + std::cout << Indent(1) + << "primitives(items=" << model.meshes[i].primitives.size() + << "): " << std::endl; + + for (size_t k = 0; k < model.meshes[i].primitives.size(); k++) { + DumpPrimitive(model.meshes[i].primitives[k], 2); + } + } + } + + { + for (size_t i = 0; i < model.accessors.size(); i++) { + const tinygltf::Accessor &accessor = model.accessors[i]; + std::cout << Indent(1) << "name : " << accessor.name << std::endl; + std::cout << Indent(2) << "bufferView : " << accessor.bufferView + << std::endl; + std::cout << Indent(2) << "byteOffset : " << accessor.byteOffset + << std::endl; + std::cout << Indent(2) << "componentType: " + << PrintComponentType(accessor.componentType) << "(" + << accessor.componentType << ")" << std::endl; + std::cout << Indent(2) << "count : " << accessor.count + << std::endl; + std::cout << Indent(2) << "type : " << PrintType(accessor.type) + << std::endl; + if (!accessor.minValues.empty()) { + std::cout << Indent(2) << "min : ["; + for (size_t k = 0; k < accessor.minValues.size(); k++) { + std::cout << accessor.minValues[k] + << ((i != accessor.minValues.size() - 1) ? ", " : ""); + } + std::cout << "]" << std::endl; + } + if (!accessor.maxValues.empty()) { + std::cout << Indent(2) << "max : ["; + for (size_t k = 0; k < accessor.maxValues.size(); k++) { + std::cout << accessor.maxValues[k] + << ((i != accessor.maxValues.size() - 1) ? ", " : ""); + } + std::cout << "]" << std::endl; + } + } + } + + { + std::cout << "animations(items=" << model.animations.size() << ")" + << std::endl; + for (size_t i = 0; i < model.animations.size(); i++) { + const tinygltf::Animation &animation = model.animations[i]; + std::cout << Indent(1) << "name : " << animation.name + << std::endl; + + std::cout << Indent(1) << "channels : [ " << std::endl; + for (size_t j = 0; i < animation.channels.size(); i++) { + std::cout << Indent(2) + << "sampler : " << animation.channels[j].sampler + << std::endl; + std::cout << Indent(2) + << "target.id : " << animation.channels[j].target_node + << std::endl; + std::cout << Indent(2) + << "target.path : " << animation.channels[j].target_path + << std::endl; + std::cout << ((i != (animation.channels.size() - 1)) ? " , " : ""); + } + std::cout << " ]" << std::endl; + + std::cout << Indent(1) << "samplers(items=" << animation.samplers.size() + << ")" << std::endl; + for (size_t j = 0; j < animation.samplers.size(); j++) { + const tinygltf::AnimationSampler &sampler = animation.samplers[j]; + std::cout << Indent(2) << "input : " << sampler.input + << std::endl; + std::cout << Indent(2) << "interpolation : " << sampler.interpolation + << std::endl; + std::cout << Indent(2) << "output : " << sampler.output + << std::endl; + } + } + } + + { + std::cout << "bufferViews(items=" << model.bufferViews.size() << ")" + << std::endl; + for (size_t i = 0; i < model.bufferViews.size(); i++) { + const tinygltf::BufferView &bufferView = model.bufferViews[i]; + std::cout << Indent(1) << "name : " << bufferView.name + << std::endl; + std::cout << Indent(2) << "buffer : " << bufferView.buffer + << std::endl; + std::cout << Indent(2) << "byteLength : " << bufferView.byteLength + << std::endl; + std::cout << Indent(2) << "byteOffset : " << bufferView.byteOffset + << std::endl; + std::cout << Indent(2) << "byteStride : " << bufferView.byteStride + << std::endl; + std::cout << Indent(2) + << "target : " << PrintTarget(bufferView.target) + << std::endl; + } + } + + { + std::cout << "buffers(items=" << model.buffers.size() << ")" << std::endl; + for (size_t i = 0; i < model.buffers.size(); i++) { + const tinygltf::Buffer &buffer = model.buffers[i]; + std::cout << Indent(1) << "name : " << buffer.name << std::endl; + std::cout << Indent(2) << "byteLength : " << buffer.data.size() + << std::endl; + } + } + + { + std::cout << "materials(items=" << model.materials.size() << ")" + << std::endl; + for (size_t i = 0; i < model.materials.size(); i++) { + const tinygltf::Material &material = model.materials[i]; + std::cout << Indent(1) << "name : " << material.name << std::endl; + std::cout << Indent(1) << "values(items=" << material.values.size() << ")" + << std::endl; + + tinygltf::ParameterMap::const_iterator p(material.values.begin()); + tinygltf::ParameterMap::const_iterator pEnd(material.values.end()); + for (; p != pEnd; p++) { + std::cout << Indent(2) << p->first << ": " + << PrintParameterValue(p->second) << std::endl; + } + } + } + + { + std::cout << "nodes(items=" << model.nodes.size() << ")" << std::endl; + for (size_t i = 0; i < model.nodes.size(); i++) { + const tinygltf::Node &node = model.nodes[i]; + std::cout << Indent(1) << "name : " << node.name << std::endl; + + DumpNode(node, 2); + } + } + + { + std::cout << "images(items=" << model.images.size() << ")" << std::endl; + for (size_t i = 0; i < model.images.size(); i++) { + const tinygltf::Image &image = model.images[i]; + std::cout << Indent(1) << "name : " << image.name << std::endl; + + std::cout << Indent(2) << "width : " << image.width << std::endl; + std::cout << Indent(2) << "height : " << image.height << std::endl; + std::cout << Indent(2) << "component : " << image.component << std::endl; + } + } + + { + std::cout << "textures(items=" << model.textures.size() << ")" << std::endl; + for (size_t i = 0; i < model.textures.size(); i++) { + const tinygltf::Texture &texture = model.textures[i]; + std::cout << Indent(1) << "sampler : " << texture.sampler + << std::endl; + std::cout << Indent(1) << "source : " << texture.source + << std::endl; + } + } + + { + std::cout << "samplers(items=" << model.samplers.size() << ")" << std::endl; + + for (size_t i = 0; i < model.samplers.size(); i++) { + const tinygltf::Sampler &sampler = model.samplers[i]; + std::cout << Indent(1) << "name (id) : " << sampler.name << std::endl; + std::cout << Indent(2) + << "minFilter : " << PrintFilterMode(sampler.minFilter) + << std::endl; + std::cout << Indent(2) + << "magFilter : " << PrintFilterMode(sampler.magFilter) + << std::endl; + std::cout << Indent(2) + << "wrapS : " << PrintWrapMode(sampler.wrapS) + << std::endl; + std::cout << Indent(2) + << "wrapT : " << PrintWrapMode(sampler.wrapT) + << std::endl; + } + } + + { + std::cout << "cameras(items=" << model.cameras.size() << ")" << std::endl; + + for (size_t i = 0; i < model.cameras.size(); i++) { + const tinygltf::Camera &camera = model.cameras[i]; + std::cout << Indent(1) << "name (id) : " << camera.name << std::endl; + std::cout << Indent(1) << "type : " << camera.type << std::endl; + + if (camera.type.compare("perspective") == 0) { + std::cout << Indent(2) + << "aspectRatio : " << camera.perspective.aspectRatio + << std::endl; + std::cout << Indent(2) << "yfov : " << camera.perspective.yfov + << std::endl; + std::cout << Indent(2) << "zfar : " << camera.perspective.zfar + << std::endl; + std::cout << Indent(2) << "znear : " << camera.perspective.znear + << std::endl; + } else if (camera.type.compare("orthographic") == 0) { + std::cout << Indent(2) << "xmag : " << camera.orthographic.xmag + << std::endl; + std::cout << Indent(2) << "ymag : " << camera.orthographic.ymag + << std::endl; + std::cout << Indent(2) << "zfar : " << camera.orthographic.zfar + << std::endl; + std::cout << Indent(2) + << "znear : " << camera.orthographic.znear + << std::endl; + } + } + } +} + +int main(int argc, char **argv) { + if (argc < 2) { + printf("Needs input.gltf\n"); + exit(1); + } + + tinygltf::Model model; + tinygltf::TinyGLTF gltf_ctx; + std::string err; + std::string input_filename(argv[1]); + std::string ext = GetFilePathExtension(input_filename); + + bool ret = false; + if (ext.compare("glb") == 0) { + std::cout << "Reading binary glTF" << std::endl; + // assume binary glTF. + ret = gltf_ctx.LoadBinaryFromFile(&model, &err, input_filename.c_str()); + } else { + std::cout << "Reading ASCII glTF" << std::endl; + // assume ascii glTF. + ret = gltf_ctx.LoadASCIIFromFile(&model, &err, input_filename.c_str()); + } + + if (!err.empty()) { + printf("Err: %s\n", err.c_str()); + } + + if (!ret) { + printf("Failed to parse glTF\n"); + return -1; + } + + Dump(model); + + return 0; +} diff --git a/3rdparty/tinygltf/models/Cube/Cube.bin b/3rdparty/tinygltf/models/Cube/Cube.bin new file mode 100644 index 0000000000000000000000000000000000000000..7dae4b0b93e3251ca8886c43b6a9403f27648a39 GIT binary patch literal 1800 zcmcIhNm2wc3={jX@B1<=Z=g8#)5wWmQS&680G1PF(jh%P2S`;{Y*|ulH?V?LtYIA+ z*u)kl*v1Zav4?#e;1EYR#tBYwhI3rt5?8p!4Q_FVdpux@M?B#fF91Sk->kS959VLr z@8oxrsPot`@w+0f-8FtBIc~hgDG4+1eGd6JQYQAF) zU*f9i?i!eQ^_{o~QDeW(f`OPNhH^g zGgfh|f4+UZiu*fWv=`dZn0fUy zjohgr`J2aB?taGS(VMy7)I&251>eO*ZZ&GMAM19;=ZXK`x&HQ89zETBDgVR_skeXF zPwqv#OMPX$EB3-ZEZ5P#bUPmAeBwIVWvOSa)Rr}A%es4oxu#b$T&Ia!U7nf8+0vJ> I)N}Os0UGHvApigX literal 0 HcmV?d00001 diff --git a/3rdparty/tinygltf/models/Cube/Cube.gltf b/3rdparty/tinygltf/models/Cube/Cube.gltf new file mode 100644 index 0000000..bc873da --- /dev/null +++ b/3rdparty/tinygltf/models/Cube/Cube.gltf @@ -0,0 +1,193 @@ +{ + "accessors" : [ + { + "bufferView" : 0, + "byteOffset" : 0, + "componentType" : 5123, + "count" : 36, + "max" : [ + 35 + ], + "min" : [ + 0 + ], + "type" : "SCALAR" + }, + { + "bufferView" : 1, + "byteOffset" : 0, + "componentType" : 5126, + "count" : 36, + "max" : [ + 1.000000, + 1.000000, + 1.000001 + ], + "min" : [ + -1.000000, + -1.000000, + -1.000000 + ], + "type" : "VEC3" + }, + { + "bufferView" : 2, + "byteOffset" : 0, + "componentType" : 5126, + "count" : 36, + "max" : [ + 1.000000, + 1.000000, + 1.000000 + ], + "min" : [ + -1.000000, + -1.000000, + -1.000000 + ], + "type" : "VEC3" + }, + { + "bufferView" : 3, + "byteOffset" : 0, + "componentType" : 5126, + "count" : 36, + "max" : [ + 1.000000, + -0.000000, + -0.000000, + 1.000000 + ], + "min" : [ + 0.000000, + -0.000000, + -1.000000, + -1.000000 + ], + "type" : "VEC4" + }, + { + "bufferView" : 4, + "byteOffset" : 0, + "componentType" : 5126, + "count" : 36, + "max" : [ + 1.000000, + 1.000000 + ], + "min" : [ + -1.000000, + -1.000000 + ], + "type" : "VEC2" + } + ], + "asset" : { + "generator" : "VKTS glTF 2.0 exporter", + "version" : "2.0" + }, + "bufferViews" : [ + { + "buffer" : 0, + "byteLength" : 72, + "byteOffset" : 0, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 432, + "byteOffset" : 72, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 432, + "byteOffset" : 504, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 576, + "byteOffset" : 936, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 288, + "byteOffset" : 1512, + "target" : 34962 + } + ], + "buffers" : [ + { + "byteLength" : 1800, + "uri" : "Cube.bin" + } + ], + "images" : [ + { + "uri" : "Cube_BaseColor.png" + }, + { + "uri" : "Cube_MetallicRoughness.png" + } + ], + "materials" : [ + { + "name" : "Cube", + "pbrMetallicRoughness" : { + "baseColorTexture" : { + "index" : 0 + }, + "metallicRoughnessTexture" : { + "index" : 1 + } + } + } + ], + "meshes" : [ + { + "name" : "Cube", + "primitives" : [ + { + "attributes" : { + "NORMAL" : 2, + "POSITION" : 1, + "TANGENT" : 3, + "TEXCOORD_0" : 4 + }, + "indices" : 0, + "material" : 0, + "mode" : 4 + } + ] + } + ], + "nodes" : [ + { + "mesh" : 0, + "name" : "Cube" + } + ], + "samplers" : [ + {} + ], + "scene" : 0, + "scenes" : [ + { + "nodes" : [ + 0 + ] + } + ], + "textures" : [ + { + "sampler" : 0, + "source" : 0 + }, + { + "sampler" : 0, + "source" : 1 + } + ] +} diff --git a/3rdparty/tinygltf/models/Cube/Cube_BaseColor.png b/3rdparty/tinygltf/models/Cube/Cube_BaseColor.png new file mode 100644 index 0000000000000000000000000000000000000000..5e5cb2068fa85aec944bd75c981fa6420c1cea87 GIT binary patch literal 891995 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 X!vGkH5P)xhsehq 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­fR+#{clFA&3$g?ja*v#Q8eu^Y9C=}^Y#yO0 zlP6#fVprZ{-*4Sq-#;2`A&x@QhF#XOHx|W~XXaU@wF5fBJEk4De4ERphQ&=1g^T}LIF1xgzdErZl_n~m9qp>BN59ed4H#~=y2 z#nT`-(@}Pqj1-^Gv&b$Rr{5YXZc<#)OhkQ+B_&8r5v^(e5Zw7MmQWat_gi9?zqimG z#;^PJ1#Dl9QZ2-dppsbv%km(JmBn)%e9m*oaKcuBd&S5gloZXb={1SHhEzdZ-6ueCf6S5*5bZS>hW`aUPI z9sd0R^RiSJ#u`VTBwlg*)+o4Ta_@n5R{dfMA4kg8%KL?k6+}4DZrYJ$V*&ovNB8sc zd2-1T>Q>AW@f6G0P0#_($CeEJ@B*q&lMAc>HOu9{jkn`jwZePodWb*K)orJ5V(ms| z_P~?YHvo3%npC^4Ob7=#vl6D>HhO$N7o$7=55?CFyQ|>G26k0w84Q=a`NW93n1R=C z+(kY#s_CNx{b{@ovvj_Q+ImFbJ^O31O)GjnJ<%#-1gsfFI4et0KUl|{hjX*u(W8=Z z%MQIB_r!nSfmRz|x`e&_Ft}W97br5%l@@g<_3*vY;EUCIF#F~}B2ELTY<_7=wGeoyNS$k-_r*<$vGDHVg59(gy z=g(Ha0p_`=tuZl8Lzs-Ce)SW1-MQ3@CuErg(eo%5&iXcc7l8t(C`pW7&1F!%O|@8k zPwI$Z!6T&01BzoO3UY_&g;TNT7tyS;Hax!v>szbj7XPB{$_>!&Tuvo#p&o$6+jR`} z^cLZ zH;DShyGshpb*Y=EoK+%cg;|p^BdrecpS}%ef$Q-6wRj*0iCi0xJ@akDSDDM$S6uW< zU8p;e#I`F0z&CT=W`N+Rt>*1EGtHfEJgPC2e0sQ%%w{&j^kBTlN&4OXIa-92Cpa6` zAU3j;dy(3bogw6Un&3?#FguM9Q+5?E9L3y-@4wscMJivA%*|`jlqkIaFr?h~*;%p~ z)s#2}<#QA65A^VKzhw+YvUVX%ELko3Wl#-9i6c9LqzS!zl~a#hP^+FgcR}fl`32Pe8TDDLa zwn7wHWaf8z;25laKjNjD@{85|sEty=)xbPO;VH&lE*dC(sB4R+-p`+| z|L&sye2{FQNiKx&^f~61hq~Ai_}V81EgP97h4B3MiKOz`FjSG7i$><u0Mva&mue~5{D*9cR`vQZHPWT z$w51D{~$Y?ENUdy?-#;=Hb2(~>Q5S>^=$_dY4F9TbnMU0T%5ZS_EbZ2{!%myFv>XG zFI%MO)xCJ$6%7_zi<{@(cTixLpE3xrDRMG$)qZp}v zSb}s6Y4M5(`vp4BWNQzbnB*n;2QL3X>OVdR(^^gv3(>Qqg@M!YE7iE=7(Cq)wFoC3 z`3an?b8&E_3goOq7Ueyjy*Eu>N*bUR8p7;lG43(hQrpz%DE|DAURr^+f#5VjMatXC{>cVe$=*x8EE|5`}mppgjZX6Ao`hZ({)xzxH5@T9G>exHC ztpu6#YUt&E<=D$z3;p!J8zacuM!`D|^Mm?(?bSZknpgbTr@nASk|1V2;mZfcs#}VN zvmNw?aSF>sJg10Yr&)XW*Izw?|MG|)eMUXC$e5F#FjMD?W~u-ULOm5-s41AiF10>^8Q&?B(0o;LE`GOCqEIQRkhE2VDn(r$Fs-?R}ory!OS zw38CWD|j}4As(UhUH}1h6@8$|emlC@55eh|(ZvI|8P&_sAUE2C6Y=EkrP?Q@1m~xq z7V|WP)8^9b`^F%lhQ{g@h6f7;J>Q7DF~AA#E}3uZJ#0m~d*GSh(8kll9Gh>@-H}}B z2jdyYGat!v9bdJN6Fhd7Y0%;ZK&Q-M6jox~cDQ%Dz)47Kupm@SM+oh_pezidgB!3i zOV{z9cOif>j12%-#8^Rn#F2*We86sDw4AVDOT4PQS7&P{xw*L^1wg@uY zdl1{=2!TCA>w-w0j;~ZA)jN#U+Y32OQ|PU;8gFq=pN+@*eZbCrw>kFx6Lij$`K_Y^ zDJ1aeOa6yEKA%dDI@S$cjU8q>#@@ZJH`f$=K&AOGQw1Z{j}2t2$NQ?D-DZR?*osPq zZM6@MHDb*2A?91QD>NZe*#CY6jtap}`Mef{ZP0oTR5*57%kdQe>18ez1H~-W+rtwb zLF`^54IRq&JoPC=9_oU+3~s{y{1M)mCDJIXwlU^|#KHPkspQk)QYxIUzpNMI@+pzTzG5J0+Va3C&DC*iD@=Pmkq2p;|JBwy5z!$By zwj!B4Jnoc|w;U-n#quD$n_JyaSLeY8`GOP+Y;zxRZ4I^E)K;Ik>3^|;o2K^h4AA}^ zfNbXz^+h!L2`prJj&BXK${lH+CA!vaAum+?QymN-;o+2v8*h)d)b`{k>5`v7I<|uO z@E*8_AbPnSo{38VL!Di{VeZ`Nhu-}r99I5R}Ad2Y^v>z4#e zc-3P$>Syl*rAyv3#ZFqTH1_xNf1j}{qRLZ1E!m(s?lB`(rQkjRgut6J|I69}pfc#mX!gqUliDG5DM`g?6rw#>Exf_u_#&4@qu#N2!_o?}w4p z9VvSh;zt9kRrakrwBQw-pleXDoS_M}_hU1v)gOGNb^k?(aif{VEo3rJQfXSl;WpLe z@JjE&=jO`kc5ckp?0#m`$=|<+S@qY?6JN*G3KAZYYw^>L$Lxj6csCUkd_?u!u=0D1~yFbwA?%$2{ z;OLPssr!ELL(TQpk)u2~9DR6p&RUp3U4BW(Et!Q5*hXgMziYg)E4v(;a{=#bTKT*G zdf$*eWVE-Y`i(DUxgU4)&Cv?S5Z59oaY*I9UVam_nZ3&l)(WG#@XxT?NicV&Nze)d zJ8x#+-ee?yfiUv!W_gwm<`x1z;ReK+g|!er-bS(tg!UIHqLj2d{t>Ffh9zD9qZrQ} zOL6wL;m3{pkG)NS=HDh*^Q`b~K9Xa-8G0&0>S^aUt%svFvJT2J>aT{g?0Z=rBmn%+MC zsiLZrUYO&96&|OzM^e?JD77UjedjF+>T{Ob+DM+zBpM6Z^au%)<5YPL4)uNSB;9E& zo9(CTn?`XF%A|=%nnJw$O9ZYRM5Z7I)Il>aB9I9}yIvKof7)tbo#PpmVF*OJ_r61_r@vx$6DEu++~^7)uZCoDDU7MXz{(myM&asMA(!vztdg zbr3D<3)XL6L%Ds)AZ?E&qwWxOghNbPM&-z0@s!1XSwFwjz6>fVBCf3z@f;4eF zu)O2K8|l-<5YAr-+s+{nJ6R+upKGD2Fa$mHIhPeL^Q9;sMwpYWhM`ygVH>-$hx!h^ z`+T6EP58OEx*DCJlMDKD;J%AO5IT*!ALOEGoJK~n>5K- zl5Zi28t~T>SAo#mH&p(kwC-**CNz)771P!2SDn{uYdJjO95ECb@-+pvsFlW<;oX?1Rz+4RC{Y&MkEgMLfaqE$-h zn+oyxL~otaW2uSz2u`hRV)8*WsCk`(e3sh`N6A>dhdwrz(rak?RQ_lO?S;>~$Pl<# zaPJ+mXcIZu$Zc6gug;*GmlJ8Xv`3<~gZ^gHt+TB(>)(e+n{54nh;N>qtl2|n9<0;d2g0L@ zSh7W=v~GI43~FUOK$=H*yS%7{fSp@H>;o`+-?4)4Nb7r};CPls4fY{3AbB61C575S zw#d&~HtJcXI2rK>r`fwXL%~5@T@F9k9jvKqTGR>=)Ub{h>cJ@xb# zO5%k#$SFY!@q(MRBio+8I!kz5CPNJpdQh9*r77+7x4!xvu%8<`^E$!xSwA~ogzBa{ zt<+AsZ%3|tyFh!zd-_Hy=^at@fjkmJ#o1F!M##5Z$?yk9mj&om8$7N+X*q;Pl_6zj zjfM$%2Ax38#Ce9tWvs{Y_Qd0v+j5cq&V_i`!^5PJxnCeB7-RU2K*7SD_D!ZkMxEeg z)@PLi9ZezVSwtMj&u*cHv#FaaDa%kw1c>yO5fq4C&`p4Xx3d49pkQAKt?zW`hm!yY98v>0Is0=~`*1epCQq$6x4Go@}z5oe$JBF_vJgBpVZbGindG# zS1j@MccAK5lmD6vYZi68>x1TK4aK*}9)qL%&Cu^_7~c;ql@AWmRR@ghhS4Z9 z75V{=6)U1bvuUAyRtEu8q*OV*)S)e_fjBk3kzm-(g`SM;L>s3WL!SC&^tguzN#C#- z=lD=#Mp0!S&l2?^f^9CMLR<9>3)yT>)h@(emV-pj7qCS5dM9oDN>1O9zYG3n- zH{n7HJ4uSAq=KufGNUXb1H_x@NB-EyQ?+PSDYNXkL4v^p)Nc2CG%66cNz5iSV2=D; zik{nK3}3gFjc!_`wX0!E56+xDuNddaqv|8IuZ>eMceRjJ9g9B;CSqpMu@wehQm+wb z>N%g1R z1X#%1iI@>Eb5RP;)Yl?eCl*viEFYlR&84TcFGb5xc=jJ+ABP&fY!{jACHdoCxnIom zbfK34VM^R#e*A^pp`Us1^HpeT6@Zs~5IVOHp`OiVNPvvJ`!cpWSIFRsmjTGd4(Qv) z0hZm0LDbHlwtEn>^Z{<iO6%lhwtG|V1jY4fxxF-1a$pnt}VV+Mz8J@SsD_nsg!0j4fIz!Zy$ zrh^up{ToiOhJEm!Rb2>b{Xg1o#tqm3;J)c_**DN-oOp;Hza8u$rYb#SkTSQ2hIXUH z$jeW}wxh(pFly;6YKs%GZz1(=G2xyqWY*xp4FuO-XFh$USiT;5WTd|^Ku&U?W`vtb zrvjI&(_MD;U#2?2N^$;SGx^@v&eWVT^54l(4%EI@;%TthaNa@tRw%*vF1=-Dx249y zNTz4{N~_?5b;28)qAaPM4Yh3I&0Rso$|2g@{kPe6(R2?W-JUqi(PTKPx9zZQ`om}y z)2iE}1(2HD4i-}ja4)2h!m_skx&#rGG(e=WiDh7_nKu^OZ6x{|4h|WfsQ-se*>QEh zVQEO!CF0pl{?(;4Qr zQUg}aIEDt4>^Tzxy)P}!1=SFSU9vgda}>?vxiP&@EWA2`b6cOje7eLKD(~ece7whA zeHl-8MyoO*eB55q7@plR{E+H51{$Z%|5=9?97HJ^A?k!c>1%2G;py7gB z!gHgHI$vkg3%Qt^kx<*><|`dy=*@wbZw8esPP;{K`Q49xOcqb;=QaIDpRXb4%e!h( z=cSmnKp1xj=WEUna8(tIU~X@O_wXcq%|s1We~PeoY9T)>D#$ze|B#<8a>P||R~yq_ z$Z39$R!bO~F%D`2BN<5N=ku&SemrSa9=@ec%GZ1us8e>3G1cL4-ST)87hK;4eH^C8e;$I% zbKz%bM`O=ckodCk_pkiR zBOmUuXo6^Erwv=YjcPJrImwfnIJ!$ckC?>&!QTU*-?xrNV!oE#)yN25%a)~&SM6nN zbiami+(gR^)GVgoy$0?CZ{eeqVU#sZG>y|d!VNzB?!&#S0J}X?kpFNng_bm){?pfc zb}h!WhPn01h6BjUKWxIpjxw;)4J;Q8q8ZLh<;Yoy@R!;186T0f%jm|FSWGp$lh{^6 zPI}1e%0+wb_%f)H!(OC=lkWNC0PW`tf^}BVaR4)lrTp&`COk_qx&sZmZFIWnCi-f> zH=3EGf-=jnzJ==%cdzkc^nHXhyv(f00Lu7`B;7H3{HzwY@Zsq@8Pq1A8>w9(XC*qX zfB$o#c6);p!&UpbGm*UZ;VQYxEm<38N<3N_j~9JeteqS|U8o_>EXsI$?H<&8iJRa| z(o?;aKdwX43x}+v7tRJqZT}r5t#UXx0*+Wzvo)3AN^KrTxd5qxA450WG)h}?;4pco z{5-=Ymp%2PvvnBAe|zme2S5!C=w)0PpT z^yUk9Xf09f1Yg=iu;ebI%*RO{dFvp@D6PSG=^!JtXuLr+%}}<(#(N9+Waco+pCGHL zGKhO_J!D%=JR7PROtKcNAqCeb3o0N*U(Kw)?)y}Joq^f9dUVRX5!f=EKt6}46k2+f zeh@8X(pppLiIeM~)z_4HQ-%CtDa2!4`_pMC-Oknc(}K<#R)<^po&UiPY8hjYI(87b zg30leaU+amibT)SNd9GL(IPu^Y`!*f}mY-Kj zMf$VNXsK7bMf(b<5gjTK_TTnnGqxpXvBQ_Z&ejvf~ zI)Fv(IADBWCFH2#ou!2LsuX>#m!K@C31@3@TLEU_t9n|;{`Q20bHNsU9k90@6#%65 z_LdRS=rdo{&8Z$Y7iuCt&>XB@Jc}r+d;Jnb>bZ}Y6tcyU%1E*WC?B&w`_t+Xu+XO_3@7$dQFOG zULFXr3);-G;|%<;)Vwih5-ewMSjsD6^#*VehC&eGRR3a=!U@A@J*($z*xv?mt)VSMqs-QD2}v~ zjIp-HxAhkAyU1UT>VVIv^dR^7BS!CXaQ*tw2j;seH{R7N(hs3=E{}=1uH1C}xWou7 zKW8G`->sbfG8u6n%@tQn6-MocWnbHQ6!%O-sn&LCopTUc(LM}45=uYVhHgPan+;lm zQHL5oxbp$yNYiVY>Pa{ejx`x(030*&zyB) zSBf4(d^V@LuMyLp5rT9OR?i=%ovCjY5}yjZi6>C2N>TF+-+u+Q2pU zK&&DP>3YSinj?op|NH&xYX^JHt5jxTsgJJ|whb=Fli4lgQ_leLNjJB#4SJg(`}HGr zz6=vBvSy?9N-{OXAQ+!AwJtq}&ShB(Qa&qR?g^{T+9RCJkY^Z4x1hRDv-H2s#KC_! z>BeY0Hn`|e;qyAVzNc%)#8W1XB<`0N zLH^!r9dywX>KwSq1e5)tIxq2{(z6mNTLG*mXPA!xOJ$$qr_P_-L4@b!aj&+w6T$HY zda`UHZUd2))|K>oPy+BsJ~awDNDof$jgVH-)Pa`Id(de#$t+_De0Q;!Zg6%Zc22JC z-9a8WDR2kA#Ld63GXc}^`jw@`I|HhQB?&jy#OK)--xsD_zr=!^j_p1M$6~(dqMwt= zq9cp3$iQ__zRM;&?9Co>7rpuMcu(hhB+D)aX>A{}Xo{hEq@ulX0*lwV)cf(;_pSjV zoMyKJ^2k9rf8kY5H)WrL>tDEEwGtc#s+^b_czn$k<{p6B#L?Dyj9^Ps^^HB&K|dQC z44S{*z6H6R06c!(u^jAENwKw{o*-6n!^MOmZch$sxu1CJC)wtr)4Xyd4_q3+&-A{= zt}eXLqjWpb$R_AHq2%^K) ^H;Wo$rrqtq-an>=z0-~Snv7?DS5Eg8oLfabJwt3$ zj3F2_>B0A?^t^L~eybPPVWl+M-mitb(MGzCC2O`B&|8Sla1R=j^g!=j!YSuc1zeq5 zO9pvoKjHgpM9J4fuQo#Nrd+X*V-x(I**DOH-$*f}cBYJ{lBbB<%z|XR>Q-KM2?#kL zP5*sFxiP*NZ!cU`1bGI5mQgjq04;)dP{~*1n=5m-55@)M&sBqt@dEhOdpP>8DVPu6 zr8U1bY`%+rIilFSj=aJ~B`#lk&vaDtEzZaT~f?lFbb86XYO;);`&EZe-3ceHrY>KFys#Ifia} zEFBrG&xQ!VjgSL+NVt>RT~6@a9ZSBKwzEHxAy;!@_rs3lIYB4+dAlR&??se5Nq5-Q z+lo)oFOxz}7*!WlLr%#R6sQHx8Mx=Ycg(y;xmp*FWd5&6?SmxZTmez^wh`mlP%WO0 z`um^I{6efkDOlqpC~%syONPH9kbAzult{?cQh(Bi{1qW?G?qR0(}fRakPP=gRmEMS zpIx?M2IJgDhR0E8enT5bj3w-7WTc9eZhukqF@WapSsGraN^2A{)`ZwHD0^#Q2}dPU zX+a25?Z%fC`BpAP{l|}XN=alBt4{7ApWPR@4+_B(YSshuPi%p|t6&e^Qn+ubFmspk z)G9$4OzAk1o85t`<#1d+SQYuGb0V#6fDsrJqtbG%|%4#fYS zNKQqoQ3t;pE@viiYAlWb+d)QnWoF;EKpiq(o3Ks{b5p;157GkSgeiJuR4D52BXq_< z`m7xB9CIB>tl8B6eT(?FcDbCFTKcUybMHI43OB0O{AI4`HJ8n0Np?c&8OE9_)28n! zjAO66?KR(N*_XYgu?81y4djCp@6RDW>;fsgOT+M^{46r>ZGU4e{-$xOwSZZ)Rv-A_S#I&<**jK)QxgL+22PN%i1oy@u#f5Ur!dTa^?HGBn$fUSV$lr%s-o3#* zas&7L0=3W_7m!Ej-;Ot?m%6n zxVyx_%1>ZaQn!NcxbiNeg?^_F=oV*MX-Y`m$7tW4Y(c<6Hf)yornm0MSyM$(M9&!CXx>R zUb<{pd;|~#O^3Zy4xqRm$}Ie;_%4J_uA#o=wh8+mqEDFLCjUp{_Of<9M3_8KTXq_- zx{ar-#~L0&t-a&9rB#0zX9wtbBsvSqWMVerSDtOl2MiMH^$x`;!t0>dvw{{f;Bd5! zP2BiNpeF?t)jwd~l4VHRFLWbdwv3*robE3Se2Z524C60%!?x3i^&{5U@z-sFMeaiT z7;!n|c$wR&QG99@{^`FaeAbpoY}=QMIc*sv&1@q;bKKw^+FJhTF*{u#E$9Xv0p=f8 z=LrMWc3-H&+*;7isH}g)PMqLs&~oa5D-@h|kR!KxlcI8<{yox#@l$ZiwF;Zs3_ONN zB+jWxpMGb#`Xg^(d?dB1Bo(|3nBSNGGHm9uLd*DSZoZ+;ld?7@ZVVA=yK9C0*P)8V z5pW2&9cUjbX|;D!)iola1KSOC5!69j-E2EhiH{M`4$zIrOSH zdKq-bsHJU)W%U5eL*QNH-$~Tp=8FaO>BQU_+E7znOAoILpv|wu4k29Mi%>^d6Mk+K zRT==sXvmn;M9Qxax2pLn!1_W423yYjOZ9QMaNdG8tA47?#oOJ6yj8g1@~ zKPs3ccr;OH?I5?Vx20|_pbq(o-#zB;lInZw$ha3Q?K@#D?qvQC>4Xd4^*XBakoa}$ zu`5epvpc!ermy7NH+=0zZ~bIvYRe#TGLkI!(`llpO(Y{afhlDIvb1wwW9w51BLmqHL#F1H{s0^+ zRi>{(pM>C_hJ@>H*J9_EM`_DfQ}<~)%!0Z(80{$Jn@oiIPxK%eL-g@damH^xRZGN} zFT~!#;e0suKWNcW;=>kUpt~Zj=pxMbRQSARYF$_%y74~RiAOWAiasz-G-M~-V6Xm( zokEH+=LUT9g;Z_*G|XZmHNin&)^?V?pJYkChi$sA8qu%PP8$Ud>e1S;Uh>u;9}s*` z$A+W)_#1H5Ff;9hG2;0j3UId}4wBnQ%?;ytAOp7DN?bNY$e+I~oBlxGJ~PXPD@J+1 zHTk6g%-!~j<>wFCrN=?vEf}p{yk@SU&3`LtpkZY8T<{ebM5bX}1@dHVE#2}K@#d9a z(ON-duHsYhtMrx!1l#Ub2fZp`7`1yh_f_0-h_g04YY35BxJsX}s9e5R(o(r$qMBB1 zrgUtojGa55vDmz)9n~kZiDLrRWMRP);fq~X++8C#Ct~NPf~E>}ashF7yqR8; zJYE}Xs~bO!l6p$YMFv4L0hrN)0}5yD)=sEzUfCb+#1^!Cc*XMN26j6J8cD-M`zJ=T zKSbbJM>t!p9MZ3G|-xtPfITj`6#_5NpwUK;Urn~)VK{AHnjQb5-v>G+a2#?q}^ z*@=KkA1xH%83Cl49dN1(;%liB{C!^gC=<(S$8U_GY_Rj>XPCMZTPsXQo1bty7h<1$ zgkiJyh6p=;Dcual2T*!<)!{qzFBwBj#~^yJ&QNVyZV}HIr2Xy>Q3bL}mi~s$#zr9g zrfxL9|CfO7pmKtmBe*t8;BRl3=hB%L8+V10`)r8o!Z(iuZ;Eo^{OtlxQ6t&vOO){g zu|=W6!<+Gqjs`oBtEb>Kh382lBU$|6!twyA#72(uy+L*E2=?jpHEee(Rr5PVEPT+- zm#wyQuea4Yq)|ohY6gkFKZ2d#ug+TX+}<|a>^|{k1e;}oXSNm~kqwwfjJC$7@&Y~h zD=N!-u$XuwSR~EOMt|+M4mAhl605av{yE{MelzK`no&~EBwA4W9omGJTIAJdtnZPs z!FzzyJf2$(RE(z$5=I$SUz;m92>5tumVO?FU-n`)|K{dmeKnWh$W)Ehz|>8^is*EO zNHQY^dBHOen>3j*(?)1%4`}vXY@1}J$HkRsRRr97C<5a9C{MZkYT9P4!HS+O7I*2H zDxp!ry*kE(>m#UF29S8ATj4Pih#tFP%=6W9q^#=}C$)5t8MP@a1xovOn9<_E4t{GR zE3wz*g;CWU>L+aG%@rOGAigyaX~YE5(vUBuefY249iS(QYO&*tXzZTTo8W5b*?4^p zhf;)!XE{EH{vfF*Y8lDUZNx6k9Eo~`H~2ukyV|k9c0B4N&4XghS&V|zhztsoK`4vZAz`ub(G- z)3vS)@eNKj-Bea-Dye936cE5>-a6k}NoR2_&pC3K*+|y_Y@W7NjuT`j^wLUlg|_ z8PMLD;$!yMPH#yf155pkZ8ain9|GIar2(uvk?5|FTzW1U{6mr+EGc>7K+c**v`r@! z_w~aa&J3#H54L)fQTd9KfYptbcm8C`Ehg)HCg^kiqU6@{E`F^m6l;X8p?5*)dkh%P zi{9Jq5G9>FL~q}*iuo&f3w|pBv#`>Y#Yi8pE_yej>@!PmoP=6pI^dclAWthVdG<6U zTQY0O4siQ#Att!KAc`GdK;_nZ9m*9sjhbnGs@>eX=}`i&$HK$_%HMT^Tp*4+nn z&(JLF(wj!qBM2$!J#yq=qA2A%qPm{LKxHTP9lAX&?V3-&JE*w7sv#`O$(x(B8GbUH zCljL@rlkgSz`MUDN~_E@KSua+7HmF_LkvGA_j(uw41N?Z%Er+&!i~*Pgrr ztE#TEKdrapGr)FW2S#=qS&J`yk=!y3M8o1}A4l`bUxCFKZ90+`bAhIY|A882LFHXG z3K>UN7D1UlCKwZneQACs#+uJy%u;5ej(=igcgMiU|Btri#PR)2-7S$E-wtT~o?D7N zaP5yoMzyu7TAam>F=CXjqaF51Y74Qxp8WoSbp2Y8T3vTvnY?lZ%v(0XI9c$Bv#wzX zva};kG-hJ!d(epe1ZZ~cY*;3(fi!RFhcn6ZW$^2#o3)P_E?nhxDR@4IyvMkalnzEc z+wgO*#rsU$rC;n9A5>btzp9J~LH*CQlJh<@)h1t=K9uBE;2l_CqP((#;d5^Zw&P`( z^b;h!^`d{@?xrt&H-N}lx+m5XDWluKZ8xeV5@5a><^W zrX!#J%`clG@V+v@jCzm1-H)a2fV`|wU-hM73-1hG!@T|?`sDk=Hf68BK5S!>H$M+* zhdg*OUsfc=KL;m>Swoz~myk1mP5B1OM9xQYSi3=*a(4nVb=3%b-c2kt(k}SUi6M9L zb;_}nx-Tfa9En{+E4T`6vKJqN@!%qHA!i&l)tubPmf;1Cau!tkIG)L?QAWH{C7TYT z0dbZYb$q$+3ukRTN)1dP+OB9>Hg%#yu#XFVqrg*a(@)M?LI#fk@0Bj*;#!qW964iq zAQoJVxu#3@*h&Ne`1SSp+xb|tUb5K{yKb$tIT1o`w22~-uyHi^c3SCt*!|vesPF+? zznK@kh5uu>@|Cl!(?^F*qGrV(`1L1QbxFLZ4F5JBNR>N%)RW-+`383M;4io=sfbtn2;+y-|Xwj&w*xdZAWW@wlHJnkLFi6E{K_q;op4y<<|xi z^=;`y(*|k*xR^N2Y{YLTr>C=bb_+^912Vgml2M{Ds}t5dhy0#_jQaITGl}gQr-k9YvDZG&;XSt13h(YQ;6f(~i3vYDB2Wm}askJ4z!UR3L+t!RcarX-jWs3c zdEmaju=@t@H2W@2r;&}YjaPdzb^ zO&4yE$Ty~XHe_>@DeUQV(0Nc}@@vS)Uukahkn(PWuXd`Atg`%nO=ltJ@hlGUcA~t@ zT$6^DrL}abj)CaKl(bSaQ3(HHnfU*=m}|t55rf3{10=}Y2JakS{N|DKm})&!@y%L2 z$q{X^<(6j(YHd;By-r)v8G1CHi7iuCN&hoZoB(RFT81VQ($pN=hkAPtv(o|t_*EX1iMe_T zFP}fmE^wl|?HYJQvZ`~m=~pBvb4jm;x z`vG`z0AmL)Luzac_Z>kti0S8Nxmd!&Q(b@sOzf6Lor+9Njo_4&Y~#4+9tCuosK7hO zrva!!o=q18Rr4-aNH+Unq3>3X@U4SaA+aH}hECEb=9IxKsvqA;;(hlfVV1L%?&smZ ziit(v>+lVo4rS4Ng{`Br{1~dc>JpKu9Xp*2_AE9<%bR~Y>7!SMpEa^sAf;8q-8r3} zas*&GE*&fg(>bGSN4IF6cof_!L*lztx&q&){u z(mUq0u1KukADoydXQbgTCr-dwy$4l7e1DiljOS^euA%%K!aa7GmgN+hMp3GW6{^s& zE8*Ouc<$ocoRjNESQDK@)`z{n;@Q)8d&$vsy;966AF%|Wnfi8S`6^5Ajg085yHMat zW07WXfSblNW$G!92q_(OUAmZR9|3fZ32XleqFAZaVWF&#^*An>`pwWP=LKtZFk2ly zz*V?9dHyNcQ#XRn4wQWVWg+i$kafDr%JW`6|U(8j|4`X zWhR4~q7BLfnQe5l3SNJQwyzy@9F@Eiw8FwpcHI{6KQQ`$nJ9?v_rP3}@>$@?ku1$V zdq(`>7q(Q1pQY>Oq*2S0D9b;oIcNV+zjUI9)C6I-8`4SB=w$6yFKYLZi%$WSZqQMD zqfnW={wtFD*Hmm;s{(>ZSTNXye2D}E4)7M%95aiu zH-c?jE3ti}sF(LUGAj_D?Lfeico<9er~lQy9K@lBFXfVbS;10kR{al_O>#>-GcL6U zh>2J7qaxs+EKBK4zMuVozxwG2vtbpxzWNcz`vkKNABOEMUO#hZhsKG`3WA%v!J^ZwBwK14IA#VDjtl=NOzX|qQ!wyq;V0nW+!r` zJPU1ja({rC(KAVwZ|luv21X(Z8%K2)^IL4Pc3~TFFu3{h*Ihe7@s@c}odw@mgin}7 zS-&Dcr2K^kS9$P1espUdyLpc$zcOakI z)K31*2^fO&BEj)^1Gtp$-T*CKKapfH6#X1m`3PI_)2?_5-|vvEX4-DEjOP>dhe3<@ zF(kmW{(`CpHc4EOy)_mYNLzq#qX3z_A~KdLnYjDKs>lovWG88%&&lxry#Mr zAip9T%^1OAaz48L+M+`dw4~b!(6x%GV&}d1(|eV~^+5F$M)D@K<}jLCxeUJX4hu%a zu2}{&eJ*kIy}$GfwsXRJ?0Akqbc`20=PnX+Z9G(AabVB>{jg^1FRyU7VqfGA+urIP zaq=5qyES_=Ict>zzNeNPTr9aw*Xqr6kHa&yp2M@X_Ap%FUs>NBxG^&DzG`#SYWkrw+5$ z{jH41m<)gU)xG&~sx>TK&PZB2h!i-{3fD2qnOY0=)d6(kW$|ebBK|)C>Et2lGnFIh zKY<5r1P^sZ<7&H*G_|q%_i||2SJZEqpI0ZI#sY&3U5+$Z+R@~tgT@ezy*V$frcFR!RYKFyMpn(YBPBV5G@RHx_$zbCkeZV^E zIEV21z6G}!Nt6zyK<~0L811aG)SvcMGqlKw8)VXSB{`5vnWM!E!NsH)Z+<0VN-@jj z+h~@L`_?yr_{GK1{PKOKc`xo{4pcc#s0KIY)m^rfI}a$w$_eAzymWp8kM(2qFtgO2 zDV#w2^wg+AXY5^wL<{+T4aRA8W6&@B;GNmzz!zU~+cQGwvGM9Wa#2~PX9d0eRhhhZ zg6i-@nZJv_>T*Ru)gA%4R*av0pAIB2SZ5V0CZ^A>ct2W4nKhfzPlk2o!sexp9Givl z2(M4s`$<(QrYAL}!xb_k%|BKeAJD^%Gf~84d&>Jw6{oFTh9?1iauxXX+c&qaVOHF; zDBH)%+nI^5&8Ylc4#c!J(jti{xdjGsTDP;>LroZ4B8gmuroRThVK3RqyrN^qWml~= zADa1T6Ly*E9)dWumA&@2kSZoU!1Ifo&hcJA!VSSR8>PWGr13JjsA~l6_LkkX))lX! z#vdbGmrLlsXKNpGi({Y#hTHU96U?&pDw2NOG0;h7qxF@UbLtFmZawz4MGb#s`K8gl z5%^>}vpEbz9RLFHH$$N{mib!>o@YLG5;OE?QX`^J@w&!Q$( zwo*IG$LIsMQU`+Ay025D5}wUyM(ncZw1Q>yLTCQP=XcY)ai?8Za9@=&_?Y-LZpg}l z>~;5{hUvde>*VOs`Q*;YI$|{Cvy!?l0v)4<2JnmkE1RTc#4TPPzUQFi&8HykfdOBw z(Wj+aliu_EM)KV>l}$R(bp=X00Bp3dn=bmh+bpfpxN1FhAt#GmJ5%ynX)vUqeP7Tk z(TrZ@aoowJVmg^V3o9H)HMsHRFM9^BtS6mUD04Llw4KwO6{l=;v?t5Rr(L%4C|gBp zpl(+p6>Y5z{!2T+9Rda{Y(HUYPEBKx@gs@k)h>bVfTMPTGc`4*20Q=XMtJ{!&9sxB zfdI6Az}CvJjvW8t7`YKYXk0gwwuvVBP>;C|0D4-IV*#wl9f_3AZs~k| zjAKJC3X}*=;km~Rtk%`t(D~!y^9jn_`39u?3M9HG@A$NB=Vo&LahmvumD+5)^XMwb z&!fmeH08#o5AKY3txRbp|L`eDdXhQCb3n8M2)-*b(QZQ`xZ^9*U1cxKWDBS2N^_2p zh0X!wWUeB>L)LxWQQkBq&D2E>x9~x+jj2XcKG%(B1ZqoEdkGnG?pY(b5z_4AA3i5> zE>imWPb8fV8N9L*`&sK~)6#p8vZ}A++OI0-zxUd9{u4Dd)!QMvQhT5k~8L^+}doS@xw==C|Qq6Qy)gG9URRcwP z_S=dI>GP_H9c{$cueR#Z=o-f?di4(cTv`x1I~UZuPGUBOiDb16Q{4ow@gAbbZs5c` zV3+@UY-(NOHCVwNqb_18X!4S=@?9!!RNV;dFq>VVhIoyt=J^s=gEe0D*dRG?2S-|{ zcwUh3auug_;Z->O4xvgAFLe~V-hGc%jnd9{5?6gCmHi$v++OAk%hL{_iX&rm=3;Gw zs9241XK!Qle!eL_|9O}$ykrz(4K-vk^FP4X7TGv}2}I@uE>=gp-4u?xQP<1@a<$-3?pc zOPJKP6G)A?e#`7N8?7^Tjq)r2aj4Qv*vypKkB!m3 z5=lK&^r+5l&<+QA2~GCKQ+E=g5^TuH;7X3FwN1>@zq9xOpDjf$bXK@DjG@>*S$Fuq zEOOigGkO0}Zry|-xThmbI*Y!>dxO&QA(Xyh8Q!ugsG<*p73|TnzsAdwt!tOBfRh<2lArk3k7>%>dl+l(qzV2wpT_ z8lTtiI(0i`g6h!uX(~^-D8~%o(KK}|jc}Cajj?9O51|^OyA^Mt$9(5r?2*idD$(Tq zTYHDb_dEVEN!#$`{4Em{g^+Boib|Ot!%zh30KXV zW0K~`@Qkh8I&u;QiFg@(vMh82_5AoRWX5xq|7L2ou@obaF5uT-p99QZsXY}6e#Sbr zHBTEK<#94Ffnt7oH*8S`8XBMN6yQ^UVV|L;dE60EMb`9XK|Eu-ZYL$9+*gsode z&D}(tbkwbK57myB8t~T)!fg|A>)~<9`B)^oMeO{15|ZxQfkp0A0#kGBbEKS{L96@S zLUY4t%k?ADa3@aP4;`smy||4}nGul-*{4hK zADBW}(+PW%;!%)rE~owyzy49($u?ylC`rnw_J#gy<<&ykqJz4W@ZEl)1WWU3{z1*g??{(I$ z4x^U*A|zJ!(k}*A`2y5T{pT>>ZYq*AWdsUoB!X!IxuOLSizmqhrU1oRP4oLt>fe@D(scTPCCeJK64Hh^Y5nH?p$zTI zMnFUkQjbRFF$q&tzjdPaGb?8se+CJQP zM+V%z56F+AVR)y3Pl$B8^eq4aE_OP%`biUq_+?5=R&wjCSD;0%-G#8`5Mut8xG;-) zkxD$cu^(TWwgq>J8AU$GU509--XvUA+pJVq?rV4Aj&uj@~u>S>f@Cc$$pKG{;N+VEiyQ=N!n?l8> zS1%_&dc=@=1GnH$ur^1_rF=y%*G%8aqYl0a!uQ!yMuElE=)QS4?_Z>339WFWar8=7 z+#a|*)FCQDdA(fqcFs0hd(QG)R%f!5k$fKIuE3gS0HpH<#)}$d^aCQvE(^P6>&4VX zxJ%~?^MKN^%GTiy#xsViWAN)tIMRP3a$`3hN+KV>^Zf>R8c{1#o@u!_4d0nlhPnFE z@uj6==TaQuD#m%sPFaXHVAsz;+4F(fk5_RD=)18EbyMOl>%h!9Vr#xUbbkY3i z`vql_EfuA`4pPa0ZJNJ@?8FNPs+g`*quRUSgykpI?EO}8l>@Xp<4nD4CO{Q=vzN}d z$aohhkmZ`!fyG-Gr`%#cT|^tQ74`fQq`i8>*UIY}ml1Tk5Dt0m3MUIY0vG=YeGKon zE2F}U>bgx19bE~Of%9=cJ5}z@RZqEf_gyAz?eR!H2pxqPu+Y;;?0uSF zrj^Ep8)b?`h`?W9m&GZ-6m22HPhUDAM2n%OCiD3ICr0J}968wJB^MY6$?tMybbnpI zND+Bc+ebcFI7D);l$1PibaK6`r;9%8;j-TXMX;}~J}kV7^M5;W3vbQ0F6I7vL-d%I z(eNi*el*04e#!T{Zln3266CpyX9H1KuK3Xclqt6oNB&t!?~PuDwtU%v&*rI8uLdxZ zmyM!V52&gOAmO_qex3F+lv=an|5YdTd42PXbcRGLV-%kndCk&&jty_pbL(Vi;WWODp9SK6dEzBmf)Vn`)9A+l z9=r<^tn?b9M{vm7ZrZ_jk|uPG8ZTY9jcIor0R~c=Xd-xQvFQ+6R$pWsaF)>;1b^Xy z0y$)p%XIkr9;-f_23Un0C=tHtF3`?Y?8gtfhVU zqS4PulJ?hfB4ub6R`r%RAqhflAMYg!Cy=7wjEcXlYpVtx4IFDSQ@`xde*%!0ra)pk zU-M>^;@O!ycl_i+pa->;x4^nJjmyXfYeKXafXd=-9w{_mW+nDDRq}B7+cS_Zgepq- zx@4;O^?dDvg$Q|~Z6)UX61NQ|yPe|@_EriH%VAyBE~NNH%g`&EM_xen>-jdO^jICO ze3+++n<-4YvfWDVdg3xcQyJ+2Q0e;#!hU?QfLZSKnXL~&7D~S$3gc=A={F?b2KI2I zMN|-aWWlx(#&0vtYo=z=4_B(gfPoXscx(N=L@GXse7eIr>bt6e@3)ez*vW9I^ir0Z zC!#`(9s-kHKoRT0NE&HEdO4CygA%88mAJ2k@|>Tf#WsVMi(&0&nX!(HA3eDH-=mHm z21DyB@I{jBI|seC^Yu)^YDPilW>2CPoU^ z?kU`QAKU+g{x&3r+(=(sidTOO+Va^-RaPugojPTzryN(wtE>;N%FHzI0vmrg$XQ>7 z@?n~TTo)Vm4wL*D4MvLVNhU>~M)D4E^pEA#Z8HNt+g}-Mm#}iIHIM@TeU&@`ZNb*w z$C`|y8+bNb;Mn*VaO*l{^-_0gri9g~gF*;Cq)*<&RBHezS}9%ZZ&V*&TGT_EXuGLlW~ej%P99>+@Q^SpW$(+6Hs8hypx^N6x7w$ve6Y9^|t{*lQbN;CdtZ_%qXO4qE+M8TmJ|IR^7kz@^p0yw*TfH4U0K3ETNx zGR>L#_Y855UUs4gt}SQ8-oFbKxHrKce?CX-pVN4cCaLzH`N|AkfL%{ivNEV)-gI$a z1zh@;$@OO;9W$6owyqZ~`zyn{?&lxFKFUt^}nDr!7#>en-_reZvMi{Vzrwtljj2JoV?;Eyj!m z(ki;>Q{(ccuMRgVdob5T3rW7IWX zZEECKzJ#WbTFJMYE51&3F;v3mrcn`o;c;lm8fM{-M@+DRDLE@ePlk=Am3Ijg<&JV2 zw)Y<|cmV>ab`LY@0~$BGMsFrkRk5Gj66rp7kiJ){>+Z_n2+3)v5f{Rg!qR0plldu| zU!H5dc&@6$zQ3CpuzrZC@MWpNvxd>=i8cskBqVUOa zkw0yE@ZlJz@{?humi|e~%wGcuU$CS1)1p^EKOkVa^X)$;(N=hSel!B?Fg7%sEuLMa zn!u-aU!F(`r#Tvif1~xcY95d;(DE=Ot-!*i5_Mgt$LQ)9W(gCW;wf(FNkOtbCH`2Z z(tQnj&dJnNx}K}pVl5wr{MD0EzSho_o;4h~`|520>^+Jb9RgA~Be=~Ugss1%^K9v5 z?z+bYv^0AQYM1mm!2~^d#`t2tcqw%J|L>2aM&e6>#KKAUb2aRp#!RGtT9TsEnrh$9veq8C6To4Si-IK1(}DLi z<{88{_427jt{*=Ra)h>%2{WPO^_viqhv+`rhbLMo#xZoc7SwK{g8XkRV6uFeiuG|Z z-fi^F+!}1{oc6|B>=@61QE5$POnv=882K@%&kEFKW@0}iT;BhO>*Up+0^R2+QYV`C zWV+28#=eWnbGex+OVdo$UdizjaYW_F8k0%Rv;p5C`lnw{7i7*qs+FfF0%CdnjpS>rU>GY7W*Y5f(FgZNz*}{tK#gL0Z?)u^1?~Qnn=yts{i^X8^$E;#IUQuv-7WG5KKZ=Ul*%!v@#uZ^vV;w^?z-v!{5 zeAK51r%#jZ_Y2b3x`jW0@&|t#HC*CHFB!0nikdtLZ_ij254CLvYOI5JuWz@~at6Xi zsV51zELm(v-o8r2{h{kR4+svEFjl4Bd1R-C!;hy2vr_1e1e#qsdQAX(%1;spL06Hn#CRsUySmn4&~Mb_jF zTV3ij=|vj1QMvyDz4yM@*ivyG6@VFz&RlcsN*qX~JsaZMWhT&iy#ciMKoQ9r38Dh* z|Bt?PYi^?FK7iJmWNPgu7CW}ka^-S3dzIu-=N;7k))T0_cT}0(Q8VwqdWM5gSy+JV z$Q8$ahMU&KR(8^^4rR1e-e$KRS2Z7;wOxdlq%V{5Z@0V3ZFH_`)BC*E0hcFm#|g-O-F@itka*F2;%1VMG|fG>{O`M*w70NsvO}sA zX4+i)eb=bGl&RPnD2x0R#Gt634xrisGTY_#wrM+U)HpZb0#diuzzD3dD>Kldj_c93 zCfH|=2;b2XMA0V`vqH$=>LBfB5p@96ogL}CIg>n9&9CuAI5A_RnC>FK&KDK1FCUgn zGm+jz{4#o8{`W|lwHw*5q&xgcFW8?z?|o`5UivjkGNZi}tfh7k_x3u7rla*qj>Z+p zQCp3aTQ;uAS>`%X{RNuGE+D7d)D}bU2OY|m+bCAJ$S3pDWQYGq`{3+iSo__2vQBql zk{+uTGfT7KBqmT*9v{-T3#y#8!;scBQ?j%ctENraIf7RoVdnn8-hLi|Ll=&;{H}p) zOb0l?9dhyUc8qNlgnG;bgQl&J(1RDf!@yMZxXH~;y;&e4a2lENhnPJ~!BIqhDZUV|y@6o z-;~&rNwuSt+}lEJF{arlvgHs6fuVaW1#3Pcv& z^gM?=G5aXqjwA|6_dlJ+yM;fQwBo56l!P9A;wQWATU6# zo87fW4UyVj(t+$r1!idm_2$kia&%`A`RNbcnMi8OFyVF{RHVZn(H4(j)wTWnm`h0h zXSk#i5l(-=dtL>ck(Y@J7gdSXo>=qEBY)w(=!6TPt_!s1`I8yR1N5Y9R9M2!XALkK zQjPOhL4{w9qqXevsb(6FlT0g1q6^iiEfjhS*&`d-Jlf*xs_MXge!&%}FlrE1%zx`Z z9qtGMR%3h$@iV0oe*JpA^t6S-CC^;05Y)A=Frme&I1Rt(^)FyQd+6#}lQOe@AZJSTUc4R^VTl(bul0le~G0IkC&fhDqfG%)m8#6d9?JnasIn3 zZh+l)uYS?`K(M_Y;$Nih`X(T=j}73f4_ntQY^Im~*Kb^49}kyi53uhX&BI}DR!@Hu zn?ZeaA-aI7dOL7MoBXx#2s3#fvt83~3@*fPMzkxIVc*%_EbfH0k|{=BX%csNp{=@= z)_BY~dKVIMB?$jzE@R@=V^re`pd zEmqR19X7&(UaZ+o{2@Y|a*;Srrz*NUq&3HdX={YK>vt-NcosDkC1*aNZRG2UXHbRR z#Hm%(cV99ZGi}IkfgCi@8aL&HG#}}nnXIzU%ObdrLdyQewqL%iG#ci5YEEErOGN1z=F7SdHsw4j}x%sx2>)~ zA;naoov3htI826SG=&Ki6gez}w%EUc&9z2sHK&s&_sWFhQp`rKX&oNItZb z&GL~|dKGVAL|@}H%%N43_tL9;rTYb%F}-ws&y?`BmbHtT;kJp;!ysFox06(26up5T zXv|mmTd4bt*O)6)voRK*8k(ka-$-dVPV)K8;=}=F9oY{BJhD@qIPIwKvZvH7KO>ic z*>;n72lbK3$7XkRO`0=zH`?(h9M@tT(~4Y_9mg{P8Pf4zW#}*TdaeOo+DbfSDds%; zc!F8*1y%el(yo0aWPnIBK{%3HrU z$rn^@mIlVd!eXSy;Ho|9vRYa*YOy$gW*>2S{mT1L^ao~ns-^c#@D=cW{8E1ADH7?j zWj?z5lV&Zk0E1*@aH=*p&zEdFYe&X%0au4Ad6Ikd9A~Xhaw0`PXQ(6}$g;$<$Dt=| z2!E4Ic~)J8v#jJb|&*PH|=TM+Wtf?}#!)YA{;9ScMsI7wh zwHgrT=1Njda>OZ7QJ|q0h@@vXkOxJ{fc5Ex>Z%oP3%J??S9$%-p#V@wxGs^rK4!oM z&6Yvy4}ZAX4am*QDi4==7st^ZMjkNi?yjJhUV_e=QWv&0gb*LzfJInpK?VI2?+JHZ zzY%o)dmt=$t86ZjTzW5IHU_|@Q%1?xNMcqIi z?k`@uBM?511)}F21EH$VU$XniwVUZy+iAG(6Zn^^U0%tqNYa~mc07S@Jify`XF&}+ z5MT0_EU~(KK7C`#^dY12#xJ(&Z)6o?YVlsQ?4F$>wkJ$#w*mH_N$dfJ6X%-fkaQvOYRe=KV%`pJ-SXOsa4M8$58fXe3J{Bmd}p5sj}%HLd}@+o`cq+ zHY2}Dhm6yBF18L{WhVA^eh9Of{T1kBOBClO!gBmM!F70C~Yr+ljY^f?VcN?#j#9nm>q*cSHtdJ`gvWuG@ zLF?p|s5`;a?|?;DU++79w-L z-6py)g7HJmg3^Zww~`@pp$P>it;g5$ML3v6*|=8X-LHvR8ltLI{AjwWRL*c%$n|r# zsym1tnHz+Evz0aZI>~RFr6_i-N4?Zj_+60fBf+L-qOZ9Lb2!DxB)L2i`(Dw^FXPCp|#whi()n%IxV zbnF0ORMXxh_A9`esTrjene(!O)KxrGImcY|5l8CsWtQQ71!q)RF7tQEO-Y z{lN?kSMV z117}%SGIBOa+rk|U6>U;h+@8@%+MbOJYj0R6sdl1jJ8zuixXd>x5gBZ_r5x)$Nx4J zz2nV$PNb8P^W-GeRt1^t(C;%vd!To{cDe_3A-;i_@ee*jP7I;-7n$`3;U7t=i2AEY z-`xLTU_4S>baE}us(A>gbc1k|Nhc<7KyEC6)38c@jk*$+JWyFn6F*4W$ak#dMjY`w3tlvC(<8Ik-76UNvy?=a3Kjr zQ;*PfE_m?tx0hq8wYFO3y5JFjbg!ffuNnJU>pj%rpT96Zmb~CyOu+|p=+?P*5N{zO zI5Ta_&|z3(I1We*PPB>`x_9g^q%3WZpw0^V6>1;26_`BYtm@R}E1`W1IkfaU@xYHb zEurI15OMmLB#}@B-w{tk!=o2N?Q<))w)s?fNjo4#;We84gf(BU1+~7J)Nfw6YLqv< z&rBoc=RFxc+bCs{5%jU2QFioe`{{HJ!Qn6~I&65v(DR4mAitwHtg&qNkc+G} zgnsy_N76fenv{hs><>m+3W%NE<{o!fjsFLkOTOqmdRuMUC6X6sp z$sY2AyGO~=KRZb2oN@t@L0CD-M0TP!dihZ+(KZnKA7xXkh208hv8M*nD7gyQ?d*tY z-!7B$4`VIU5L=kIbZAFEo(Msaw^gMdhuQ1mRiXK`w&c&SPnTrRo*?MFLd@_Wh_*J8 z)y~Xlxly@$zEI{Po4`}N-$Rp^=G*GPDiu;#bn~ePOmg~6sCYkL6iXVnzWNt=HZOd~ zuxZ&Cq2@YMqqX)%81--2cK~V0gW>Ps*?tH5nJyj6u;VcoRN?2+^YDEklq8neMjjrzDO{j`+N{vg7}%#SeeDGP;(V0pN0_*H?2RR>3K!i=|7$mGfs)WxyU2= zx^=2$WSoB)2eBlH|DP3yAxjfm^U@D(9DVMXe5 z2d$rL_?@9av%}@sk%?+AM){V7p}{##E^=QJ*~{}*o_l9uOV@$|a_nD2%sLqPvQ(BLPoc0tA5X%wZj@9xkOu;HutjzyQWsTQVUK@$RV#e1B`geO0mCR9sZLePUw%6 zF5%|PPo?tt+Q+C)FASEBH4Y6kNG{^p1?bWjS@<4DiSrVrO$>2irT)ziQiJ;awo>%c ziX|gvqUdKlI|*&Uv8(t5-~b5I1~{kPnyhXg1Y_!ur~|@)PxSgOBfo`aY1O`HkUC|w zvEBGO^=g6Y@2ebCSGFpAnsM|D+8U$Vkb6{S@9(i_@gX-jVAxzUY`!>k5^`fj<_Ozn zx4}4|t;ZMmt;^_wyeKf$UrlZG3vX$dqN51~XJ<^LmQs zl`8!*;N`h(gw}k*KpxdOP>(05?Vz@Y@u9h_BrWsPSUw<`dKd729RCmDYqan<`&H7l zW{ST*9$QvqMYeoF%}|{q8VUr9wPQd`&=bx66GY&r0<;dju$Pe|wUjE&A)g0gw}f!G zM^IOecod+)wR`7p|{?~uQyDB&s&MP{Bhcx zo-FdHxh^W6`VmYWDI}DmG`n_M=V222Zw%hrNsyONS0Ab$JBvKY)g3tKK*qZU6NBOp zmXaCIi4@KV>a^Re?AVg%Klj2KL6@!PAp_j&ExGjQxCE4uK@vUKz4#cb{Dgz%C}{SZ zD&CCq@bt<=PbwawEobwS{Ea}dh`8z$W)xC*y^YshiZQ$NSl#|LNoP!_yw%mx&sUu zY>F_qh19pvzeH|TEdKEZ7zc%)sDd1SAS=dp?8LMhtCykX(Z;H1G_F=qJ29T zrmo!~jpv6aFv~L#1+xrNE0I`lfK#|Q+S5su>Y-L8+tVzKh*NRNT71q%5cUq$226C7 z$J?06P8RL6jyaWyeq6zu*z)W^=J z-8h@jxcdNw5&VGtWwd-0YFq z@hrbJM~urdXCYR{-eQzsA`xBU};Yr zFy?X0a?CK(GO!X~WV8Nc#VSBMTr|T@bl9CG~twI+1|UKH)dB93GW7G8IqhAaZFAYJFBGC+%pUe0w&Su|jP5 z*Mr8ow;p8Mb<*!JZe~?YJXlNow@`dr6NrWEJGa>!~bip(199f3%`EdqM+^xpjUqQK}RJk)5!dA3?3RG|N+g7vyy*OX| z`YbW)ERpUyqAD$6x_6<4&-4zWurW}1rzx;#j?mf)nVZ~k=Xpqac%}HmO7IIJl2V9V za+wwZ12EhJd%c)Vf) zNcR6YI`goY+W(KAWtN&%+Lx&aMJuI7O*Lc7W69W4sR=Qt42DLf&MC@P_ARAjdFVkk z9z7(fLxhlnBoQZDgUTpvRP(#PzkmGU@<-RzaqjzkKJWMIbvFum>Huv~V*JR6h*|Vj z!9nt$#x%OUDvo?N7_E3DRQFjaZ7&(A#$Peh_dHJ{Gi%tiMHIDViF_Syd|WshdqJ0A zez$|tep{vd>#p3rgk!}bc6=h5{S27NFMgv7a>SZ2wFDH+yOpU1PT3T;_zN6&H;rAq z0T%HM{qCv&R~5r5Wu}wr_JmDqQ&eD`^H&UgqLs*qFT+ltKG%)QN186|!;;*HSeW8pvdK+eB^6jNAp-uvtMiEVUBsTXw<&h&+Qzx3+NaiL3=KfAd zTxDWAKBv(?_YyCM3b5oFS;RLD_`R5j=R@Hyjmra|#%-%0_fgB?;&aTRyF= z!;$YZQ~#kYXWNoNT$8Naj0UPiSUDjpays1q=I-thFbwb$scP*!0E8SCQ-O zc!MqAFy|uO4`f|u+dxomA|o{;NuEa>vbMhcYHCK#)-dtL#rq*$?Fxk`7}$lEc=6?zFAuV}#J$GHW*m?? zl=TVKBZS^sM_BX#^-uWq^~Gu)utv7K^aNDWeK7yd`kX7`wpD zM_b&rKV2A+*WvPzp(n}m5rT?y?8Y!w`&9!xJCQ)uQs*^6P*g5r^8}9nj1=93-Q{S} z7gn?PQvr`FXS$AZtAqTD&DCz6g`ju!3~m;};TcYjE)OC9C;Ql9_nxjlbM^QlBFa|N z;;7vW`%g8pdI=zm$9oH+0JpkfHW~FIO);1212!sU(Sv@vohoW5LH~IXc%}2-0e1Hs z-1XiGe1TaBcK_d*&?Dy@9P}a5A*w#aEnU?31YvgbE7~Gd` zrf@(3@MC(QwD-JZH>t@+u>4E+S2P*8Z*H> zmRWv+A2v2a@EtAqDzGVHY-VB0{-Q$vPWzvBYK=AZa4%g412Md1*gU-97gjf7YwuTc zRC(kkv`-8?RwLyy7%HJkFPii=Jq9INN@%06po*bdrCla6JMjk>W zl{SD;*t3P2!9cz0hK5qvLHCYW*58JG#cAlrEK?2j%7K1htK{Feq#LC2jIW;iONved zBJV6#c|{IeEV{#NE5$o|*oxO&8z!S@3iNUoG5CiV@D#pXJ7f>IZf0fZmrpllfm0uz ziY<6bj^f%CZL5ZwI(XshktV?)T4wsq)oUAWQ?U;hWe7W4Vw=~(R*g5}0z?t7&{lPB1?TR+ID!loAnv`o93E4~k}-HRoB z{=>YycL-i$3CLH&Wruu-v&+&9j5&^o(2vo+fa!4;<+lv5EQSYTUCjpRo*?X&t^8a@ z@z_;R^s4HIdTXVJ@|{TS=Ao+xj~{Z_NS2&vfVktR9%Cw1LD>ZsQgHSJ6}n_r8WMH= zk5Igjaq;aAjC)x6>Yoh3VL1PXf!hc`2WKA|sey>ii+cUYfE#oFhXrW3RzS|?eZ#S9 z?<&BSisP?FKpw_s96E=IC7rlTPO31FF%ziM9>Lg&PXT(jp%N)5V_3){7b2Pla!F^6ev5w5ec}dTAa*<@N639?iJxvUD6WAk(V}R~ecBksxir+*F$ld5HruL0%$^yt z`&H=zRSTfKuV&Q!$=EU*^Y{gIH%PlKg0A2q@OW;(LdUK^PbKx3H|~x_>K>&xOnZxV z+>AvF`j~HpJi9UMiBqMmVvJ)=jkJ?HK|XJd{aO9aS~j~$gp6}eOJ58i)%#(K8e&=s z@jXfw@k@HdTQ_bEb!RU1Z8dcd2+uQRd#op6%t^Z6^G47QqYbhMKdk6e6}dP7z;G9i z#X~**pb0CXxxI*Qk92_@@#cQQ`y2d781(MNF#pB|*i|4OO&YZ=^G2)f)V%;l?Syd~ z>44zaIQct!MXXne_%-MmzfQU<#OL680XL<&+aO5C2yq;SsEae|C zZXBlRwmELVox)Q{)~oh6AkuY9P5rj?rGaA;38K>f(%%ykJ9d!q1#RTVxw4xU*s?Kt zmpAqW1mRfVcfCX-%5LasK9%9Ph(whl= znE8al+l=z853br+V;jLLX3t{jR$j^i7rnxXIz9Ubp55H*5aq4S5QKxsE!=dF<5q8g z`t!)pbVxPN9@QQ|%jcWd4}(2kAU&Pny72@~6hp~X!~q!;iqJWA@e)G$Z!I~MC zeP>20UiS%00a_-5RVqIWi(_vimnC2X#iq_ImERk*Jl>EBbx{#?>9@IxB=bY&v5@;^ zX7>j l|L6jkLz>PZZgfwe4yf22;&oA}(=Bmm!(UE^YjW*yvUbB5KSes!}+N&_W zGaVPK`m_%f=hxOj;m%!_R#C)@ZZUo~y@C{P6I6U2t{woX+cFzmMe?`|zRg_e)$<0|7(5abCL51MF#n98K1XlbQG z{a54^6ZT)#AFR60Ei^&Of6%`A##L)*WyZnFJk(XC+l6XU`Ys5`P%G_OqYAgonAYMc zw}z#RAJ zQSVdozDtJ9-t`ze8}F<=%l5?H+%K451cwv=VO$|m^pz;8BMxjHo~L`Y9`K0kez488#G86) z)(%Y21jWaL>d^%#*8}=5PkN~r#0L+iWq4vxaozxP(nZU9F5`)1D$CbSde-qr!L3ya zR?j;ocB#OCw029U{32qOP!)d4n@-MpmAOFw;cfxZ9Lq~f1JoeoRX55_ptgOyLk?CF zQU5`zLS1W>Cpph0K@kRJy~L+T9Q`&ymgoMOfy|{4-`!Er1xM+WULyJZdnlro7!j;D z&m}ofsg;q>${N1i8Fu_LbdI;zLqk?G5(R*OP-AlhHa-3Z+iY0-?*L*o&$W#z7%%dE4;(Nif1AdS(S)4 z-wBj-wIhEsBST>S^#yR_#Z}BuT}H1Z`bw%opL}90-cB_9idIZ}YWy~;&!q7I(!GB~ z;!Sk*cD#d;{TRE3rgv;L7{!I*IZT$wzS9&`)RL8?|7ROj4B@8V3!EmhAfkOD@%6xZ zVwOmn{7e=RhfVP$eO>j-=ZEUI0e|miFhP+rmxl(?DZjzGv4fO_DKw`hrGWxa`v61GpK*SI)$KhK@l9`n@jxcg zmq;%ht_#fxCYxOe=B{Ym`3atLgXumWnV2g39NhD}Fbau}U@q%K%O$N&y1FzPnV3L7BP+;zH;8*zh%PZ0NZnbEG`AVI#bF)C4J^Ag zeNU0xs|KM&%xQ#H!Oa)$BW+U$m?dfh^fte%Z^$&$@_(M(BY~#6-3#awquxvR6k~z2 zn#ou0e&X~mZzs*(m)}$$fI~(XpYi4335jNHY{_La!8D}rz&H6OV?HZ86ub7{ z5G&ubx`q_A5njlJ&9d)jq&H2Z+z61`O!)vp?O=!(nEJ`CdMmxnk=W!i3V-uidX__& zfPi7)6Hoe{*cl7Kx}XbtPeG5iQt$ez$Zo&3w{i5>3L6vqi-BIEztP0N@ItYX7_q~-NGy`zpLB?)~dEr zRP)(WnZ!|R8a$~3-Q-pcb>IzA`moPI?K)Bj4p(?4&VRNSY6|*s+?_9rrhmNR&`jY0lfVPMjv>N zCOZYu75;_sLjR$oOrOg_yM{kZI~J>X=sw@>2*jVW0ckxf%PPk*f4+x=Ys6dH7^re* z6tAptuVv#^bWth@CL0wx*D~X>Gcxs#TsRGUT6(ra?P=_0Ngvwy#=w4jm%f^f-CD3e zkQmF7$BshWFeaYB&bR1>8&ASTJI$dnZj{_znaox$@>U*WXfvKb;m-`8AFa#Ww;l^L zoi3L#?Mz^PH~P{W<$6-Lrv1Q^gJn~aiL-WFu>-&Oy2|(DR6Q)--X$pWvsCvF*PRct z7d)ttD1*KSt6XiBQ8pS^Q#3$pc^@giH%zxmuaaoFESo!UyI~N%{HqFaeY20OL6s)X z$^c8HGYCowsdG0SRc1ScW!VDt%dblm+yPguUneTwR(+2v8HB-dO;zYn+IPTIe5?=A zV9!nIX}-is<7qc`SiOTRQG9(M!E>I@?0o>6Qg*1EF}8OE01aO*50pSU7i>OE%}-*T!G}9K;Zq@mqgE4MxDssI8AIG9%B+*z*H(Ivy*Ru>~^3rAN+r3*ermLjM+F#-|>*Sz8*f8D*6U>f5+#?bDz3A-w#2~O92`TL)4Cq5&%1;G7Czc}{PsuHzaISzd)h4M}GZTA+is8elE$*76SR=%>sz*p`5;G`1R z`;6|iE_)y-osNF;@TDia$z$C{jeP9Lja#WllA9gyHQ#K(a%t1w1ZSVQm3WT$s`A#lPrl#JeEWeF)JvO zku=z2y%>idF|pL1xLfzMR&W1+z32>)Jn|i!{E`Ulm`oS#kdR%x?Y9>UCpOjIz;^H* zRIr&++~=nof)p{og`gbC|CoMleY(xtbi&jN5Ac?96|%FV*W-H*?h^$()T3q77TRf6 zUNO=R{5CER6pBAE%Ap;$;*IFcUdP0A3$9^@z2t7Sz`xw046-g;#rU*}+A^8)Vd(BI zkWV?n6@Ny){hfa8GTxEY$B<;2m%9AmY9~N{+fwr$5feHM4z$)s^{thy-TMcUq#1&h z+=)7iMO2HD+-*@B!BkHk<+7dwxylk0ukStK_#ZSbi?tG;(SNOuR^(NIN&R7#NImMo z$h%Odv+|0y&T#@YX%JA?i8Zsq%4v|-w3&JNL1o6ZhZ{h6sQFPRvrOLar26*RRA(WR z?;8x(?R259)RF%pW%VKrWTW~y5)9-OQ3j4A;)A8!P8~j0r(8y*hi#!eEGX-rWag7( zT5amG@8N?PNJ!-QT9(&~lCqGWZ`_0s+t%a_-D1Z9k0!0*?<)l0dtInb>X;ABP zS;z?#gvmoa<cCKH3 zhW*yrz-}DY&v=_^EHPm;?p$#A2s8SID{z5!Bbp;#I-oaR=0w!E7n(xlZ-LbAAv)*J z3@9MVfaezoNsx~{oBEtHlSeEY6G_+DI8`sD=QZc91%J^T?%0dv#IoEQ2T=73PsI(R zcNh7*U}`Bs#J3U?-HEGVse`N|h2(Tg?Fe=_J-`kla2s1Ya>DS^%>xcDl}mS6rNXa@ zZlw(!XsOGH;Pv9p&r?~Uo5GIgqWc`!#o3T=oNV3hsrZHwNIA#mIJ*-1IE&-+ndMe> zN|MToOSuL9%^@^2AHE>OFPRlUAmSR!~suvz6blU0U;+&1&x>!vd?zPcHBk3YW8Bq@7TH= zZannl20r}7{oeH;lByVFTI8VTH0UM3BBoDO2_9mOnn3*^Z=GJT^`CP+h=+FpGs)o7-qwNMEpNI1HOqqmhcXV{`26e^Bu=Aa8oh*cz}#?OQ36& z^3lc@<+44;hTyE5(qz5N(iiinfdNL}-h*^BDnG&lIOocIZdpY>GfasO2ZoW6Y-(%& z+NN=U;~f)E*)JC;EVGS$9Qffgemnf{fSl&1y%P(2w5>qi9jxKRO~O0IKrX-+ z@?`d9opfkG&~^j6X7Vp`9mN;F%CM;GM0&TRXMUBvs!T7oTg57#$!xyLJMq2$p5Cl% zGmu@cd<|-Hf9*K)93ji|j=(`#N)v(hB5H9l-O*R8V2GyinjE-6r%sss>tJ6$ z%#hBS!GHsjN&CH6WR+rsLV|O=$84eF>{YdJSO&T;Z3tl0-sJIh zryR(ZNz}KMzVsQ>sF*EueO;P9b%XrxhinPNsF$KAx_=HPDo%d(>&sgw-%w)=M4+Mb z854uBv*&mPICu0Ud{3gZ8ox}eIEk;DdR+EuKC-0W8wr^z%`(ETz0ktRGYHcfY4R&s za#9ug(LxZtSI4>R)P)R zOMhKogMmaoJpbj0MICtVScNA|D8Q?~5?$5N z6-h=FH#+RA_Z%w$t-R(NIM*{c!)7zNLnHvi& zTV3zs;+~#aB6~CKJz{$)8b4yL$!2KfEo_f*hmnL$vFMkqx#V=APJZe-+0C3!&J$4h zG~(F=>cgbzbiF|Nr#UOJ1Y7+sEw+yzxAztzxSifGB<(apKJ%bc=$R z+!vs_EAWxjGA?V=P|M@nSRGp+(dpmDVl^M&2_?qVOprlCLVFG4Q zM}u`fdja*cVYO;)L+>Sr69_JNcp_MTcVnVZ~}Wv)vrTB%@~&Q`Y_$lUI%g>&tB1Q9BwT1ujzMH%`{f8vv+c-#CL7C zEN!P|ed7`BwKZ`sRAoCM$oPb>e$)BFbGJwzz`RhH)L(UR0FP|qKKuz-#Kh~hMiw#K6 zh`jq0Zd(+su(}dbT2g7WY|(Xm-E!&mm>_nJI1OC=4j)>woQ4Ij3{b&6@-EcWFo=}d za#PCPRKHlIFaL181~bmD2b8!d#I_(B)ThDhDM86-a3VLD$k80WM%M&X47RSC`t8}U z&))!^lv%gWp#-$YQdgDz(Rt`cPL#1?N7M0F&k(1Am7A??`y?VD9{)l9XH8`Mk}hDn zkvnh#Es26d);>KID9o$vtAWBFuxC0)8g|Cpd1lBB)?<7!k9 zqT{P{4hxTFO!t;8a7!D)i(|nC%%*6F>F>=HvmyV}3x}6Y%tae-{Nc5o!$R{1j3hf} zv&uAKM&esP9m1Tw?r-mhL!eae3bdzA)_Nx+bTEkzh#JlB?()lbqQ|9V;zREY4{rZs zsOb(Pyn<2gWbZQ^%1wmwhxf5d{j9`qyI7jj4Bhle7J99#GUw<4*>KIJm!|*YT1O>P z=I02Wu*m@+G@$5Of@P-*Vst$oN@+mByc zGRVA^DP0G8T7UTe79OiV;m1E z@D1^&{RB3Iw2xpGeHs+{8!1;vtYjz^2@mv3jxGK8jj%kW9A4O!r)u@>kJnNM-7Sx|HBauieN#Mvngk zERzmKlh+a}Bs-Y0Tgp(C6JH(un@yV(?d9$N<31I09^Hv84n!|RYOp_#r(th4j+O-s zlfF5F@hxLw5?EBO1yvEGO!zfXn>f_#pkHpQSZ|o9UCw-RBHd;(5%7Jf>`f2$A~jm( z!~+>s>aD+W$3&gNgnFqZUe+40E|SPM`GIfxhq#lEn`|r;ntFxa#ViXX+xm~grJwor zWh+**+5=X{Kyx16LhS?jHcy$$w9N98_CAZC@MC(1utQiv1De0Sj`wy-9WPR4)O3-z z*3TR7y`Hw3W}iwJd&vz@G|R0^&ok8lV+s!;7v<7R^)mAS8?I`mMpuEywXL$y))1dFig+t^Xt9t(fnw9;Ph z7L|o@)dxpwB7C%WS=r|YQQy8v(qmg;+hAfNOWii!RP~_KRSWaOzmJ6MZbMOT?n1c< zv5dw4?jzj*3z?gXs0TCt8M9=W5Pxyk}q+AB2%2GF5cii9<@wPw+IPN*~ktX+3AH98<_6CtP{5ZZ!-&R)Y2#j z{ET|xNglA=pGx&a$k|+E7J|Dm@~Z5Mll*)(s{0;fv{1TwLIkK>FkdgNdD!PTv$udF%B*Z2U>4IX( z9Xs9!$#UNO-OG7t*a8jF#gHbhz;f=zgzo0AgVD1?vJXe?hr|E1VSCIOc-O8f-2KE7^49DBB{z2@#E~tYl#P-KMMCLx55*wJ zuuv?2hbXJE9lX-QZ_X-vZt3P-wuKhzvlhDPqk)>b;0I}A=5x3PuIM%@C3cyM*FSjx zH#OZes(55T(ZbCP|G)NFABREN;R@<4R90Fow92@ahk5nMrIha&#ov7YKB)AiQ7Olw zG~Y-a?;4=HID;w*BVxa&jY#y)u&~7iKWR921~t-;64B%-6XguE$a$z~t0ir`EE)^k zAa8-2Hf^)iSWZ;d<#CVqkHY?Zu*TiTQ8CW5>3k-MddV&w#HY+8yq{J<7no8fm^gq^ zyI+)$F%o&~FWW{Sdh^8UG%WX220s|LXu&|$>56R12jU;IRkZd;R$75IkP)V$uj9z- zBb9L0Ihi@zQ#=K}U@uL4m>~#31l{;~6p+$qvgjP<7Fx}*_0;c;rzel{m3uO*5{c?< zQucQ2+MM*dahje1_v)4@SyofAH(KeXI+?plK+k}b8h-s9#tjpnse+4T(jyaV8Jxx={&|Y3T#Tpxl+bCLVF2Qums`SD1>cJs*VUq zv)TPYG!bz>6;53HKUYRAKo9Z!i!JNBR>z|4OIdY4G7>H@_&d@C58>h%=n2?u0Y_(h z@(@FE(Oexl(NlGC8c(ys8z>dUF7JZi%q_1FvLd>@6Fm3hqs0G1q{2E|Z)#jXWI!1byr=v{_Ai#6Il%9CF=zYpLIt zTkzuN`|tqpd*={ueoI%6Q*BJI$v;j`shvQ2kGYFa$xbIX`<_XeOpf^$oq3;J!;&dH z^F-n^JzQ}x3$k0q^%2m5vZK8gaPoR zJ%j;XJZvxdY@EGE46PelpLv}$0mdy3QM;RY{DRB_p3@Gmeq=oaU(k@2z!PP3ha53i zMqgV&EnhxH0h7$Pr{Si__x0@hvO#8K4Js)brk*`kdmFL&0(42M06EI)i-Cw5ukV>h zrMuCH{Ad;V{UW|(Ud9*y+s9D2Rd548;@k%s_vMN{cDRm_R|EYkTaejCcC!eRIWcs~ z1Y4C2U;#b1r#}QxccxG|u>91JVDH>0dPa4yqE9>JM=*TPQyFONaw{#3+jbhZv^1~; z_ckFRO&#y6?nAlha6HOr-@`64{oTjXOp>VX&f3ZK*~PH49uVeEk5NER{-l>&V&*)? zlWK`|J7oc;(l_3+SD({8J}hU2`VF#*Hp4j$U|jp1D7sB#BuT%de`&0O+GF7_PSnr4 zkwkR`wg5-Svd^r9M-0*8U;Hpl#nc_uoyA*kBgPPgSRa3yl~Iu#6u*i<66>xkNu=EtAP-t3e48K>8=VSZ7@^g)lP^4n0j zgkuAb;v-P{HXer9Z0v5j4B>w}Cie!PAH8J`zNZiWo_f0v-^R;aFAF`X8$6ej_n zjWG2o7x?G?dH8V&SycYx_M2VZ-Tzsa`qbmVRD(O|qpd&TA-k@oZ`ltAR1xi8_mbV3 z#2-Ph`-T-z{JH_e?lUSX2T%`F{c90XXQcFl+2TrU-F|FMm`!8j0fzlTw*Q<3JWVcO zoB1>1M|?qxr^K-HE4dN|XW`Qc&ZsT)mV7MqH`x2|2KeIZj{L}Wo(&6a#(CwuR<0`N zfUwM+RnHw{waHXamR@@4{c-&IOci=hX3g`7>lBJ-BTZ>f(MY+GWGYvj*9T;TC!g=z z7i=wcZO3iLSxK{4ct;c4-HVa$B=El{D2+wxA3*JAQ+s;?!1SELC(+C~1T%~*;T#n7kFhxXHZM**059H2$A=QGZuod8{BPmx zKhnfOC}BNZ{Cz-wvgHZbzLss;fuZs;b7e^ ziuYy|k*gTZ1%gN>*Z;C{{cdJa7gVGif+S=4nm8CO>|~jj=aDxS$bTGViuc`T*=_3+ zTt33YZf%$jE)E7+K(*{=_eq=?c3=SQSh^Y!w0a|1R#oZy`Uf64LbKl#;DIYBcg%pT z`OBy*UcPX)UB&*kt_V7G6%h?ewf`B|i`$4(PRb_^|8s)=kZ4AsjgMgdzAmJ7eKcx0 zI$e;0%=wI29K^p&l{q`7+iWIgGrzsu#(Jk8&69kj?>;<4j|iNn*x|~_`^YF-1LuS9 z;^*c*%{|7APLPOynH5Ppal_9s{b6C5$Hz(fhAZq|e3OCvk58Pq-%Az+uE$-E$S!S_ zy$n_!@zs5>p?>~N=;6OXlrmTc?%Fy?8G6V>{n=d^&$QKfInnL8(yLM?OZgNesCOBq zkeMP-3@Y^F`#Ys`txAZ=cJ(jVMJ5NJx(mQBQl8OqiM?nzae6DY`4Ta}^*1;3QFF^z znX5gv6T?3JYfe>+^!C~`$o3@wcX9H1@MrxK>`GnX#%k8z?o>k< zRrEKHd@5FG9J^VS~E__9NmtuUrXFHI-A zB+_-h(oNOGfdj#0dI4Kp|HP;~(^{++lsEqztC~}Lk9!?w_RR&*oebmp+erSY{@?c^ zSX6w%9WwOgk7zd@J*|{%+4vWI6qIpw(Zq^)jBlQxXkvq4QuuLJ({AH(R&Sv4h{VfH zb_%p+v{@#R@3h|1&N|P`edIrLRw?kBPFqbmtn;uSZkAz*1L##dRGIAVqi?x8GWTIvT=|+}L zVdp?4j3vx{pYU`jQtCF>d^r@>6HTFnYH3<57e{`YRI#$d@GtLf-~5-nNgTHhf*&<4DFF#Sn`dd5XnvGp=~&L&98PYHqWJNw z^-#MlyLkuC<__yg+EtvRq2-Uc^x80aiIMtcYXrS^Gre2Nl1s5KtH8w^AVX!^f73g< zSQd-Ot-y`BWSgcE=pxJn;@DB3>^<+`WAg3;!P^hew?VAwA#rbm z1J12VXx;|C?O&n%>w2X1sch5YJhFd0)ng056-0$`rIgWF&W>IMWJrT`P`N3jes535|pvFeYOzB!E@+p9(Q4QH0Lv3-Z7 zqDy|JXSPT|Ba02_h}Xiwlzs(VGA#z;AIhjJVE-q$y?R3ic=7!}4B)1L*YV?|UP$*Q ztcOB`JS6@}3{=P8#<2KBocgdHNUzrZOfNpjj`l(AL}YNV9UY4*e8f>VNWc0ElmI_;0OaGX!b@yo>&;WS|e~% zNxLo(-R1-2ZmyXpIe$M~de6j%3FkT^`QQ2eBZsTKYVObVw3fD>rAz7q1u`PuJ(8r%Oog4opUp(w1Lpp}wxlg<>%V^kd65Lu9jCkJofZ7|O zkpbeuLgOAZGBPe~)%5fQJ{7iFF~^UvJ}=;1|xyGJ7B49|!S8 z*oF_8tAX`{M+KS^?w6`CfbHFO1-3m+RI8;sCMs=k6Y)kkxAj)yj}d5}T1@8(7Aw|= zT7}KPZC(+Zp(^~dk*m(mh2S0waDaD}Ko;M(74??jA<&BSxev z6wZal-ISV-P#*pT=$fVvp1#LZ;bkYeyS*tlPY2aXSmMcx9C*N#O#S}D;lXZ={Hc|X z4>z}CpiiJ)>96;h97R1m-^Tkuj^lZb*v@SvpVv|Mg^EcyPAVY0l`scf|*7*-?8IY4Dln&G(vHAms#29A5L1B<^SD5eZx{&53oUFxuE5z00aCaj(;m=TDFH- zzmuK+faAZZK-8!hL~L5noPj|&$72HKe~Q$ku`3ptmr9omJ05)lTW2S|&WxIrxVyzf zzjoDzN!FRJ$JQeuukT{n{0%HB$(&kf|7o@fEf%qruAWYseG=tbe(9sn<5iDaW3tlUveidIk zKc?&y`u9Yt-b{B~X-sbg)i;xe4)oc}GQMRhWn}5~3>!CapWLy782B};@kTP-7KS}% zDvvRB^e6zlEFz|4KR-CdM(X~mitG=kYWo4+Lc4_A8cO{~Df1HAN6Z`ID>KJ`Nd#_G#swbuN+DUAH>_l;-IaKQPdi|M=O zWs8i|o_+r^sN3%3jc7`1Tp02TEvtdlJ|lIFGvuDu>KcjaEz&rH*^?~YV?0Tgf_OYUg;;ci=<1SX6=92`GwLYNX$g~c^*Z2}BG)69+p(Sm1M}LKQCI}TpZ)8$ z^SKRpjv1?2Bna9g64&&Ys~`6|&{5IEGTL>CHQ4uWtio~(3@~4@$j8nv7y=A4<1(*L zWAv5lsO7dXf6+mq)2S4Dm4~pjz)Jl7x2?}pR^C%aQ8d&pW8L`v#*ex-f?jSx-$CV% z3}b4c{?AWat>2xxpC@rkO*LSE zQm(oWCUlQe5am0S-nD`_J5lD8O-wl?#xESidrCF|(+V*niTdCK`rKspBk-ONS(^Uk zt?bQy=_Ohg5hV@mt|BKnP)9-Hk0(btpHlVR=cUO(NLH`3ce6L#>Kp{U3Z8*H4YOo< zSPk;+m@RCJ;Y7DZFmCxli)PI*z_#Pu$X`A7n)UsOw2lgch&xm`up^E9-AY~8RwR4x3WE))W zOb6(vdYQ16Dyr$BK{jtoPbg1V{9YkW;*?)% z*nWpFW6Xv_JR*i*+ZwU2L zkDYRv&{7p9^7(hPz^>mM5i!_#U1&U)H76}S;Rj>U9pd9=+1dYy>dVqMfiiBQ?Cfx0 zv2na&NnTnjOa3KuK9t@Gq;;pFtFQ&vh&6mV9GXs-T3M=+XrWgWsIlHf_gzJbHI}Tp zw5k~B#?R3z`1_OZ*R3C8ya}2EFAIp)? z$7zjmdZt?lCi{4YA}eRa~hQ^WzAYSma8seFqdwML$Y1!_zFqs zglb3{qS7|M&;9)c^?1z8IiJt_{dzs0HE;fnwg$AD8YjeV12Tmn3FyWPF0-ddq)A{M zk-x8>{LpsSvKgL*9lQImUB5c*ht9v|uNRiq;irPps=*juS}LqAKvUXSUf*H=$1zq8 zp_Mg?_xG7}-&1eiLDG2Q7#d^*XO?;>>h%FKRL@s02cm(*vz%bDosz{Vd+`Len*!y} z%o1-W6zrGJ$v_5OXG^;ps;4nxA42Pf@qJ6cE0L|V4N@O66sNQOzQavV9)J0;>NOZ+ zqLo%`zjJ7jjSTvG9RquKKWqCKJw6S9YPcPe^q3`hp2KZ875d1ibN_~>mZ9ZrXnYKX zOB}I0XUV3CMP%ElFp@h{BystPS9TF|)3HL`zAMDbaxz3iJ`pNitmT=$WfGLXS=E6{ zUB2u<>o#=1OW!3ms&Jaat+-~XeC8}aX{YUQ38xL?CV<3`rFt8{g~HHJ8)-;S<{jzH zel+eRY2jP;Co?t%T{lG)B~T$uKX0Z@KD7QDx;_95OwKS91(B&n%Hj#Oa_@19Y!BO$ zR*Fz&S|h69S^3rXfrXXiPgnWnqXsd*R4F$G4dZ$D4U1A&qEXjKV<#4M^)XTSvYGUZ zBA)7)Rts8jZknX<)3czhSgs;tWh7Gab%L|AAU=+jybsN-m+~*B5+~~=o65+*gvgm6 z!No~s7)=$ujg~QmmHVKE3yk$wKocshmRocaps1nz+1UADpd1jsC%YyB&sEPJ#J49v zcBM`DVJp32x$G45A3Y#*Ieg=w9^n>VAw8!O6CGqB55WCY)z{8N_t~^F1lzLuYE>p) z0dl#cMr_@f&h|Xacs3CipvW_C6}a+wip?ybgul5(TcG?iSn3bt@?9C+#{vDf!8^!@ zK2u$&lKQ;aOI8mE`gJxL6F^+cMz->RrO2hvRPix8{dGq7VHx8y?5TT?UY-HxTa7R*X7}8= zjrM)1wX(wVLY6_LiSJP1@4pO#|1w$>h~4`ZLbZ|~YoR7{NIYugr!japmQ{o@ZscKK z+txrWCaky@kl41(Ua`9mG(lz589$10)LK37B)3H+Zd<~dxQ*J;9?x^c78-&p;6!gM zWOF!ORdM{UP}SvY7OJXBI~7B>Zsj(*&65Zkt-XKlt_$|pUuD?M&AV=&G~#5mphF`AuYE^KhEd**!Igr+=#^e>o%-( zznwBu=DTYn)>VX=#+~I?FR-zKikZTu@vyjK*jcwrvW3=#$~nLmF<`5Heiu%b;GHxc zcUQ7-{4)G2sE8<1!>ZVI`aMtf@Jvj=fbu{xdF{ACMWx=oW-F~^Y2TSr)qD2>I&li+ zwu7qvLC&~#3jgH@1_j!Ce$>>4dUB!@*hN}e(9~ciC`!oM2h1xDE<;4~U6FXv1jAs= zK+`DDB>e%4?ipOrN`HZMpt%kskImqN4+DEE?2@|%~K6P@sEA)u6vOZi0niKFW zBnB_$P*Zhl$hogREk#*umVCo?aG9Qyx>Kf#w5xE);)-G~ahe}H zad_OBvNbbUX(6Fy0igP7w1Vk>SP%7v$>aVMD`pj)J`JPVjGXkXJy{_9Gicy9gW0r{ zE%vupPW9A=J5a6`n^q_#Dvsh7qAl4RE(7NPWfs3Gti(Lygq5>m@*d-g?PgWSP_w^C zyN7T*0masGnjWxkTN`RFn2UIP@rgcfOD(~pL!)IEd+N$?03Ws4+_0K2l z_`~=44MH($Ab%a_hQ0z$1$&F$a8|}NAp#X=j1`d6AM?e%6S9) zc^Em@2kShm>d;GHmt;kq3S$d8zqX|B#<`+uCw6jTR`ekx_lxwnS=Ao9#+4b|U?y)- z1s1g@6P}Q4LF??ayH`@pZjUk@@lD;JB<4cB5=F_fIiX_H#;j36yp&tH<)@2|KF~w1 z+_epN2dIll$MN2{E0UvtFnwx?bk?~%0IYrr>_N6YsV9vA+HV=i^zX)<#}V1*Gx2Xksuo|5XTrO1;OfrMy$S!_VyVd&R;^< zkKIc?0T$me1Mj~DvDW?u3}*EX4KG$O!b`F9O(mftPoc^tT$GA1!^hdaC*;13SLB% z)a3Rr1D4JU8=WAvDGnAQC%Ak);zD;$U9JS`dgXUk5zIKOAeyPrkO6OdBOsDhIT53}Da3 zAtaL^SXQq3O_*07vNW7=$wv~`l>qfDOcNGecn(`&S>&{>V9~qMf=Y}be+Xlbahfha zW!--K-K8dzS~@^#c;Z^4MGLMWxl{2S=Bx?yZVS2QOPJ!b(68vJFkU%;R>ZM`=dhD` z062nP^EKUSVc2h5RC-E!0c!O|H~B+V7_&0wS+rE+BHVP z9&3QPO{0AR(v)Zh%{Ns9>E`C3>^bicqr4RH*9D3g_^g+=8N!h3 zaQbME^wwM~Tg;Z9^l{ja!>4I-;i33 z;_pq4fyLtgh+CeLq($%G7gJp8H=w0aF_K&euM3BdB+@HO@pfky^|V3bm@#)4uVxTp zp2mxQeti}%AobnK0oJ^S!Q^w#1(O#1H_u6+@Ss*~;pYEdVBZZj^A|DFg2n=M3YuFt zSuS^l_RUzG2<0CfU5*s*=LGjS#;nD>99J?5X6lg#leA^qs3k7-%g_i0!~fl)!?oZ^ zek)(HdSvjIAZ^C4%$#WQfa!9&z<%?LKo+$kHHyOH$(dYvXHBMTTOGft$XXR%jF!*D_H4#umiM0OSN7o%hNX(P*D)(=7vwsM?WMpsSIt`4NK{fTMQB<{0- ziSOq-oR82^SM}t*{aod2fr3Uf*&NM)q2`|6Rxw-O-5Jdzx>t@R+w!_zUj`mbzejLq z1YkDSsW%VpWNo9zxSS!DbLg=QFIw$ps_?Q_@?7LnJ72{HdwI#Sh4ayhKW83mb5^uj zan&;bFXV)bc|$#lY%%Z3C--}mMnoSGG!(HSz2?q9y?lq zd98rgM>EzR{bks|u9WgLiwzp4b}$5{!$`3=|I1G`kP=JNA4x;Zz+9mkeAr3+OGjI{UXC`)d=3#ot=-qgSyTi}3S6 zc==ov^-@(gN5=BMCaHNr#C?_wos@FdNy-;eo*N0(Vk_L)pLkajMo+p#)E**UwXLL& zzaggWnvQp_SG`(}SfC2{vSM~av$lSbCkv4 zIscPzCraPmk|bG3Ha#L7T%EPSOx>fqK`g3UbVurbNP2V+WNSnOCQ!i@t~w*T~#q;)accnoU!wA0bb`(|qEngLGo-Rm&uo5_vkL&ov~bLD8L zP{FPh$_7S|lnpCbOOK&n60YE^{Y` z*-bB=3ah>^VpViVIgJZpdxbOHe8xcR$5x81w4+LDiLo8|AzhlU>LC+6R_z|~t|^Tm zLTZ;;ONPEkrva_kLObc%d1T3WdGsTFCV?);@`bW&RQ%uvTd_eGN6Y!zkLHxN$(-I{ zkcu%6UpP1xl`m+`DZgd)G4W4)t1HI`J3mvhmGp(Xv+ewTo@{e0n`MyP@D~y>%MAW{ zZa`2pinJuv3*yE9a^g#S&6OvNe6D1$!$0{z^?-zgF$%$p=%#&^+XBkC4GfY0D|)Z% zI!excDB-$ExnrfJFEdbo(cPoV@mG6&vV;ySuYl#t2S$gSQSCg4Y7*!kAwD?nW@7;y z=cKi{?$2PNHb;*!MIV+?KLf~*h6%s1FHOJuBJB?T@FKF*aBuW9bSZ0t%(>fKy+Lnx zY%8#gbJ6GqJzDZpZ=5#ie`j;+tt3aEaFCvlGT2Ma?7je(Cqhe0{}p(2Nq!Y@)AljF zb(eNUkU5kkbt8`2=0s{3P5-i+{?u8EX8f>eT*j}Z2u2mJi}DE z+eDO#yxydP>zBYS;(kO_j>I0i&$oNW-V8Xr#VGaFjvA9pWarPL--&g*;MLS+0}Iyv zAW4@+N!X4jP^`{_)4Ud{B97wrqVGfcumDtk(Q#mxJ@xzA)zm%Z1l{@_^PaX^k)<|S zH)bO@3sr7)SC%;?os+a1YW=EONgvdH5mVf)a|X{(TSZq-Np-GuN$|G2MjyKwRqcf! z@t$TPziN~A(2x>rp$jA+K&;cD#a2+tZbI>Jbq$UO3fsA7muVFod8 zR9`P+%5m6PFY;QyvHH25bxi*YZ@+x|wgu`c#Jmn5OJ9y?+nnidt^3F|GK}Ra>9&`3F0=ArF~rTkaZDK^y7;IU+}L-2n`Uh|Jn|2nV}6bE5e(;@!5Ap<4t zLIwUHUk$Ql_1)jj4v`NW)Qg3c4!jDo-B#xWQ}5(6b;jvL`X1a}CruB>d;g3l(rfV= z<5Re&_9WR`oQSzU8IR>vN!Ybk@J%rXi5Ntl^?;&}1Cf^`aZi#SO~RrAvP`^P)Gt}$ z6UGN4cluyAG*G8A`TFnMNYw6ASm#0Ctj>&M_)rucmm@iX(!W{f=*h6wM$GdTm>r&9u$GCx6NPa^^s$!OJ$ znZTuoER9EP65y6w&v?l@^lXbPdYd1;B<(3#K7StJ9wm+b4e8v^z{+O=y=6UqeE7?o zf9Veie`0yZCB1iv?tRhT3Cl%rk$xMqxp%~_LN|kx*2tF&e)%dwkK2pJ{dCmGIWfy8 zLva{kXr$R{uJj-H*U}O5Ey={KKU&uuU)X5{@~MIor&mTUI>HnzL64Sz&H~dSmaqtw zk1*w{puG1Ro!#elrs`*^M>*9 zsj-yx@HBI58X{?^dj>md4&lB+8a+|Z2nTt=j%&+^_4~;nGs(2{D)O}0i!L)_>kb2A zNuYN3{0UT|6XAKB%wftuGc|>#%9kG6Glx%+X~8^Fa01H#5M^zVb2u<{g=3Y z@6BDyt3Ey)&L%wK`Jx3cS2f;95~5nnjdDl@h-`ocAgj$}R}B2_@N6D@WcH2A#`68f z(5J(M_|_Laty_5&{WcZR_7zi?&0lOD{N=HsoxvfrM8}E^9^|AA+64KW$~ylLbN&Qk zg1q2ZR;Xov7^+pA?jfI72GD!HOj5@T)BjS{rwH@!eKs1P5eE_+fi13T`qeI8rKL4`iJ&Y(?m4*iQf3#Mt3Wq92KMu8egB@3*r*`Hv zYQ-{OuL+_?Q(KRbNd{JUS71rl2&4I4J*TRtZDP%Dve7WqBTkZD-Hw|Z1*xl``~tkr z0WLmaaN?$(`Sd#BS36*v_9{##T0_l9Bx)7J0efn9d#0=rKkqh*zP^$H9r;#7vKp5C zr{_@9uvb$D%V7?y$)?|-!crfkzR76AU#$k)&4U0@&ed%fA!`rFV&yr1`0F7wCN`D z*DmT5s8z{v>%>y@BlZ=Qe9=ARL_#}y8E-SCWoc-0uih~2tdnbq>c+yIP|gRG)}rz` zQAQP;_uE!bCNV#Ku$iWgprh|GBnZAY^8S-;j{9podM6rmrkNaoJ?+ex1&xoPNpcsa zmT-yeTntrAkeW4q+sUw7`!&?k+WB+_00xeUq?b zz#FO$Ek4RSk;g2b4*t3Ou-$DYKQ&~>Xck`Yif(XF+FG2PU^3X#1TJ*4XVlfIbus^k0ag8HQg$% zW`wJB4pt-Vzctv4PP$w~<}pE(e+u^X5t|=`bXnz`B6sz%MPC?h_oclmLa_q!Y(%>Q zS^v{Z*8D&%|EyxRd}LHrz-FxXq$){LU3`5_>g3?+%seTu8Zp&dGrqkaPust$$6heA zc-PL1UTDX*MmWLxzeeH!MX+p!9|ascu_Cy567@n)#}{;OATiM=qM8Y>9CX5N57 z>wDL*1e>$IVxwsDA%3Nuf#xlA7!Sm1W)k!6v+YJr;V4EH>CgcZEH;X4e_KTz_$mjW zx93>-?PUiq{v4pN5-u_TsdF>p;%}Kqv_|FC1wXr5y?sy+eCGjdXT$O|`@mie=*?cH z+KO2$3SN*(2He5x-m>#uhna$6gzaHffqfIK%g8|9IoCn)yx#Y1+?=@n9v>`x7%kra zfS2s4y0Lx-`amdmx0H*H@I~!#>;i6+0pr4b>9iAcj)meVTsEVg2NGO1GQxd1ZVfUR zi$#hBO<^+B&~MLoQ&BVb>u<2HS=k!H6aDN{5yCIev+AM;cpi%7pL)Xvc1Nscjkl(s z$Ykvt@l;cwrcCcMOtbqG!CJCm2`j~542wGBNqr-U?2CjU2fTiP<+W-dTrqIaScH6c zY`n-w>}aJ6wd6$`Y@vl7%QkcOX<3_OJ-H}!Gg1LGrDFAK@sf@)lH4pDY#150<+7{*kr9Pzy8B zmpUQfxbjO!kv_9!XtYZnV%cM3(*;K?{(wfyh`**#&0*Ry8CAPznAAXqsZ@}T9r7$T3 zB6i%7=C(rVe-pN|aCQiotCanL^c=Bdr}Q%%a~Sbe2J2$2{ zfEYc-2jiQmgy((2)Igf#E_oZbO_XgVVTQ_=Tg!v|v^pPZMIiN+`JV@Qe2`PXHSG0i z=$1QK9NL3bKh52D$``xwcn>-&cmQv2{pb2?Ylqf5cL^x|HPqCV`3dpSqcuhRG+~yR z!nVy@_E^~T4PJL{6iL|C%S~Hut$p<(m8@NrwW5kv)k*l%=hMSp1D84Urxc>_E5UN} z)tQW0?I6?JiM{~ncHw?_yMalNx`uV(@Bp58(@6o34O2*69+eZ}CILDgN{yLEdI9By<|o`uOWgDf7r)_C1oB&B|6BffNufpqntjBDSl~?MrxPt+gy(wV z`s_w*p*R!!^v%U5RI-pw^hzZGi$9IP~aQWX;QBjD>h7SI{j>Cj^=iSwmQi9Jlm z@~HXyH%O{ltK0r zNBCBugsuKI8nI%>x9_$!T#&S4>UQ_!k#8YzpLCJt2ZYE**~OpPx3g?2wcskiU@8;+ zw2E<&E`tH;scB5RUnZzS^XlaD+#-R|D$r!!ZV>Fd%d+ADOL{KzXI60si;5Qr_TgdiUCRK zr>m;ECiYh;bC!jA#d4Paa|ydS7=HIu+5MTH6GW~LvGht<(|CQ2BkH8hxr*jzKTU~#decLpY%vnUk~0pl~5@pA;#4D-Fl4MZiV-P-2Y#BSIE5r8#kcg zLB1~54+!3wxUk~SP4EVOw|k2djV#*Nh&FY&)%@GFgQ!$x~TtT-@ahkxG@naKg_xjz6AgKTPhtq7F6);D-P!4)^@Js zn@kzbKT*o=o;AYWn@*XZr+x3?)2@T)jnfjWYy2^+4HbVg(nNAJQIPTP#c~VkxLzkU3@o&B>Vou*UPL$c;R??IR|h+ z(MlOhIo(%&fTz{*Wu+yspQGS&E$+)KyZImgf2!?&#@iX&`g=k^W3@ahXG%N%@cnnB z^ABlfkPe>ZE(uvk&G7H6i)UQ67!(GZ76X>Y1Ezepg>rg#n5>q0B1q3quE@%oUQNT!hbXA!t2JDqH0pmYRceazr-blL7$EyoE$>oDby-R$t zSS>NdgBbY`;ZO~G?cV+fvMJH?;=Pf{t+g-VH22e!)d5gZ05g1nVk36hbM=~vZ9n~M z*z|#004Tw7R3GL3XQp1+*osw;q0WRws@{J%>CL-|hkQF)U*em=68zPR*Auek(3IrF zkG1%=-C#(RfRwfIo|qCf;Br}WpNMOaWCya$Jx(RM zs-#=j0=T_ank15}Nf|~2-$LPce`NmrK7|%%&*E8nx5^rC_CN|xC`{$AupRHL6Tp!P z>=s|7a??nFvpm<(Hm$-W&CX1*s>gd^6;Pv(CDMDg;Yn*o(YSHf$m?c}_(HERJa5JL zbLQ5PL1|u%WX%Dr;}$^hT%U{=C|QDYh$;MNDe=!}7?}at7_5T-M{HtCz+n4r!5i%C zap0_O&iX!CJ%&^Hh1Z}R7K)!6HC`WuljrSV39d{=ZoMWx!IU)@a36%qTTZ5m`)zMG z(WieS{ymL3PrO8anoeoPl;INvRotmeQTJbeU4GzX*!*k*Qt^F=r|uL!(O<#3q(6RW ztQTSKx9%Xe{X_=H<)ael*v^vb?e`R;!=AL${jDtO9|7^V4*>2sMK(d6fGa2HRn6Qb zVT#JKSWBmm_j2VH*>A6h#1jR;GQx{@W+Y?_?Gl)tml^XfsJtUl2i_0I#z{#24ea&Q zNto9nM9_l%n?wnWr~;sI9~Ry=H`D0&G2t15y$)&n%yptf8T*T`?j1rQVaqqbKt-o} zN?z*?Q~Y=zrd<~=>p5ntNidLy%42sMR5-9S+Ks)h%6Wq)DtW};fm^YM13Q^tkp+w? z7-l~u@~6TS<8(-woO}O^`(0~UMN-sImkWP+H1}l1T?DB&Gi#vsn4h zc;HiRp8&Ww1s6JyuLNAUJQ~jf^ld+B?$~dTa2fjY4KZVom>5MZ`pZZ$ov!KfCdC6@ zHAyn(PIn(Ymy_j{_5r*(Z@aj&HgJQ@zzP}7c_xx!g|PUzeo0rjH+&tW4fYw z0D-fZFhn&}{ryFjF=Gso+@JWSdBh$wQ3F3#!iXKIW7+J11ggxTz9X>GNT6-FTTjkd zeu@0YKa{2>lo2dXt%>Qu)ka30YoPU05c@gzIh89NMGv{+6_yzaLD^daah*Y<4P!Av z552Sp|q>FYvGTS^PH4Vl6Pk?1vvZVVibKUc>1x0B$=j0KfSdw^)aLB{~=rE*!0Y z=hMuptGzv>`vdmN;5R*Vb8&u1oId~5sod$|f5@$-HABppzb)MRNIsEix5T zBP`@s$qS4##FOQGd%3a6qX=T;$yB0yF)<^PFl~|CG(w_BhtZ`JY?rl$;m?wEPEunQ zMo8%f$weyg*f#6iP;QMLwe-eqW)e?fH@iD%^sTIpPRXpwIY-U3mX|H4! zF&WJTC7Sx%>}PYcqCSm+bWCx#sm?#xfJJ@UuE%Tc0&b43 zZL`&V{SNzQQmPMF9FoycUx{R^Llxue6@a>jDtGN>#~jbP{Dj3{lgY0026%N7s%VTN z7I5o-w{uoY7DO#z-_S|>X9TZ=itWd^Ppnf6{@4bB`?sq9o`RaXXdg_D%31%m4}P)B z5S4$Pvn-BZwKxiZysrf7nwC?{0K%5{3uD{h7VUUXDP(`#P&`Rck!t0);=5^@+E6|t zAV4vFu5}sP@8Q4jC58y=S}%DK?}+i;sO?4u#7GwDxqmGA$&T_T9LWks_v23HdEW`L zL}Bb&;W{(bmKDQrMk?2gQx;CQ_Fe?%H$Z}ihrq!)@eIW#;PM1x)T znrnP`8Bv}tY3*U!hACA3pTt6;H6C4k$Nms{7+ z%#@&yNJ=kiAJqq*6qz9952Oh89{RbkB}WxbEM&Y}bC(%^i6x$6p$uhf8*b&22O2NF z2J?d(tG`39m*6*CRc^`D8=(im#7JfVG1E|PiG;aU;j@fX=eg2{-?D5#C3_bgF4R6) zM2(foesN;W9^PkywQWqOp3%}JwA;|e2tS#%{j*b;s%|xaxt!QYuP{0URN?()c;4h? zVZWf}Bg5uOKCHO;B0_yf!fy*Bzq2%6bL`T7Op?b82Pjrqfh|{nX@EKynnFqf__tT9 z{We2K?k}@0LF)(E{L(I{6#IpZGF#4mV~7UF2%hT6!iBt{EvHsN#ZO9w$yPu|)<`-7 z=QQ7z{>ze_Y^8C|G7z2UW5yJy1XBh%c7F_VntvBGwIj__>!EpWBsVV<6fQrEqMmC< zA40Lcn|^lK=WxmHgAw>^`JIf>0$AC2DC<%%>e{^%{kjTnDf-Ka8y|t%jYsTH@@-m{ zGdd;#p64{;?}?;(Cmh_jbaBFgHe-c$)LmhJ(nQfOkRM+A;k-R>OSpiim%4zFvxRhR zkq{K+9lLqKs*kn`+cENQ!(lXMqM~DWo3;G3zq(+ES#=0fejl%uxKT~!)aj)}uVW*A zR^5s_A0~b}iDNJDh>?+N8pa6*gv2g8hcR-YJMkKyE*bj!irq{R+{S74#M@QismC`&P zNq?`NapTxB#1br$qjHG0H9KWv#&DaTjDzAY!8Qlc;vz<@`LJV*F`iQ(lExu;ITg{` z3g1i|MZG4sAro%2@`!(fzzqw_X}cS}9eJs~2Gw6=U0BKV@_}16GHv#JfcqToa*gp2 zBkJ?oj!eCiY7#l8%f-i34~6rgty{pGX*HIbiB5RD@6@|VSk!V=K?Z2UbQv^77>d8_ zHm~?>tJ!C&obIZP3ZTxo_)~ip%czYCG`Ani;{mm}`w&w+*E)uyfZg4we}af00LBwJ;5(9r@f#pgVzG;+b6X~{?)4GX{^4dTu zlbDOA;avFdDTl2au=HqY?ml&vumW~ygFPI{$A(cgo!5BQ*_W3>r8s82b> z0$U?~Wuj1-5+-jm(rzigN#+RUCrhd>O;)IL&8=?sSV?YqgMB9lHgyTpP2JN^I-kpg zeFMr8^_DSfN70;iN8&%(dl(fz_7RVIwnC3*zloD&X9&~gyu0x8t+j;tbuK-%zK6_K z9rbQSQ^$*$!O^ywQd>;~(4oU+W6;X|z)AD;UuO^-QwnUN7BL+v&%$>3NcsK|X7Va5 zJfG4111eryCy0N_tYld<3}wLakAA@wrc$UPE$8GyNc8vpM+#wDk(V}^svnqXNsfp$cEN;<;-kMP6uV3UAP69hv{`3-2Me zX)|F?PN-}mKkNttA)iZtrS@?Q$L`(`KlUjr{wgol7PYbe#czsbep#Q@H=JeT7EB^i zLE|AaBqjYlqwkT#vU?awxIVqpp%sbmgA~y$xz=7OcF`UIoJOQL7h1O$^IAX1YF^D~`V)d&q^Mr5-vwd zDmh|ff%2c1nKb1qhbNXD?H8m;p1H_e5KW7z-=AZ-!Jej?%?5t;kGXcE>?z68t?j<5 z3APy1vn*i9xe-2D;b{;=ou&2;-4l}U69`%R^>77u}{+K z%OIE&C3!eA4=MdofyW)uqjN`d$&#M6G)EgmFL9=38kX4l5`!#gg zxBztk=fvlgko`XXm%{7l2TNuAWM?XbxV2c~vODX$)vD-VA}n-1hN4^>{%Mc-&tB=`W3kJfL-e$lNUsw*s?hJTt-Ur=4hNGA|ie*xeS; zM>gpiCMdMSExF5h#QF=wrceprf?Dvt-!XJe%$*IEHUDsf*m_vb_wY?rnLV!2ethcJLd_HPU^z*8PtN8Zga?$H#4zt$6vKjWhSg# z;i?VhQfGn%)cZ}cF~3aGZaj9U@fjzY40*(6{}p70va4@BYcpMJ>_OhM^xOPQcqv)0 zx*36%rrfDUPu6}vnui-SJ{p9d?jxqP?8+V|$#p;?ig)mDXIU$UzIxM(41(0x;n=r7 zxD~74qdr$a!}gQP=G7T;sWn&u#t;*^x@Y+$fL$wWxETw*6c>ySM+M@}`3K486BaCR z&>3V_tr(^~&l3f%&OaD4C_xA;>zrYiHo6g}wbwkf%LwGyrri)!2}@2bI}B@T;D(C~`;))WW0W$V8!?7sK3@c*=59{DU)JPLsI{loiY}$dn;4SM}{u#TNHq)7&Gzwt#PW z!P$#RB*_M}1;&-L1BUUF28&?7FoVj10j}a9=BJx8*I1Ui(5i9JoH^4_C}%_RM~0e* zmdYO%ii$W^4CVtJeanSxQQ}?^TE)y!!5TIDV}gLzKFFjwhVm5fpyO(3+sNfVKYwE9 zM3CA0Gr^3nnY{HZ6BV|>{4uHrbM#2(oXnlf1V=Ycu#-U}s%mcRV~X71_$r3SUZ5i8 zM`mn-pE2{}6^MHP^(uraU{gz4Qt?73?UV2XSq7eSLE5V%f`BP{1<^J+g`V<&nEn%0 zF7*JW64?bk*JIb+nm%&#nR&!>XBn~vE|}_rlr4#YyWL+h{4=9cm`2I?P$46ibH>G=)%yQoh7Y8icD9knx_iru@9JUJkF5lB>b z>`f-p-yF9Z#jZ#bS$zZe*2&Pr@p|~h1lMKQtjG-T$ z;J>vRu4)EY=m_5-Iv|!`^0IiN6hqHldbEtAoKhar89jrL0Kl_;F6m(7CW*0RO^l z$t+FQt0b(zbu~+@wN;;4g_NAFXZ%39I*b=tuM;Zr5pCae%FmIlzRRm@F#-CAszW)j zrrg}GnP*c77>NLRq8|~)Z$&=;HOjoQ8Y;;XG@woI`hZ;8ev!QQ+Z-S4s}Wp&3)&nj zdEJK143^ydH3D7Muv+#%V#MPHPmxOpZ_`~Nh#zn> z41ON|+Y)9)*)JFLq!Al+R7-mWX}3r7EF-Y4+n3Rs(GKha*N{XJv*^ez1G_;B_SZ|` zup|93@M)9ICsaFXxk1)`32qKuw>}AuS3W`C<-_YDA0w}qPK0uAWnHaiLLnNvGN~#Ev>fR!ILxqc6uTMjiRf_^3%k$4#})1 zs_^6yVeq4I`dR($a@X1uw9TXLFoS^|lo<_e-D z(Dl1CE{$ZTL8fAP;twHJ{Dla~BeR1M(xMzvKL>CrXt87;W(me)Z}EcT0NoLd<@_&D z`c{kejj*}{*zbl$9hHoU>huTv&wnH6DRYexufj>7{HR+dTh14k95zTpTBB*TlXlCb z{U7dbiU(c|K4u=Eo?##!W2ii4Bp2x%)ur`@9`_~HkyHUnsjXelNN4qqvYMDD90ytP zivaBMPp;p-dyq{S^F%FkFRPZhP2O;r4!t!g!3W`a9Gz2P8_Oc})-bCvGvGmFpSyUto`I z+1Nr$(m0kC*=1pM7>v;o4>IIAah4l&bAF)~@J zNu%dEDFPTi0uVPCR^52|2W)u{7|*wng<%RofoTk9QdZO|)O3ngVg?e!v&N}RLY)=2 z#-}-$iXIAVilOzXZAe0)f!LIGQQQ`4B2AS00_EYOsDkm)TiySIdu-@9Uh`uGQU#h_ zVO00VR;+(I2Z^>)37#!rUyfm)y2gzE_(RaR5N(+{vGfvXU@Z|U&wcZz?@lxPP7K|h zVJ*pB9}{Qo%YmLvp4@Ch|t>>awvRPg;(SlXjt65mT2bw;eSecgzv#JNXbS*h5fUIERA z@$=Uh__RWTWh*!SFiR%Y8;CYOM3Sw1a6tP!yYAvaqElVe6xiM+X3 z{$y%wY-9v-IJEKZn!ohSWwY;b?O;~`fiX%vabL3{q2dSHUT zVZc(n_q)}xHPY&>QS>=a`Ez&IJ6NS5C)4d^;(fo%N0 zoG-F!ID7=(@=E%H%s^?uO0#tY=`g}3G8lUzp)` zVAvSL_B25~?=#Aym$U1p>_q)%FTpl_Z6^QOd?a(fEh5c3C@nV7{h35=v}thH3&a_$ zm|L05^HOTIr`+C9+Xo;{K-1-zc8+0{N&Fv0XC4>R`p5CJ%u>zPzHfvgZ7NOs3^!Sm zizF>mRAbA~V30azMrAEqmTt>&`O!rg43d^Z!nNesla`aMK{6zjw%>FAt=Fr6nt9H1 zzTeO1{eCt_>~w{&(<8o|3c~{(Gf~&p%bo7fnNG*lKc$}#3nBVyiyF3RufvnSu_g70 zyt&L+CldObZDD27wx(LhKa9@YLdDrz?VVuAB4y48;O=L(x_D0xdR*i%OgES2QGb*Ky% z1X%Mck8tG=rvReb!gGWMt>SbzXlFP|8XhrY?s09!G<3vk|H-d-Y9##3L+g04lw|%O zI=0d0x&06Ik|+BA2gbD5WLsuD_gABLIkv;-FAzZBrBVA16GK3n`!CY`7gBZchl4tV zQND3NzpZM>K`~&gE3%OkvfTbmVSW9G=AhC(^Zw?~r?hI8JN@sp&`hlH&lMmMQkcwe zkCm{BP1&{;1Nw8{cZtH+W8b8s=;Re)cuh8lP|f`gSGE`1DQ2>y=h$T%^;cP`KK3va zcq$9(+yR=mnCJ|JU;SAPH`Zgu`z&RplPh2Gy2h)bx|A`0%q7dWohK1X#TOx}{qv9m zS##n%2~3->+&5r3E_lrhYT{yIOUi$^=a~Y{*#R4!-V*AnzByH7;VD~+`Lz$Te!Z=O z`o^guhL*!oJ7}9Xmg4X(BsUa4cSfA;VB#rfVtwc8Q2Sk+s=v)NR|Jc$XR+gX4;ztQHr zo=yR~9;J;g5Vw(-D_g&X$Xs6}P&khqK1-Wj9JP9nUAuxu6mJDHQ^fiabT!u!E4E`% zu^!sDY)a>&z2p!%pCk9}*-TNE(k2H>XX1%|iv0wZ?qbDxggo+=t@~#O@imGt;zy>S z7sVD#{Ar5^J!#QYU9u4fN7ug~SVme!DrHu%hRiY6R>o61-;ItEHqWs^Ssj+PmE9;u zIiX|dfA$jgX4;v{G9~MjOrPojj?bTr>J-b$l7T5zlrNvwVP- ze1JXfZ($dmNrDSG&24u_1e)Q4?8+&$4GIFT1{=W%OMQs!B3H+S_2autqi^nkuU!Ls zsMjBmhygw5RhA60SfP*PUJ$+dv})2M?|VpRrFfZfGVV0zpfQ+6`~{2O>=oh*EsMx6 zd1AL!)HM4E6R4joS5)h1=`OkR{-ZJ5{)IuypGf!Rv2YD>-qSF?sF7^ZT&W zSsAGc?s*^4LWfX1o8jQO9e2kOJLYHUx|<}UMzRZ)r}(R1uvb0D8_Ver=4`%XJ1gE~ z=m0EFgHg}W5d<7@V%Ohz`u_9h37fmGNwdK~`rqZC^e6?CXpsv=g`hGcV=!Zu>UeTT zGgq}Nk;(rw%4|$lUd5D?Y@;Oaj@d=qV^^1a2bqRaEd8D1!ce5sP0ac8HRe3L9_?{d zj1QF+?lSTDuKzxZ(RKq4S#NUeSAx>~5$x*WCGoIqIRNENxrFhzAxGR=$gsFk?Bp)u zpX^al-w^B`fVwYU0omQTjjWL>^SC4E`A1EnTsiETMA^$I+&4j-$NB|}u5G-8N9Zv> zjyjP4gi;ZE>&R+u)wOpV8Q)ZXgyHR3I@Ay9CW2K5kZsa6r2nt^r=-!4< zoO4863|{+nUeaPi=@(zc3R9uB&!#echfT(9H}xfEUIacViTVlh6AN0&ceww}FFBYA zmy92KZ(l+?dSOhGstZv5KL$rgj`tWTlI%leE`?^oR)fOK4wN6P%5zR(eC|Z^O7Iz= z$aew@*hd_&p)S^C;i-NZP}(4~^~Eh-SL`rz>XB&i(R4U)3XyK!7*}}@iqU%{kYApl zJ~)aNMxayMz=~z|CFFsbk$yaj+O&8Kt!E+KbIx8iZf;D>5i$4q0VK`K46c~IA90_% zf(bINE-o&?nQ+Nc)ZpDZveF!m$j2)RQrTC`@f+haN1+Pvj2brzg$Iqtoc~dt9^8Sa zcM%&UKgb2h1X^m~C+lQu|Mt(M8;>TCTX$MizSDnBwqHv2t2d!{qGh%K1=k9o6785gJDHtdjeD#>U;ZG@6&^oU=Z%?9Ra%cB8j1;3 zsVJ2IRi3Xm$n=>d=w=-xC`yImZZTv25d_@KH{#1Aj)F$CbJJNm#*0whft!TV9FULY z-#nePljcdjS!sM>c`x0D=H3iWT5e~?T2C8(^`kSE>7EAsRXUPua~%T-Myvh$nyawz z@B{9epbVycpMIfw0E)c_$Gp}rv|;l4RNrdYd8XJ{zUCN9zLFQJgIHp^?O7;!i*wj2 z1X}i!xO~|Gx;A7Nv?)hyC`{0gk;2xK&|VkOGL@(%K5~rv1Sb&Smaqa=7qOdqIw1b= z6ugni&S3`XcGP8&9l{y1e14M@D$ii@4{X5QZDD?&7h=(?gL5-P3&#<@(7F=z8V^}A zbI{1{wqN90i@WuN zl07%X^~WEVh9m-5Ne3%_4M5sXO@vFpr?PROuC;lHj5Bb+dawjh`g3wFuWCw8#)Km>aa)q%u6mF1mk|VV`-M8>{KHk!O3!{^zUB z)Tf&9&7|uF@jk~CdJ(tGj~lboAOPw2P`_aZJjQ|BLYX(ioLRA9STDAf6T@W$sF|8D zL(T7zU|FcARLehXbqwG19S|spu+Y$vOo<^hH9lG>dhvQ)&N{N@a|@YW_!xIxaUCm9 z^_PV4o11@HR1!SX_ICVJzqe74daBXi$Hq7O?x_E z2Cet6fc{(kjYQ0S+%B&hUBIFqZ3!U#7kSaU6ps@^Q1^0L0>%C4`Sf5Jed0h17c9<+ zwtJ!U+oTjp_5dpX>EW56%y}6h2!quVScXn_QI^&i7)@#g75R$B&i-nrv{46#_AlGvnb}YcAS0mB3|)? zRiQU3sGVU|83Xo|raoWwWA1*3qeJkwwi?J%eg=`Q9$O}3*`4E9_x1~HKfGf`bbdzx zy?mu9HGU@1Gid}mL)!;cHK<4Fm8>z6Dr9Z&h@R~W@I4a`j0Va^0|V85u4CLtM|R6o zP7HMyjrGxMPSX$A`z2JT9v?9yghfROsVcn)`ksq+6}ab}wN#4%(|nX2G?Z(nVd+~w zCLUZ0fdiM!B^&bqqRy(a0+nlD33RU=$pY^+q}wx5?>Fp*ELxm;1?sUcJ1S_-;RRge zYyRTM?-*Nzx_VYHtVEp4;yp2?u*EoK#XL6O9?nlOhnZ;oFqo@9Anzy*)n`WR6$ouX zk7P`sm5GtRS*^F(&65UAnp_aK-S42N<{a~&!OMAvRhVgK400_DH20cNOT5A{%%d~ibj9QykBDP;Dx zY2-iC!L}gwi^>=MB(UJ$Jvulv&@QL=^Ayv&2!@`7dk0^)~zVJ~UyLKE}!M(XWcO7Cu#WV*TB z`@PA364xqJb7-DJWoE8b^uGqs<_AN}kJrGhdKT`(R!{%opy@SKEE^*=ur$pg?ihoa z>Sx0mU^cY2QZ%*BkvRVhl;I~_WGnQ1g5dz)1DvKY=B6DfkcSkFxZ;I%4&ydo@qI4T zPGgQVfD?Tn3(1q?Pwytsw;pDZCmwi^M#m&Ump^BS^-R(TGw?KbMIX&*}Lzoj!! zh;Bc-n{P$d|0Z8tCP+qcb+3akzZbOiywq2a=HGC@Ssg61ApnAJ#=NisSR0Ki7OCjnj zP|aW-!#IC6Vbe3u&n4S@WkRKe@cs`b@THyGDo&MoLl$qrMa~yVa6t~U%O{NJRd@G? zdK#%tPpTaqVV8V`icjzZW_@#z&3TzBIcF(%a?~E1JA<}0F0(+Z9QEXe`9j%;1%Nr zq7>R-#SDp)N?$nbmR`_2u1_j!gP!!n7-?&_3GI(wGDgTblWUQ_C&>Jx=n<_g!Lm|g zsNF7u=KHs~wgzxsCccduL|%XGLAcHUqOw2mXA}35KDU8M=i zNAsyq3GLXnOX4%%w+}D_ju|Mo;K|zB{VbI@G!=Kwhg|h2U7&+n)Xyz)N9>+GU<5gs z$#?R!I;R^WlJnH65hc>wL1kTix{xr}WwAaLeuR@9bzpd=r4e z-h|vv{f2ET>e4&mdMDcKauS(SP_>(dN>`7Oj-M)RhBfPKjq;3~K{h`^TTu*IgdsTwnN`IEy=ZhxiRC+G9JaG-jz& z1#6~z4zZ?ojUd5;c8cFl4xV|nuxr8$3H;~|`3Q<3*;VVmIe6M-GN;P=v&Egeu#|E< z+0Aorttt; zlDNfM5%upzIx%jDw6mn=lw*l2)|_Xy9CCZ8Ln_C{hb_$$+f_dO%fYgiSe-0>m8gp9 z&SD%{LhvDHb&b(pq!OL^0xq-fL~gPa>qZt(E8ly9_s& z^kxgjbEjU9Zy_6766jVhqIe8(W6215W@08#A1IMm-caCf!o)WLnIFb1zI_*&oVD0A z8C!j<7BmEgk*~)R(M>ZOi?2g%W1zF+!bI!<*v9N2=~TW{%yX4w4k1OItbLZFNJ*wa z)!@58PdjfoJi8Wh6;VrVh=xl<_Sb1iB+FgBkQuNHk)NHUwcWedI=x5K=i#>ru~^sLX{yzy&ugk@?aiA9FTW{s@&m!pF&$aBS4y z`@euJJQ}#ymTt8mv$f<#>rmYJp|Wuyyp}nH+Il4;Y31)3ag&){SL)cOYuMLHy|C_s zke$|P>_nukihH(5+|g?heG}chRMj)GnqK4*C^ImUr#AGYKE^mBn8|vQ@2^dAr2bVA z%qHSf0yV34^mx{^mw%|0pZOE$1HG}_b=VEZ5oNbOa>rMCe>X3>5APPhzEj2QS6+A7 zOrIe}+H%yb0(Pi|iteT|TTiiVm7Q-Pw^c}(C1`q`4vwrah0>g$uZB=@Ejz|*fYa22 zRvA<-XKUKbEl-hyodejp(+PDW+{uBKRvHZ`uhbtWYCaL!p#<}f{}6bAvi?u5G9lOJ z=ZHxqW+1n7E9>lYu#6-(F||t2;avomZH8k`-GSl(d>QCMm@!RbIJT2A(dv+1eeEV+ z$w&6OXM;32mSfOTXy1ED19@O7??-tf=oOm zATnq~pmw5Hv6*N^(I^}Xj4!qaS$4m4OkwpMWKFUGW}XUt5cvU%dt?4(?CM6ScLc8Z z%#PcM#Iz3b6w?i*6(;gIj?(XWES>3ujbZBn!>l%W3q97_KWrjvyImXzGUCL$Byl4A z*-ANSI`zSZxZ!)sbcLlTJu8;{I-BUZnx%?xMpC**iPdw(Z%pxBe;ElEF;{W1?%Sih zs!xJSMK-(gu9^H#a~o*^PYvo4GvNSYhfR|)vo%u>^pWd3Lh*WF;1Wph>B+Y|K4-?q(~|7iW=$0DoI*mmz%+3Q%Y!Vf2&3 ze~apH>i|bT)f8Cj+ZRsU5Cw8VplzQn;I1phZ>HZoGX#fwifT+Kt6xOmL-F)dNANK@ zKLU5X*tL6(7d9nSd-eKb60y=?2lT;EQ`?e3nK4R+dW{tELjus#0h5I2F>mrlrVO## z#t!`Y;G7efkL?-3oIm_KX{MKS1%cm-bs!_{OZ+kOMIMuUX=i}XKxc=wO1t0ND1*h@|bX8#pS=Jbcso|DUt zGA024POT@(Ih{c2Qs9X7xciGl*3)Vd0LQl6sv|q-(K_*o$9l)-Gf$79#{NMWfNt0I zWXTQiK|g3GbupIv_(_|!zOobJv;j-!*?|asA=BEQu`dKmL*6rhot_c(a2zwJM^npe{$B!BdLG4k$23c zXH2E|I0xD8_iWu{IMSZ-d!9l;jZ62;oP}OEVV1go$^I48%NNYFp7-o1f?QpWpA6_C zn9D`!BEPlDmr44wcEKLE2JS#rt1RUQCzyD)9LLxiyip3ZfmhWi6dN{TQElrZ zUo#5}X*5qh0#CJ8VEZPqB*}da!b$oY{6f{SQ1Q7RXwwrou3E3kitiKf+eEm6yZhS> z@{UU&7(b_-1sTeGeBV$$>FrVr2P!X-{1?*bzdRVh zPw&N+JrSSGBsMw$3H1R2$aA3iwcB|u-yPu~hd<`T*+rWVvm^ZPd6hxyJ}~Td@n*jw z>Nklt8k8kAps^PKcHubl(Uc&xVj1*nj3r1jsTwQ$IkD^>2hE6nbfPyJo*0tJj620xdf|yiR5^{-ScL~*CO<#Kd};y zoNg`s) z9%;<~0q2&B!$r!RdNJpoC^(u$W&UZOk|Q9d&&4|!V=}0 z>o)XwVZW}AAcfm|UIyn}BTpDoBieS7nd%Xr!EopP=Eg4I1g!wdE3_A@MLGVFuwb$h zQzc|s*23OGm)LRGuKf;RjwmR~HAa4262EFy8U#=+JgLG#9%I6;EMNt-nD}s!F5W2X zqkUuuT%65|apT6E>a(%jS&A{)WoE3Hdt>jp=>`4zVJCfUih8RdXziGHjFNI-@{;p_ zBaPn)7iZpM*cz*Bx%Ww^c|Q2XCHQQHI9uO=vd^TqwEj0RnUp{&L#QjIglp~=?3_fr zvDblC?oA*;0jVLISXKbsF3!w~P^kPIG|vI6_{!u3t1h%LuKX>&=Af*IXZ<=Na&j!i z)3XQzD|s}e6*h;G3s86JlO<{IQ)c#%d3HyoknDWwg=`C{CdYsiI-cPw<7)-pQqf_i zBHPUw^^i4Z>o3BQ8w=Kj)}{9AuW8!OG*2T`!Tnge<`&o~NIndIbI?u|(q^~G1!Hu* zCB$VCw})F_jG~H#?>E!cpT1=gAClH^OGB!Wv_Q1&iXe8Tf%QM|zPVUVubAgR8C8HR zF_HKORl$I1+~Yj?;&B~zhNV1nP;_lFoNFk06Yc;lLHD3bK3v8c1EB6n(As(LStV*# z%y(YEdp(VCzd#Wms!*5;Lj?iPXX+h$orTlw_v4R~I`5wzsT z1dgpgRGyc`j{QTw>JwM4a*~dI+a@{5kiYlo|0os%QV95`U0)eFU)%dvDwoJ{c2*slrVC%_qdO>?N_- zRhDW#$ta)6ihus2kF9>nh-a~?)CTgp5Lxm#m7Y!$8BdRQC4%&-Ouv}O9&x09nR&=o zd$M)+JApU;@{P?7NPg9J{pREB*ulQ+j)p^hw707e-}65P_Fb=eBD4W`15!89o90j} zH)mlhdjdTjcA}3X+53ugFeihO8hUQ9>fa*bOdG(SsS-$wE%<38$wDD<=tCyF?EYSI z%M$^)fGi~!c+%#4FbqAF0GRbY&7|JLXMdCB)d|=$Z(_!zvOhamty|#Oul%ZA0@IfO z)VhW|z+vfJ9Cg|y^dd{Ga2eHDltl_V7*PfpWQir1s;pq=JQmP1OCa_6B<8%em#_*$ zmOF!K=fvOZOd$#O5-aAa%bCo1^Pq5<=!Uf=zU6>^lVJxGF)xF4B#x;0T#E1enGh-p zr$zv+ag@8sTb+24*MeiO0%mWoCduEUr84=nzMM4P6-?~XetD)%|cGz@t(6u$N=79}P?BdsAc!LRFr+5fr9(e)(t@ zXzBAp176=IOZhRTmC9kJY*FX4K>EWHI^DGvWjiSFWgkPPU=>#jm~9UAD0hyo#+~eE z6|f0k4$(U~h|D<;>4F%#O^fIjM7qpJmIAV zvT+xjXAWJqN2Q6a!SwS9WtaOom1PGwmHW-)zjln3ZT;BT3M!33g68ADOe?3ePnDR+ z%9-siixb<_eZrqFcB+Ed{h>C25SBbW>rk)m^G>Ro#?c4FyG1v=hRGP|> zUSpN*r5W~JtinuqUpH7$rNh@W%7`-`7!is1jIj9X4Bq+hQ23g|k16+%$EnZ@SK?%| z_^1lkUJ#99z(38u3WuLiSc>+{6kk(Jfx>Tyoyv(Ry>_}hBWnD#xnxdI|IgX9%Osaa z*d}lg(Cm#{k1rovV=d}Al7QDtqQ;1bDpVe0YeG5F+CbS8OIK8?U})yC7a6Hc?uX9M z4gBmP6HBtzkZ(<+FUpY4{MY!hv7$FT%x(=UN|MA_yn}f3ia69E+MJ{^zbAwH=50Va zH;Z=-2q;s&#C5@JR^=rd`D3B%iKDci>C@G~tfE;>U)bf2%;I?@|9pnX49vAyTEd2U zYi&*yYr#F$k9;Q(2STFGf>CzGV#xj!FE)+@yHhV-%>JKn?(S;zs?S0;$i(Q1yQJis5mrC!&2M18UUsguTbNS%rFr~Cc-zuCoO4FBa2grJ3i5-5ot&T@Y>jm>fUm+;2MjbR z47pj4jl|=qnKp_-93ln1fwC8U+vrujosYp>BI2m2dB^ffPEc5+VUu14JJzwD*Tn;5 zH_HY*SBL%Dl{KnYdP!k%obf#<#jNAJr!MBq@1xrG}s_sZIKC`$rt4Umbec) zIb|Zf|IKE)L42OvXb_6uEgwM|2UYwP1A^Ecw|N0}oF=E=`bCYf-JD^4Ap%~Hl1D6_ zdjeYb+QcE`yo+eCCmVOJ(MK%wgV8kqjGym)b#IT2ay{^#7D5$t8{3w@uDwPO0Glb+ zsSvf_=q^~p`)s0K4;;}+hb=1YfIXc8? z?$)o~s&&>z)YZ}DrNoTkZM0h+mo)gumc0inEnjWkV3sILISG{351l98>=E5vfp+?c ze+{GUCQxj&{==h_iRD*DRqpwT%+7Sm?D85QO2rnsbvekb;`&fmdT?q^CTxT-I)?A9Ap%ifCFU01f@{R-cE#H9p_qH``z~EApMKkH)|nXOw?p&HI20 zx{#?GL?_42r56v9s#Vyh<0isxu-iAN*AIFm&|C#I9o9kUSJ7hp%(d-o^U4JLi%5Yb z11!VwaqHSuY4qStM`lsaNdG60A+E5K8le54PW1OeTFQ{FT7V_&faUYtywzR}+=tIR z@IC@-oK7>Rt~n<1+W-&qnhSbl_dHqZt3y0KerQ#%EzG%f9+H+Ol}eo$-v8?#2f?Lt)LS z@(TUf=s^`+?XKU{UmBXl)ES=l0QbLx#_BGX-MC-ujA!Qzb*CaT>9?&%x%n7pmzbk! zhpsK3jW>Q~=Q+kQBbX}l7Uk*fqj2Di7Sc%DM{W!xOvZ|Hfq_N}@=33XNDe(t{Kf=# z${>D}*a?+CSe3(u^5*{uWq%lI_OLZ-D@_G(Yx4t!&4E=|e$&pzGZc5fi>!5H?c;)h z=vpgw@%jOiO0PY|9Uih}ZqlE6)jjO!v<$Sur<37Zjqh6)nOoxTKlK#+JRNzo4Ug(l zZJsp5;;o1M%wW!p1$3}(GKuNR&vjENLMV)x?Ccfva0`I9N2F_j}Pn>*Ajwx~=MGWQy1#T`Y`{w7ZRW7Ev z9A%#HJr1uFUTu!bD__o;MXbdQ99GI-IKDo!5w#Wj2ZGKatt1s>wNW z(KByHzwPkVT2akXYWJHuBKRSBaUM1DEtE7;m68UiJk>|b*JXu@!~2Gkps)HP0{8c$ z$_RNXRNgY8GnczO%3{USa!9NFlR9#KvqP2_#+SeCMB}#Uf1U&Fai^0kW=PJB-t7}` ziR_5dTI_02Cf@RqS#}?X7whgsQLfX37MeQTZxethf-WGBO80dNE%P;hONnK|p+UFK|r=L@mi)adr zn!Hh7`v}Z`F$$&48v-^v4THZNkOeCo_ZZ-dZ)Q=unY68MWWJs(bE&x^B1CJjV2k7g z$?OXLj^_J;YTE4#17MQm%oVYJXRsDa$P!aZ}8uJe=a z;3`HC>1U3-$i1vnfA%s$RU&%xIuq$k%|bYv@01c@`J*?Tvo9jK$3&^LYHJGl?_z4H z7nf*I5si}r)k$!%(PP%1XlxczxB<2Enel{`UM9yux-uI##fmL*iZy@#zK{stTkVIozz};IbBwGS{_>b zL}2Tf1eO2UiR2l~M85fVGJfq3g<1ul{l!~T2{+|rQVwwR9sqfEn-#>d*L1>7tCSFoSDd*LniWgmby9-ic*Z?nJGx#!A$sTItYa+ z^#dk%fu`5{JYMw0T1K~Z2lVT+$nT_bMuMooLpyFBDoB4w_Kyzl;ZG~D+|s;E_(;Dq7D)d z{waaye|~diTd3;#b@zIKq#oGIO=sJ~bbm;sn~6G+9dN(@e(w!#5_!Yt4}8zt5L6&W z%7;b;wqq@rn^+-eIKXlg9|lLwl$Bv1;FN15|FbKM&MVF(H~JBAJZtOE+&fjjx#Wtw zP=G96PZ4*;NBuYZ>+?uPS}E&8R%8HUZBGWv_R)wz(OYAtJ!cfIT$p2Id7+5BGGiU~ zK?$knu0S>m@$o^jpB9?^`z?gi^sT)ZYhN(udBoPrZK8`tS40A2LYu=FR@dVVV09d$ za?db9>;RYc@i3Tk)-zjHG7Bfc`=(7nwk;dQd)vVM%2gY^O;(70WgvM|@CpOg*FTZ$ z@!Fjr$acda6a9itr8*+0R7UP_N4qMnU~t|1B?Fv;}=NK#_4#PHEP$OU**Eo1i$m}?7*W| zsB-R#o}om%llJFiN(NXrtEq|eh_B1YY4$C%kvJgHK1CE9C2xk&7jFPW%c!!VXa&+P zVKtv-#O&i1Iw{v&N7Hs7{H1u`S;Tc)6>@e_1r0Gl2)jpU>W0jw!Ji2Q@GTS8@kYGe5**|48D)OZZbWIQTW zR`dcm;cJz#f%N+1vJZn?A$Q2^*a7j;71h6g7s5VSjQjTIOtEh-Gu9Mnbuz6P89GvMxptm3%d}0g2vWv0VQ!t;In!2 z!0%)hWuG2T*i$3xsedK(_HNP|^s<^>)scuz(0l`~fEpk2AD4B`8u2p$aZV_%e@;YA z)$Rb$qi{+G)Sk;sw0n_~(IC2@37|#XT-CRRd29CJr&obR+5E_`dhX;EOzfF)206pn zS^WmCLJCbR1;pBlA7uILX@t`nya2VZ(RTNOk&6;T6R%ncR~HYG|@r0}Z9GvEzeRtjfNgLq_K< zG!|C!CAa*j@2AKC(8^0HBJG(RooFJp@+dKVi)hcm5y&+Vrh_~zWI}8C>3U~L{-6MO zsABNR+@d;`-4y1ep=0GwI&H{ue?nH zQLth?z2*(~(B?FD*9#fsQPuI5H8oG%4OeXMhhxinZJJI%cK_UGR>hkGpX*f(o;NiG z&HL$voQa9X-J+?Eg`+t0po=V*Cy=dWYG2;}CK?ofVUsl*=pi@hK4a-@hWwa?^e6E3 zDaS&#&8%Ln=*x2QMk=_$0j5tso6foQTHPVEAzwZpK zk;386ny`~6hy^)E$#-Y#;A*^H7b0tj;db&4!`bsm9lIiOlvgy;!S23? z*p>CdLNIb@K?V?^0ca&{-oe#fvNob;Hq57|-2knII5BOFQgTaeiildZJu;UiA9U8* zvZ!otpl%|T%@_O4nHF)Dk#?E+YwL0B-ACfka3=cdyC)Q$+71O;Bw(LLY}84na2|or zC={QZ{3@-5=@7+e{^vWajo)JBOK1DvBJK3Znj|t}+1oDs5Lze$hv5A#D- zl%)JOzw(&z;k*wZ+H6JZ7e6JLO5%vI^u+i1giRY_F@oSj|o>Jz=E9z!9p1^($Wue{EM*#`t zvxQt=AbVu3_8U10KYz+}lOcA^fW^eCI<;dD$0wbC{SR1voNps5W66yz6lOs-QmNLj zej817Kl&>l2%FRcc)gi1dBjHg>gJ(v4@=ST+7!uY=o=pbtM%dE#EU9oCv2Aq$MpR) z60YD^dHiM4^cHMLcHBfB+7bgZD5Ya$$IZK(pak2d-yO_fi)x{5SND>M#?;2M#Of`h zcxN*fu0pmsWnoM}xOupa-2KH>O(rqyAV$kSB%`7lobT@K09wR0H8D+vcz3a!C8Fb| zLF)``N8Xuqum#`r(Pi6-#jn3%>0w0u3eh!UnDOgZG*(mIPAt%)OBPd8ttrFcGC$7w za7$6lg)qK6}r9K!Hd20g#QcDp@@ zJj@^%XvKTcxm~!~Kq%doO5K_iuiF%QFRq)2?{T2Vg2$xv4p6huQw);)XH@74LZ|${oTQmmFm@?on2>Fs?J@mtKJB&V6E~eN@CfwHGRlH-ClGeYPPY0M$2O5>+TtPs*Ne1At<(c{z-_nn{$NZd% zxGtgt_%c+-)1D3k-I>_aj#@{)ga`Hrdtsk!WR-LnEJ|qRVbYV;dr%y_oPx&@GN@R1 z2br7x7+dmF8PRx%ora?2PA1UlGtQ6gy|JiaSNO3_C#z%&-+JmO=V41IzA}7KB$83= zF3q%)8#wfuRz>i{?ReN(X0gM=_JyHDuyeYVGoGSoUWddaEN9l9nl9 z@~r+nu)OYNXuWz&#fzh&$!$#f%) zou&L5OB*$7DqXG|B}-Bn`O*04ihgnKOSSS>j2d6xtpiFi=ZY>B=A*yQ@$k8(79U{-ym)I~q}s1sG?E_B^RbC=R zHl5O=6DH8t?a3(z*isK~*-sT){tEKU6sNxp#odA^vo?a$kk(cuIB(MCITN;NBv|+T zsQtm}hrgL~H$N^3X5IlSu&`M_xP;NuA{)gVH*aCdF-tI$?-Q|gG95g}oqlfR{U0PE#siv*hT?B#zQ*@mxIi9= zrR1*@BqvSe%UuIy#W&{@wSMaoylq1iyK#Xc+ednot34vpO`9VLH+?Q<4GjCs4)f*x zht3PN6JFJE-;zJTPf}a5Xx(*076)0#o_utWT<6CmunOOzzNUX*`?gS<{-n$oMIP@n zQ#8E{q?6Jqe~-E3N+HENMSRU6)_x?4J%~Z{eM7P(qhSlE6)pnqg!zP91F`(eQfvzs zB>11h=*HQiXP#YTanva8W=mPw1QDMcCH9Q32>eyi!ASeSD!w#m(PYEgcXmB$vxvwG z*2-spe0u&ii%&-eXoHsP!fc6i6LBN-?Ed3e@b^+OdnU2%l$di<^hN@J2Bq`^XDpZ@ zdterQ9h|&3WVnEj_#)V{&zKt&`8WE}j{cPLluH~5VylxmRZsFvEc@pc5u7xU^IUjO z6kYoo^xGd`V+PHI?|<7Wc0Vis0zkZD;}W5`lzPEr=sI3tpq-mGi;kZ~WwewJ=3B-? z^An9(6*h*L<{Sgrr+x#qiTfInn;h2ezM*`Z(T%JXenO5g^V*KW*cg>U;I3mtB?{@*m<8dxnGoC zMg)FJ{=>|&ZTt2{C_so*`W)*pk}7N}Z$&|svj<*nri&cZQxG$NQmhx1;@KV!>T5q> z#mifp>A#JrD^|kS@<+(M1_2h>cL(j^>!sZPSj_XXi8+aF@Ym(A{rQ^)a~+A` zf5<$L`T8J~HuwRQa`MwGB72so26UTH!G~S2jrlb4!4lD)r=oiKe{G`Ok22_R^yvyd}^A~OSltM-pj^Bj+?5HB74%(?6q`t`&IxC8>jkRnvu z=4!ES3g&*rKl3A3T4N>K%mjmq`#Q2fM=TgmUAfwh@v6U(%xUB$Ugck%Y?Pyh@9RB( zz=;*I3-7WU^SrT~KgF)#GTJi)z%gY{?&{5D6Vr=DM^kjrwgp7nMCo>}-wj8wlpZI| z3Xv9E&^xMEe=eT{oZAz?Wf&Bt8xL5z1^rz_Lkc-2jvBj=`ruTG)g)5$fb77x(M&Q2 z*t$BH&0alSV|0$rlE;O3|~0wxZDOtmX$utRAEA2D5xJEAGS)8citk z4w=L5-N@SIOuiE&=o}OTJvyA-;YywNAUB$1;mk*V^dftkpT=&Hwd~@OfA!{;5^ftq z#Wi3&ww5dz=T~`+zeeb-sz^&@$3=i4&EiGYO$zo}tL5y|R@8x0E#yQ8-SMBIz*^Pg zM^LvdGVf3H)eAuD&orn$+uK+k$bE$;L)u%WVh z6~snPDHgmavhxqi%CIhHt@SENJ){ZL^Lc@OHU%xAi7Arh{8J8#ayxp=etA5r+Hzk$-ijih3vM?=U@KFX&Ex%7l)<#Nddy6CkHfPfw$N^Qn;^7s!=C zk$3e>C)AB9|4-4GKg6{Dar`VZXPRbf(Y_%R?MkJh8C$qiE|S*CI@SiMq3E1OSyFbA z;^0eJ%3v-@>Lg`L9oLqWPDn$lA=;PkbN_*UXlBlNp3mp~e!Z%^Mu@#{B~~E(!Omi? z?Uo3pN_#wENTkPAkz&GvTOeS-k zcBd}gu`hsfpIwUh9ve$V&Yn*_-!4ukM^KAQ^1hDPXcR{qVMxC$A(JM+C94D;V+COw zD%lZu%2+n-izzO+OO--4XBTmft zbI^3v>QvKV)YrDblAP$pjN-d)`U$^VuY%j=(htMv<$|L#Ci81QHmvRCRUZQN0f=0g zIhA;T(C~B;JuYs2Jcv3iz~1gBk6DzbFCdooSEhRbB6XrI4WY++(-6UWC5zr5pY%LqX@6W~W6XL}ha*;Zjy7hIcCUlMT zBG==AAp0t3yge;@xQv;2hb%VnI11Hw3|M&^aDZQW{Sx=qaeF-Qs(8s-Olj;1fG#Tz zw@pZPFF`-Nvd@XOssqW2zeyb^*BJAu$mPb}sKVa3|8-YT)lc-9ESUh}^ z_ykWDejbu{r0Un1kLX@c0+X-bWFv=cUqhnAM?_?`18JD^2+mP9L+wjBFIts*pPV*h z;SX94Q6Gn0q;2{hv0U?8E7@;Tz}&=0(|tRcdZ`;252uNuquq46kP4lm6P&oVQ={e9 zSpx6l!zOCW69h+5gmHR(mea?nO>~Sgwd>om8&T|T?R(QN_}*xIPIxI4-q%Fj?cN2~ zB&KwSD+^nOMr_nsXpxJt_by)cnqJT=&gUq`<`O1#14~&^Q=cJ@aea6UTD;%A2Tp00~lW zrA&B4qzX(_;$6HS%|qBFBAWbW6i+{}=9484x!31yMqSv5lk*DnGO90GC$&u>n%S;` zl(5bV6r%gudyum}hj?oW@$L^$m9snXy%B`5M~d?%q&=c&`+z>0e@ptQUr^#dY@r-2 zzj>S}oPf%F0_XpYc(W@3sra8-_K&4Qoc1kP=0CW(--tMG9?}JhGqHU(@||eX$>}_e zCK5c_!$E@JR7H?9j4cRIZmvT=rhp9VSB_6fnvr*Z7u!2Q_iBUq+de_k6h~jhPR?r! zBzG+K{aZ?WV+kj4-oC%~<3X*gTzRjF_di-u-4k@-03KL}{&_38czBRHza=;Z{qXXk z(EK5m>5PYjDE}QJJMwldBjnRgIStgeG~g{<98->Xj;$82@iqIvAuc$=>HLsZKbF>e!*F-vOKB2sNd8{@g_ z^NGuRvB~M5$a92#`GPDcjTVPx(^?DraEItxdYRPDD?U(gAihvvN$@34rQI7C8fucK3&O)FK~1r?lBR zpYhTf)m$g_^%+h1UyS+x+U^4Afsb&Rb0g$rD?NO2(W+iv!^nuCy1+2*zODQa zQ8>C=^q%x$`fN$tr$mdLeJlYu2?iz}TQ9MyMsJDrH69!{v)%)(`ysC;Ze6X}80 zU*)ft?P3SUaN&1R_|AjmXIipsozlk!=xwb-Q=!h55x6jaIeuSIgbPyEQnz)Z;Gj)Q z-f+H7)OP<(-w7b^QRg?z(MCEsGPh?9kis6CDAtAXho*PABDy45Musc~s@z*pDS^T&H+qQS}wP zh-6knjUZyMSLFSGU%cy>e&{;4+l2F$HR!pSc0x-d16JUeBs6!e=z7F^BBq<8er6Ra z{DtPN3N4bfjF$`bv-~A(=fr)$&y*D%!(?aXQH^dX)J0q(h@{2;?hT41+C)J2xn(-$ z$$a{oUfNi{UYFX&Ed>K$$!=uxMYLFH80zl|n-nN7L)K7`!w^5`XbW_9!&qnM#}vXp zV|PQ$Ba-37_M_B4>#6;~%Y>Ub5#G&L8oVfAF(Wj+6gB#LLQ?Dp^}A#|xihg^94Ij-=(c7c=iJ`MgtXr8|fA zF_PZnWDBtj=}#!ZY72bVdzf>1A`J?5f0a?Kg;0R&Fl5qy8!=e`#+$@ML54GpYL&3x7gPzF4Nmqo@Mj;=y12;Epbz`T;N&UgB(DS?vRUkcwpJ=v|IxJismIaUnVcjpbRgxAg8ND6k&Vo?a6q6TFD=;eQ z;derQqI(}@;kITYIF}!HVYK|)xZeKgC_2WTnt`fgv$>(C;pY>Xd{^!NJQ*`CxoePY zSxTZCcB3ZVyRgD;PNQ!PcF>iMcciZ*jSTNv&7g(a!RNZ!^}RK64b4qUKjl0buld1g zJZjJOgFvb^S2wOsB)8X#lk3>Jb`8S0UpNh$QS&?OLO#@VLg;hhn80)&*&avAS(-&r1)^qB4MUHB!>p0qJb+xz5K;Pw zc3l{?Ba*)P#F3nN0#9|&Y#n7xN9s~bTcZh+?fB*w_c?wa|3(z6ZWzeNSjg_8wyM!A zf$}G0v4u3$Sx)%c?S_Mo`A+&4e6oNEx#OTMo;#E3D`D``D_IUQw zDyhyuJ`L7R=LBCu>PMaleq{Jzo8K9tp4c!Na16MG%YCWTix;Td?) z9F2lwy$1OWVHLU&tA+m#utKjWH*aG7nI)OIi<~--E;a<6rKdZ=tGjtcymU@4pMNfa z>XW)LcP2W=a4|RO7|5Kh&&j+s2wx5eMo(CTE`K^N-R%i!R*i*?e$H;#TnUJX zsFm`CAOh7I)otK3_Km<_kWYRDZyYnT~%vD80a6ra)h@KqXUflZ1F2SDvC}7Z(zE7CZAMZ7YlyZQZ<+cB$Vgvy+CdI*oQCP zS|(YmfJ~N@BF-xS>3gou0S9`Q{=fgRc)X)uh<@AVbFku6p~s&`oJ_lTc`Xoi9Bx4} zQ}DpHm0zIT458(A#M3~Ma926UQ=G0ZdEid#e`aiVfsv?*ydF^(9S{`>gmGiu2QeKd zW0OC^&uy(SI$uZej2E{~UtSI<0wMo4QE5OicS)!Iq6&@QD934iVkQC#Q8c-muEJ=Uxdvd`AByQMU(4_fR^q*_gV@P%k{$ko{OA+x zWWPXcyKL-#F^r`;BLwIlZ+W5JJ%^QtKo)9{ zx-FpY?ne@-1!STvF4#fubf7zoX#Ic5DND&Ivp`mewB057P(#ez0xH3aACi&dM~E&^ z_gQ?8bSfgdyv2{7-B!L;!;LREIR+3jHz)^eGL;ty6Wg97K1CC6-w$!B1e&T>Wz@j zq`+-W$XAp6kpM*<{tfib&u|q|{cT%9mY}j{B6Yuwx=yGzO%v3maK>A&VYFP?n5H1+ zz-BtwO>@D7zQA*qGCZAh$adJU!k4+=9L)ReB^P5@BA}K^P$a{ikk~BTSYe;3&H)-X1y{kF zCO>=n9PF_d)DQy=6pmkQv_H$KC^z77X;-qx11MiI-7=X>>6s=IS`|T=0`DHS4{=am zF`DNkcQlRLUmL5HTdEScmOD8G{p`TE;5fQBO)|5&Op?Hb61Ak0xh16oIT^4Tms9*G zvf>4leGwIuD~orP5i@5+P%#VXs<}dGx+rcR@JmgWfpyNp@>tr^PNmu{@_W>LC8A;+?X7MjLrW8^R+z{0sXe%%n)27*|1^5WDOc*%Zgm} zum3tvWyWb(?%ctt0Q)aM7d(Uf86|EEr$fZ_e3>x=8w0gzc0C)cJcKs2y?RrRTfM;`9Vsztm)^GLif|mzcSP zPo6cib1ju@D;c4-;f~A^5J>-giO6uE^C3;j;WBC+S34z-IdB5xRKNV>Ffx7FLS0|& z<~>c~`{He_7pRKA0D#}0hW*Jm<>bo1*?7fqzlOuuWLs^pBaOURMs1iK+f>R1H}%@l z$Zvml)hQjHBR_cZT>_c^9|y+Rem6s_^tATU3DOwkY%Iq(i+l#Dhm1T<^;mgN`(@$r znCr)ZiFe6JYrx-H0|~a@ zf*r!?D`&_w*j;s(<&)Om6H9-22U_Rc!(>~8gg3E#?{au0kbuH3no?frXiQsd$VC%8 zK}k$0@R-c@=|Ycxlq@q->L$?nR+_)<=|BPPIVZRdH@9)5*wSSD!HE%a-Pq0aL+3Ss z$bJqmls1e&CI=oMg?Ik*yCqI={h9J?j5U4YI;9)7I9w@#LKoeF5^)ma%g^Ynf-P06 z(A*0;A6xkgZsdU0JN~m4j`(d4hehaav@hw?8Yzq^fFSS~%hODdc+zjKP~m*sHl3`x z2+4gNWsBZK15}wqFH0;0OfGmU5%737+ol`6)#W8WF_O$&@H1vW4`dRmK6*|+YjQH~ zdIdW1OuB1?rZ-MzTvlf=qp;$em}@m{J?Kw z%oc0{^YgwRb>wk0Rj>CNfb`A^%DD^nMo{aV=@1{<(^DwDA@ZpI1!s+jIrmgSW^wdSZT(3Tp@#t$b*&kNU=fR-?HV-DNqI_tYBVLq9R0qvV> z@nuLr6uVEHSG8p_E;K?LBcb9cM-8*))Db6)G)3#yNS9aef3&0oA}qmOWr88xda;}* zAvVJc%kWqWb|4Bevb~av;tg*%1B{tJTzu%uH2G`Zs3?+sK7yLKaE^Ay>@^rY-n)~? zm`9)YAg|p&WIYv|-ixUNQH3F_bd-BRn#p;|B>E12^@2LRi;-Q0v|*!|j`5>yjt5FE z`W>Vag{8xNV0dt*ifb8y{Mjj4d=tE>t|#MdiQ?7+xK9x|=VJf^WEza?RE>cXErVoj z_78oVN-VP24fi0SbJeSymT8S7p0U zs0%1ZYdMVP;k(qym%y26xwYG0)r%O9CTB;NNz%{ZX21PqwGJ}gX!^whD&z}*>Ys5< z*F!n-{BI)ph!0RnLrWC+*QGYolVHEQ=88#{stu1g2kfN|hH)ysW}G;3yAd`|+Bquj z-iu`Em|EeF7D8AANA|*7{k3D)X;*uY530zsCi$Fks2?9y8+CZe=UT@lc*&N)$8X-l z)2qFSX^*0*s8O`&d*q4hgk$$0uh%sPK zO2_Eb4+tC`%yz>LGFtmq#6&peAD60VObp6(EC4w0mpbao(lU#C(%5&nN{kJUv}9ITf_q3FAZW05%l1Af9-|CH>kIshVqvm8Ut=ncAk@vpq;EK z|L*y3NdFK#5o3bsX&=ePi3h1DeUUs4_OL?2P&mww6UOD&(|=IYwd9V~^y}9_OuxZ8 z=4K^XQla}}(=B-Kus6Oqn0#d@`F6;nPK&l*7}1HKyZMSah)id|SEXmn4m6Xa4mWG5 zzMb*X&%gaOPeSPRC>91aX>O|>qpv_N_g8PJ#%nl2VEp_oB^fgHQXtOin}e;myBOakxi@7 z+*us+TtlPdt9toG zcufo?Qy*Prh34w1%@!*7x0&KAqRC0LmR>w~==8bfs$N4o3GI)-jww zparZQ1v%TZo#z7oVW_D!l(#nuzMDkUjAmlcf~S3tM&tz;sRZ7WQ#%k3;eeYzE`Q{O! z`BXSF@D>#CQfym5wcO^DMp`mlIL3A|<;;~E`DwD&(3&x}^5)+zOlIB)WrdLKE2!=% z+PX;TL9p*foxflUZ@{l=!WxJ~@C|{?SK1E-&X&62$SR*>9xwUWW6^#BGh`9awy^*zV^R z=*0khT_mn(0AD~k2P^8g8MQf?$Y5fbnQubN+t!H%A8VVU!ErsooDh!wY=Sk$LY5LN z#F`wK!y+trK8yR0hCi2RAg9-k9#}Kwr2Y4X;O3@Ni zjf1vs-4v$Skxq>vtv!3^uanLk@|B(Ol&R6sjxMO}aTz5=P6nw|bq< z$(_(|@;ImgfbkV#Pp7l>NkyNnPYeuD@S z(NPx@$Q5mbmLi~sWGn9BDm&(lpbZsIMG-i~^E-?!feBqb`5G)zz|S#63$C+`3dxn0 z%ki}v-Ba#-hr?$aK0A(nNA7AP&3Sb#BSJ?#Nx=rX-jHtWUqD59%I+K3FCy-YA4DdM zqjh)0Gb@bgsh>-zspbiG;n-rsY1oc+W28P%cL!dvkTleYk33;*ypjw@`Rj%?kJyCH zoebZo`~tROP2!0M;9Eh%R`QyDU-^?%8%1o1y{ZSww(A#cJdQiB>_z;tP<28!*E>(w zZ^8cN=G^;ya@*ikeCB%-=jas*euU01ULB9q&Sndq6CoBO&_{ReXA{|Up+b+Z{h~)N z**jV#??vjjJ=b|Zsn?=zZZGFxR+A%nEqoX<6u6)=je$pJH4^dY2`f7Yjnp7H272s| zQm~)g3|Zf)z!v0_Q?r|>^9k`%wACixf}5kl3VyG}?o5&te66Ke9P?5v_uYT59b<+0 z8CTa*d=n3&iv__C+3m?}!H#W6t74ewxV;MJZ`lgBE|8>O6g%8LjjuI=UV&FrxsHAH zRLLo4*u;0Ma_3m;3XlGIj=4CN_-Bl)P%rLkoe6!(l{%pBap@sD!V8)N%1`Vq=x3hC zjpw>QR{JOQWi@-q{qG+oZO$+X1AAc`yHO15DQ2c~Y^FIgD&{W)0sx|prIhbRdL|{Wh5kUv zXdYjD4RBX3fk~QOCmv3U(^X=J1CoqL`o!HbqFE=5>SwF7_=-?n`AHo1NEy%eEC1oC zJsA)@fn6XjQ?&V1JYBigOdMdOOgqCS5^{J*0PkaIqR4Mx#I54C-3`-OMB*7qjP9iW zNj^Lmr>n&QyXFJr3=z zRb_xEpm{WFInks6_KhYmTO=`N$<-dYTE@^&ZHkkCV53#o_-;PT4$;^_5G%9-H6F znGWVJ&j0z&U+GY#Fe-b&SC~U_8LqAiKsJBwY2sSNY<#a)M|X=m?py+QYN30my3;gt z0~oH4BH0&{B@Ug-#U_7{#D1#%c+&{{?jfG(iCVqm`{@ok(VNI#Kh;_o_*5dmypyQ#S*ALlHX^`xu8&7p!5QYm%!&yb%0Q|G{DIiqVAUQo)<0aT< zxxR-vk}YiEL@9@C>c$LWB_^o40=!$a4#6%)aom?)($9vWgKkNjMnGZd-w8*QCx3dq z95Z7Cc~^bb^T~cR&VU@Pn%oLGt1zc$XvV=?L!78#)(1=2B(mHP%Vzhc0O+8S?I=WfCd zwD}49&ILfSNk-7{I-X`LnfF^D-`5Ij?Pmvf{^qC<)}M#sbf7pKj+CxJUi?vRwpfK>+Gu*$FnI)= zP$BICH|A-1GX6MztD87&NfDmtywuF&&1%z7N$U}1U>$NN#Ej_rKz_I_?s`mOP_L(l z=aUDhANdd0ksNa#d_p>=;%l=d1C5enB69W&@(PDWX3?~fNNXAtNN>MG&G_M~`m}rS zhoEBM9knTyn(9l>-{33_GWS>_C|0wU^fs}h8v8B19l7;s-DY)XdUYDgbn8Jc>?kT& zs>~d>nsst+Ezwn*jAvMFkxGUHarZF!hf(=7wke!t)k|?LCylWE?Dy)2_KhIjqs1II zJnj836rMmn(2$j(P54Z*gxtd^zF}F{#xnYs9C#`T_=9(UOmSX@EUhQqyP_f9wSa_Z zs8!$JRSWgZcSkLp$$P#u;R7O416D30w19L_HW0uZ4P^ zr_>0bknPk*wtNSs5REL8j_m^*A}(G-V;!%d#siq2P*)N1&*%yhX4Cc@3jBvIHG*`e zm&W_)A<9E*pm4+Nx7D|#|Cg3r86#yoAJ z4xn-C$DpcZm2Ah~;(+4=(4L zTdiQ%EWC*(vi&8#7I>Sv*w&Vuxu_Je;8c@xR^bTT9;MLDaliyOl<_+Uk+Yc`A4hId z6e?fplz$2e+ox0P`hBYE0+x$UL@d)*qKyMW^Gql=Ug!67lhJEfA&yP>2{TPrB>f_s zOmmdIY?;EWix%M-RX3=A9PW0&F4PXKUXe_oNV1df;%I&s4N%_>yW7>yFm@&~Q`iMR zp{kw)M*iuq|3>`oHnV1p2RYyClEtgY+h*dfc=DKygbiubh0&Bz_2|3Evd^yjP?v=U zEvU2J7kG0mQnRIO=g-s4Z*wgubmk~CvB|&S4c>eky$hujim;40BC~Hd+wY2A$s|*C z*{Hf}sK7{h`KEZ90X=^e2J*eePAUKLHLq*RlEu4rFxRKap1ZgTNlu(ID_f?(Xi zo3uMktUGIx^-kjON^)w_6|{C1z2p=?0c>VHOBg*M{?J-CReXO|5&rGCeu*`vm@EJY z)W1AQ3He+>rSBXW;<(fy&dVX2wZgDLaMt299ulpW{X|WwQ+BT3NU4X+LbnjlF28e$ zaxDQlr8MaBIJ#gv^^EV)|3s8?vUp3EbH!THQnTcNi2C)ZZ36=ap1b(s1ZBJzkuVC* z3q3n6nY;1TO}DvFY!@qIbjc3E_3Ol|Gh}Kg`O=NPk`7QsC$sQZvXN3`+27Ei8|bCk z!8>?9wbsBUT96Lg*gl6!ub(FV*w`lzBVMm1YjXyNc~fnnIQZ>0X5O|#ozvDrP7#L4 z=9%osW`X&?t*o=nP*@&&J%bx-wxD_Xp~+~#FkaC^9R;H;X>@V;g^W!FlJW zqj~9)7DQIeRj=;y&9}v_^LI$P+L9#$OK=d*;Vjb2S|(l=s(iM7I`|k?J!qxcFO%#O zR@;{?TeZMO3H zrXH(Y;0P1w>NSe98Q!~C^6E@exnTa2b=R82zNWa5k0#h*-ntk}619j~ccPlVkt#?R zS(nB@89#JESc6)8gyM62;zvaCdPp(B1az_A_X$Ja5y1Bo4RNYJkY`4p#;t;!r7QIn z2GUiio$C1N7HAU?{FFegXC;XrmrG7nt5S9@h&B_4CuNxuMpNW-kBLGFq^AeC^b(YJ ztmZ*I-u}CW4mMAhmz&6<^X%obT`lBKe(B5Ke6HXG5q1GvT=7h#1+nfxiW^#N6tf-V zAp-BtC#dCmV0tM*%q394EY7BvE3rE%Vo=6t#K_xMC9Q$Voz0}uTl}Fya#83{9ARgV z^y~cCkB5Crq70kGUJhK`c{QBoEc?*BOnPa^rbwpek;n2`hO>)&j9-ss3tpzwuuahJ zVir+xp@Cvs9R2rSP-#d7%}^6EbrWf*F9}x{HWpRNIf{#B8uOs343hEq&^hoy)wKMA z481t2!|Y833Q@%MC#;;sgM*^D8V_IB6?JA*8zx@cjV8Xyp>)6d%OyI!>jRi9W08st z8b4V=H7SaFDYEan4LLkIN3}(o0k5kJJ+!QE$RWJz9JUbRB=~6h!*dYrq{18 zr1o}~AZa5rnULyJRDt&j>e$%Tc>3%SH1X&`$~6Y_1m}_-04Ua_Gh__!)G#r}7T;#2{BD9P$_2)vCXggYvGuH6bF|_azCu7BAB=%7vfS)Ty{WH$> zn8TH8lXcLp$F|JsnTLoSpPjTN>9N$=X}y#+v#-X6S@CypOO=l0bWWs`?)uOn%=t39 z@DwpA8I~SewqzFO{R~jl*Y>;1TYed)8QNvKiQ|J@(Ev97;Y*RkVjn)Um`eF#tI8`E z)^8Iv+#bjGg9UM0Ei|SPw4RG*>+xvD%7yAv1UDl-9m1>{arnv0HIda)R!$=4#nR#a zK5o)yD_^b3me%MLof24{-^n|eNEf7kA{|Z;seguidnAiMkcw*%*REa6l-nJ$o{rWe z&L|vV3nnU^_aQ*%ImZZie;TM1gIe7Vs7%knJ}eDgDbf%pVK#pYPOV zds(J+5!o?CMGWbOnkhq$C<_tn#a-pj2V|q&4C;^12(b=(ZHm2EK7wS7f?sI^=$lum zTXW{(U?+XF*RW2{m=)#ti0x=tLiM&q9^&YDmwpvtdq_t~{#b~#8FyEk^r~Y@ z`1NKi+7hcy$e{+yc?-Id@pQH%?{G@I0nvRyxpTwei)zAR6Yx}E% zS0OH61}dQ9avRGBNy#?YTRO2&qr*eF%Yg z>AMbS@9;h1Cp*l$Ur;xC0L!U2YBgA+;BRE5+%ZyS&c*;K?L;)0^pj)yi~O+Kj4FsS z#+==NuV}p7Pp?R2;jvW^7S(0!eH8OqZuGxawtOIu@7nZy{(kqlbCvOSaNbkG>HT90 zd(pKl){I58{r!5?7t>ziVwecuJM}?QKS;M_S;b}euIv}Ylv_|k@VHj{IvZZq(%9ytc)EfcucK|U|q z6?!*ag#^3+!HvqP5+_q;Y@9Rm#L!)<^`r|&IZJc!?*a5BMfLlM62TAZ-a_s2_teTc zBXDPCD^xgo5b@JJ!Pe;N&zqeVWYdHs^g$*oV3XTP=$eq}4DBluwTYx1yF?M<^VeA= zQx^uDkzn43xa*(pX4hP6KnsxvTiS)H@#DA=+6m=QSUw;Lu;GI?SO7!5~97d9Ibb{{XCBZx;7v zT>fnS_di5;=Pk6SAf?6@az4o^lwxZ_$(?k{SbEcjGMu+b{O(D%sVSg7ncYMEjQGd7 zkMIEF5l$=zv3BDXml=95>$UOT{!`@f4-`?tE`C0U%8k5a@cSFlq`RLvSvF-S1B7KGUl!*!g)G;F?*`F!-GoV~Ww^fnpA)~k(UaGNckr16^ zoZIFice9mQ@MXL)A~|n@tQb>2Ifi)uHO$Ge!JWqHK$bevNPPzgUa*pOqpUP>Kmn46Wl3z= z)cG(vsnbMyXfCF>Zl6D+7ixG`#f@l!ij72ZQhq*>clA0_O;LXZ;_SLJcPR@lG0l|j z>mg@{lP_7*ne*fM6k_n2f(w>IOZ65|){|xB2Abj}wBJN`mEI87a=&8ew{69ECi`>% zHKg^U=8M$l!gbV?jylNPds4TJ_t;;CS?}LV?5g3shFJvX1|FY>&si#NwFZ&|;_@2t zv{7rA8h(gWX{CO5*1~&!k6DrI^}oTQqCzWEXX?l}eYf%8=_sfkq4Z&L2kARgy!M@P z=N~dv)rs4#JaB6TKbvY#|M%!8=C3Gm*BSDPI-H8~&;+v9F>zyM?U+nw$VSy#4maF{ z!v4oIfB%W~_1ZbA7j19lSXEcTB@--Oi=`}KMariUFR;e>`cty(Yf9$QVa~zW&5T-D zGzNBLiGPl8Lf>yCgm2&~o<{COXI=)-34OXiX+vZ<(v^-j{w1p+r}$M+ru}5JGXrX0 zflQepelT7l{j9e{(*+0UL?fad_qZkcfd<~mf&(@Z`W~BFWI^AVP3LxxrPi73md5lO znpW9J-Zdi@rw=lL92?YDZVrU(oazd0{p8+r66pAJ!WJh_O!cECfALpr7$uLyWDhV^ zUcW_A=6*Bp>^_0|fk9lZTYe8GOu@Azdb=|8v&x8`(@>@O+WY0hU@|!eDMd{(Qv$O+ zTZ(+b>GMaSSS5`jrEBSF8zzum{h8j|ObK$reEZ>k7 zmauB=T0z9VKI0;z!>P??TFBK?n$-ozF8;FeOH8le#}DFJm}ECIl|%jYK-^-eSyJsq z-P;Y|#134?woAnQMBL$lDRuEWrRJKS_>9EsNm_jK_wvFXv$Aio!RGUi>>iQ(;2c>c zQn?8}-r@2cjHUAjP(Rxiy7?miU8f(CDc=uBF?)_uFBj7F=3oe|&lJMWjE^(@<~5mX zLi&R8rkVUQOEKY@2}XASOh7>&nq^Yn69OH|9~y4AlD~A)dMuH8SuY71f;+PM1PeBl z5w9MTxe{h^Ki*n`&-o_iWl9#GB$aibetflo3N*Ko{~RyN<;jZ9?dH z$=j@fPYh#f&7e>jogYiHwOlAm|W@#Qqq|w zs!Q}Q>IA9BRDYQ+KPN%b`WXtaki6PX7Vlx#DOkB%b4L8`*<1E2ME=ou5tnO_rVK$vz&`ubaG*eFx-qe=056VSo7b>!9zK9-vY6u+JlQ z(k92=?~$I^Zs{0N_BqZA_pQ+TAJkb(1qV?Dvl|lyK2tJ8ioZ-{1N!;QN>Yr!W^?hujz)^qEZg3L`7)zz0va=dH*RJ6K-I4>QbstzpugSNaF3g=tTCJ^Yu5R3N zOk22yF1I6Jy%%rWOWup6?|r7`txM~nPL9)*ZiA(=U zd%2cweSE;e-E^!tVPs;(2Ik|3JZj)Vr@x{~3wbYb8uyG>(hs^%p-_a8@L)9ktnM!_ zXV)Z!pyZ)}dKW)*-xbJW51;CDpi=_r8Ne!*|J&cE1M8_&{M8}uW1l}HPCkm&$udP@0~k;J^<<`ni- zuqGWO5*9&;W+Xd-{OFiJV}NUEULq=)xL|n*0mm(M()_P5{Zt_mU^?9${~9Jq+%X#u zPh{cKl7naVw=JV-XU!g8aA4nT=FA+}z-5A+WrsXv32a~a!l(YyO40l-@{h42gC4~> zrf|T5QrKh*VT^z!N7_An+N$93e4mZ2wsLEIkNLK6P5{fQ0kL#l17#c_y623r3y)$2 z=~8xk47P&)zKecyzX`7>w`68-J_uTS$H|KkWvIoJ2GZyuRi)3#uR;UI>>B!=4Xdqw z)yA&Tn&~{GcDxW#mH#6LUR2`Yv65+1XqCNYu-}FH*k>nQY2mR8yE-W0t?0ws7Rs>05;YWYET}H)W-?u2^_i54R3+Oi=$RqRU3)AA6etUZLO!Ccda%F+U zs5)6X9gCE*o;8vB*LtY-)#r$|lSO!&G8A8JtBFuxbfXO=H05Zit7X*uR6})`Rj5jt z>Bh*l`xAtxnec0XLQP>}l3lRaA*A#~i~xZh*g+E9;Asi8lAbi2IMU=H3Oc z`3`vD+9zmjDs1Hnjx!74oJ;J@`&l(@%4IYXu#+&dmA$l=*_+3if@hR<{vvMi>TchB zj?TtvB0dnWxd}zC7MQbpMZZ7WF>!V8Z=0Bk_dcBmwR^EVCzPSS6aRC|l7CDP>RxXd zRhdGbPhKPS#y4+G5;SZR`7A$aR+qm5?mjMFJh2JSMd{UR$t$`N<{LpCDL&_)Wmby% zj>@4H5$7oFXO=U@-n8xu`)ghkbHt8$;-p>m4RisGY3g%eH7bqsz*9pCsWdiQO}h&}lD)OgP(+fJ>`!!4?|n9ies}MvJx| zGb~!n@(}QRe)YS=x!HNS`lr-9?d2Cg(2Lu;GATb9)s)21mL90UKFOsUEM=w0afyV-D#HtpqK$#r z@6q`I{Oo0%+)tHg@pwH&3{P{iIF>}LL%DMJ&@Z-A74l*zMYt`7BWzPy% zT0;kdA4AJ@#uvi(clfIkep{H*4b)pl`|>SN>(F#%fOyDM*KiBU22OeZd-CxJ)$tTTF4T^j1H4K9+gq4 za)08Ym5PzKbd?}O8%9OhkqejJ)qh+R>%|b5fbLeoz##F zx6)^!&U?F|oa}o@L_uQDN8mBjzX2c$`~|N~zYrCh$sJC+8BL9gG>93mijjZ)WJG2M zF}lkU(?bu*?FQ5wJA)8~vk}*!`7~7BBhmR-7@3o&|2PhMKIX zH4HL=u3^*LFO5zFsF$4!C}Y3;9!luJ^H^5H-RMXNH?81Qab;HJvCQsOG~z_}>(f_v z(`RFYW2(81meHlKbueq=TV>(wVZP-qD0l780e5?6JRujg;E?Ps{&>cCA)~|AIQ|}? z_`2E4*p2JpVxN=jq!u?Gn3qq6tR^90>Zhn*7F+#hQP47w%Ey6JwA>c5Jl%(G)Z&FZ zzhYK5cpG(y!U`-?hIGA20N&vsLv<9gaHp6x(ZhO{$bowkw#$@T|6IMlQ&D1+h)w97p zb5z_ZNES3jYYBelA>P5Z`lCvd@om8zp$+=+a`)k8Bdyj%2!vvd64<9O49Oai?EQrY z1`hnuFZyL3=LY6n{J6)MgZ#tCWm44CV~;4?4r?!g-^2Bbe%b(6cUtX^Uh&Gk5&Q`1 zn5IsgPT{;JvA`Obws^%hK#nW`CqX20^bpJQ*FECm|0z22xETIFj?b}2d+WXrLei~M z=dRpGg(N9$t`;4Or6@JCtNN1r43)u`axeO_5)HYf=KB?r(j;k}E#10)pWna!v5#$b z<}>g2>-Bt&A>0Rqji;Y+zvpDbCWA!&O>hDTpnm*K-1r7iE^NTJ-eDcRMrpDDcRkh5 zQJfeh`@}MHa3%qECG#VzD4O&A5q!hYFCGsoLW|O$@e7wTI%-*)i~a7uDj_dNkwLm_ zY|CNP=r-xc*lmIP+Yyhs+LhtdqQ;Yw_GQovaTfdnl>BBRWhXFLD}?DxXE!85(n;~<~7$2NLC{-#0>nJ&OG?h^?S^j|F7qZ4%gE9fXcdWwV!UJoAP zaNRyuw~1u+AbM^xHKAc6y}2%r{CBq{DQvL*KX?$|g0cOUL*=p=^TW95W@F`C!-5j= z(#0o(w>+1BM$}_6dUwEz3iSl}aoo^sF>#$8`wrQAo#|aa{C{prjXqp-=NIai(`^{N zT6Hc%d^eU_zMdNOCz}TAj{Oqq+Pe|l{wkqixhz}Fc2O|GZdGIt9DwWGSw*~GCYs03 zo;NBbR+@5~vLgMmVhO+g1~cswwne|pd&q&OTRsWkwIj~fus~Bf__?Xq>uy`GY0qm& z7pVLeLsM_$_xd^PJObd~pBO&7{ID;rmbxTIe>60VU(?oDl7Wo@P@2)k)Gj zk~q_jgM?KrekauCLq;{ptN1%iPw~x0-HQ5O7AZ=2vOcR%S=2E*CArf?VVhH+xAN9; z93QWHJj0yUK4-I*NgaNOm2AQlPFFCu`$ma&+*oM-o~P)cyFfLoU<_(u>ODjtdK<7Ir3kYvH^ki$Un8@ zsY{9EW#9s>dTNVzJ|nKJii;D_cWXgz=lKl2#*V9)(!7{HKf?{1A^QN;TpodM>c(O@ zeIeAMBSdE@-Z_OZJR=UhRYA0vMx0~zWQjW$5ux$oM3x-Q+n0^l?>jL=*%G2gn8^zf z+qc|H^80!17HU80 z?vBl{8OBQ{hxBD@1V>hk% zXo&b0+CeaizcLFwSq&WjZ{~_$CJyfFv*FdTF!f^|dBlk)%Q2uT`Q%PueZ@< zw~>j|n@H4Vu6?ym=lCgtN4*J(xcV(nzGwa@&8At4=IxQ#_}yaG&_sp-wi(YYmE=9b zq5#Qrz2xq;)zVDm)-gm>Na=6*D%Ai~52-$SU_!s}Z{ANCi@p#sPB6MVZ8hV72Lh ze%W%%`u8miYky&km}!$NT?rXqX(X$ETNVV1^Gz$Eyj$-IK!ore)6Q-JSmaL=MekF_ zd|;XA0`q_6y2)bhKydj2lnl>-#OrZqOgL<+hV6N+j=3 zfvlLp$K@MHpHcE&j@D>8wRt{m^*mgPvn(XAEufCf!%}1!Lxa|+Y}Jhkx|yjFs^dBO zWt;Rge6C^*Pww>{bstiNz2EMoz+YJti?)f=@Hd|^lV8f4I*>$6zFK^b@y}6nKS}Qz z=*5n9@^u$L5Fa2kP`BitvO2TKMTgDBPKP9~WW<*A4 z9kzj;P8=mC%cw^_M1{~l1M+%UBMbxzLkF8W_aWV{aq6_Odf$gKR{&|r>?~w)QYC9y z$)K5LSg+0=y=?r47ppH=TbRYX5|3DSfTg^9CREJ6&yM}KhG!MUcIjd?RkJRPmE>*W za})kG<@Iqv99) zC5xA;&ix+FMy-zszOO@_>?6(!EF6*KZm^rf_t>+o_c0nC^UF8=bdq~@n#h~#K+njc zbh#;G-a2T8BukZI%nVyI$PU|m-CdPCgquFb_TWsLx*n0A3(w#GsC7LD5k8)T<-V2J ztH@_7SgWPehRxIC$!zH~w7kQ*jOwtI@BAomuV{w%wghDlJ6C;qm58;w>O4xnGeWW*zr@!6W1 zVCtzJTmgr9s*$CJPcYu6VJHZ-c-RlcCRGcPR?5~)gljuT_{G6T;1rxOuQrRZ$6qCM z9q1bH)Qyb{ra4<}@ql&9RHklO>^B_ZODLeOh0$BbMNEFlvodE{7YzxbYm_(3mH&ah zua+x&{v#xP|2I+Yy2U3wW}+QK?ZBgx32!zL3()D(71oN@wltlxC!7BtsV}0w6xjJ@ zv3)*>cQ2Z5LLE1nP9G|^OSkA2$pwI1bGu3yYt4=Mo9*ukn2w{5o5_v-Fx^K+pr12a zSbHGl&6yjJw-4|)PqB%aR8Me<^vqsx3!I~;h%wPju--rz*{gQ{lvKj`A~fuLa126)ELEbPs`Yf1|-xzGkLnnS%= zK$RM5H`m^}8tjqD^qDdi=6>Hr4F}}EelL=K^nVGJ`xtxKx(W+<|Gx47M51Gy@+wfZ&mGl%)Z6>0)&pB-O3-A@HGZ%&tNoOp?x-GR!BbD0Gb?m>p4QVir6 zg#MkwA-dVKsEMH8pK&`xRpST=tvPTWQHkzV4f4J}(!sr0NcK=69N7|-*~5qihKsUQ z49wyB&`PLinqcA-$;K8s=qEY1+fXLd#ZG2X_;_OHNmIoXYi%(?txcr{UDc*&xor_p zRF0B2`&-JFjMKVm=a9u7GBbdAvl1N7L#%_53z`BfNW>yeWT|p5i;HlBp3ZK=!Hn1v5tV9I?2J)>NTO?~=1S?d48y{#h!*9F7hzhhDyhUm*1I zmq!63u!^wHbxC$HS6~@QlDrvM)O+CbAQHlXe%^nrk=J36oS3Lrc&m>fNLM1!p!Vf57B#zIr}fw0cEDOgYfo$~*5IrYdZmJGO?4f9Y6#fx7t$?r_i__BDwj8i|*1JsThcj)p?c9W}KOv@0YdA(OqzY&U? z!e}@Q0s*On*9%_oqMw%X7p?I$Hw&hF?C7NN^3k6xsYNHq1;2XP)ZsUz4Wv$BHJHQy z*-v!6ud_58A#!pF)l~7)_q6EztFu&Vqz=sz3^qZG#4$H6pzg6?T7 z-DXZ;XxKq~`W6l5biNX))z@Toj;}g9XR%og=447e-!Z}m{_TIt6lUTQlPty+OW0Ur ziw{(UpfjSyp&yTvs`KJA&WFBP}6>>d~6$NwlTFyn{>0*5no1) zrvz&9#(1prIWe27@bc3ZXHuMkB*JAcDP(|p9(!IJnAaLep0p`Ve15~PoJyA?O=J7M zfcc29@k%v6aQ6?9?$bQ#WeVXKFrQk|L7v~#Ld!PtWAh*A#U6dgiY=-|3U>}w z0n|!5qj(uNaDP6h%uY`uHS#*315SD*Igb&?s^TXlVLtt(j6%aCv#3I=`-hht^8`_zxz1!n}l(6P>dB{WE->`vVMc^ zw0ER^B0-y*_GXcfowbKvrIIWgosozYalB9O``iskhZ8if0&8eL$PybPQo)Pw}YS>WLaHJ?i3t~5^rg>Rm0HQ zNY&@p&2Vk5Chgm3^$kwNU8DMR=3(OsQhy9A4J}4BZ(y(MjPje7b@}aVpE2TFy1R_c ze97C1BMhIw56VWp?}OWzo3-LiXZHQYsB)9868JZXyk;XYgz)$kX3^cU!9zTsqwu}1C;zuFP$vh~SQ~1n{t{`}Cf<0NNCs~q>yBRi zAf?zhr-B!m9AytU+hqZ5P(K>D)l308*(5vSTP|$2pLpb-iiPG9?`y@O+lehk5#ymB z#;cK=`$FK1!9jAeJq27U#&?MoJ|l?XXzibwDb%lH#QC|>&m;dQV+)P@IgK_?m`R(I zDUE2dCu}_aJGo`{zIf2lXUIvkzH|9%nl;{FJP^(|Tp2BhZF96|SNsGs?L^3GD)iH3 z0NJIfB$Y?3{l@aYr@Ln&|8Vi8ky&6j0ri>zE9fAj=8kfD#67fj+Q_e>{Vffbo%pvf z<`ri-^SYPZ0g+|<$ubPJeJ@hU7O&M(fzY38RE889YmAKi%-GH)A)eTS?Hs>m)=ooe z-l}ZL+e=E}4Op0W4W#~Dp&8N3g0o-P@d~dVIBL8KI_AP@JR>Sz$ErDt-|B;xUbG8Q z?eQ97Uy$NIS#k58^X7V0kcTe-y<&lc{RQQ|XUO{yi`#5WlLA)^C=0G~) zZManL25S0!h!ti&#B`m#f?X5uf!xwlUg;d<#25>bjF5mT{;rUEvwKLmj8SCu1iAN= z0U`j6;~)#40d}G3aCZj}Eu~?>{K||0C2Vvui8#R3a81fuVZ{!;r-RL8!aX-)vcEKE z#8`9PR*@AVqOz#uBqC=U@y)*yaauBN%PhJjl=Ne*PMJoZcA!i=D7{fKr-@o&mI?iQ zZNvbp%+_2{@?eIvEvusj&2=CRe*~kg7K(i$`}EPRwk+zx8mdNbzH~23@l>SkilAmm zzmwDL9n=(jMInW(t+@@zb1omHw(gB54!*#u`ceVtJd5SC540)%P9)DCyCt^p;&ykK z%2v7Cs;qQ>=2LBR2&eShxXW-Qxqp8+xzpzVtrj8h2tbNH0K~D@Y9ip#^r9!^bgrpf z(`ze_?dkq@lpjb2Zv5G}h-J7Uh_!y!Wa>L;mp&KO%^YA|>bfnyv&gH>1l zHGzH}W(hhg;Sa`eOp>E0c2zCE@GblDdf24`nb(F*@4knJ9s47+aQah4ate(2hBF$k02JrkgJa`8A-$fOBSlTjg>U1d8<<6GBd>AfG7RGG6&q#_^e*Pf&B2>78 zCDzzr%EdohlD23P$V~r@E;dKQZ!(Gx=#?i6{id-RT>E)4wn*(z%XLhXJH>#L02iq?xd2!NDW@;f{Yz(Vv-p!ooig zI8N^Oca`Re6futW^5|ud=B|;~1GqdX-!QYnizS3dpEG!k7Wz5@-zuROJX zNrBzZgeRAs)K8x^%0WIGRn!}nBCBAR2dv}0qWb7W)W-V-!|E5K$%u0yTJj6@3;}31 zPrTGI8~Kni4*bARnnLxyj!_?)KUEen)zl1D1{Z2?1_`^+h>>{g^JBL za?;P(X?LLjas<<*1Q<60e1btY{)7OnRii+ zni?u=&ZP4`sh($!rnO_7bRRFp6Rnx}nN-SEKU`x3Pa-%3zec zj55n625iNNV=&>g0jOfjD6h0yJ*x!9?fxL3HIN-OFqB(>K>t)E()J$9yAXf!S2pSs zy$snqg&k);$V!)4%OXd4-Q`*^w|4&V?mIVqTc{@seCXGyQYNVHb1X`qh?1&6m%#vS z+VVh9Xkh^PG)nAO6JNGP3@6si=A}YsTSX-Dxz>$x*-%IZ-K;cA7bjMrOY^G59y%-M z0GY=lFx_7}3q+gm$J0lABHXMMwO+EyL3>*N(&slv$RD8>$Ui#_GsnD1qn7x8qyomP7m)m_0Gnz>y#o;wM(Uf;}2FnFl3s`a%;~eLEm& zd~(o@;?1XrzK2Ni&tm#7IE4o3sMYi#q~hvH>-yGqD6R{(@_{c8Kp>5MXUh*$bsNY3 zf^l5~Yu>y;#y>rH4!|dfoYKD;dFp63ePO*+^)WirqG+Hcb!AIzD6qMd4vqaWPam{{xi6uy2Tdm*wRUnJ*@l~BFHqk74DY{e_ zjf1*?(`?CZ3+nZ4Lhyx{ws|f&+eDE$RyO)Hq)UHc8oq2&EPQj!>qTC8XnrMr^aOU( z4j#xNA95yYB*qOP^wX!=^!7=8(0J%9vOljYVBmMb&OZ7OPe5y?AIFaYH9L<5*4RzK@r#RJztc zzMnBpp(XIQS!=xiV%D1tFp}nvpgl5i?`f4=BrL?QLvIgYpZC7QcH2-N$5Ncl#C|?J zKbU?z&4)!HlOkfk=_LmbW1`kN)c@CBcC;9~q8s8=tBHfn;@%=v?%hR^pUghMPCrXX zeaBh!8*B3|>%p_moppIK^y5%J+I7@UE&ju{^7w;vImou|0u*HYGhPYv_*7WI9J1T1 z7R$INd2;?941Q@)=YKr5tDy~lh#uSRh&4F zi(3p3k4Ms^5^ja{aky?WbQ$zRO@4<++6=V*(exex1@MfKW`^>XiL&Gu4)mjdkK~Jz zK0FlQy64&bgOHP3-N=7L#N7{sAG;`*Q{Kl{92l+r?E*6M5p8yiz~{z_0s~ZgbD^{q zP&FOiVXH>>r2~xS$^MW}{B037(C!6z&vunXFOic6xQI}I{1i{K0Fm^Txb<4PV7xkESU*})k@a&`2Ksrsw3ry z&UKqa`XnbGuA^5od&Z9-uNt#~VXJH@yUsHa>8Y38N%zBfYvQ4Bw;?2Us)NwqnXULJ zkiTyMfA{^y^|zr#G&nH5Uc+%04Iuh+lj}95Ree8as8atOF&I8Grc_Yv* z1Ep{fDOxXTz<+%mryGXo(lH_O=Uoo+E~IQ@J}evFNPBT7h?XurHVL~4@66|U1j1qS z?{4kqYl1(sRfWgFm-;k*i?MkwI4FJoxauN)YxD)!ZT`Xp$ooGDk23qX4aK0(9Of8@l^q)=|d)lecMALsu0B;JMA*7&D8w=2!FkLzgG5@Za5idZWwT7*b8WWNZXk$WO$`CH z#rNR5BQ+#9Hv5riZY^=~R5oN8>x+H!`T*VH-5cu5h3md-<29cDWt1+lm6iRmm-kw0 zbDx>kE(54(G0~^?@?D+Y+wW3U(hEGwuSU?#H6e(l&<(S8qxNvAMT41Sw}fzfah3E! zKQtXNYIzHl8}yp%tcKIb1USMTij=q`c{kF0}+=*M!9Nfb64rQ->AIc z1kYW9)3=#GSQBT?mH|}J_IN0gM{=L5U!#th$`3)Cl z^AC`d6FoTeXm@fZ+nNPG|3uuLM=kl3L^=wD(%N1JwE`{L1sp!7cv`>J(g42Mvv@Nx zGgv!yN(7RQ#Qyt27~6FIZ@U)|=wn&CqBiH4uFjydd@LJswS)gDzKsX@Q6C*5#_6s7 zM`gMRxs{`a7oWTf+f?zG7D5%fnTm(5 z+TUi>a>o>E2iTysgwS3L*&TtQ{F1pp8iQ^Of zaTF(w&RP3^ndK4_BEL+7onek4k?EuAoe*z-$wJO0qS#06tygZxJ;b_yu@(<~LF}Y$ z=DW zlq>56F2BJ59msuBumfQqg13W;Os_`u29WQCd8(}@#6aIfcf4r4Sc5|u8>!}H3 z27P-}DjxcB_3EwU8R9nH&T?1P=0hh3;Odj%_~PDSwri9j`^x5FPT<-e+dgMKy3xn9 zG_~eFWPvbu2jW*6J~Pi5Zl-72%eX2L5QADggS>0Ri(e|Es z8r@}Sc5(yxqH5~c?PlWlO3AuJ@j^4AC62nQ4>(W~-(^Y*6X5idoOyK;<1rM?MS(%pP!iRs4pE9V1b@|iJY(?o>aIc=`e zHuK0pqI4YJzh77<|BRlqq#yFsp^qNwIDQ>G08;WQ6O>1D>sq9!@NNkE%A<5BHWc2F z7bt%iK6NTLeUxzks+D_4=+n{kZd=mR{sXq>s8q_1imb#0VbmW;NN-^fovbY7bR}jF z6PA&+P^u#{ZY-FtsHhmy0yV9`|0e3xb683Wf+;$tteO7F^t|TWOWT%^11)!$t-j{qU z>wb~d?m>QF^=$L>_oKC8dsE2|KBXSq@=`%r=@LY9X1lf5Y(diBn29VH_Sq>}s80-- zi0uvMlKPg^JG;cIjnY20^Gvt6yN~33mZ;p?1iERiQDP)wQRmK8TjJ=`85Bn)@4%D`pIbW zMTWPYSP&^8-W?#nEOexg*%2E+e0s0I?}CHtM1Z3fS|u{V&JLo#&9QZk;wStH)`u{? zn5!)ROJBgPd)Qb$w#8Atm?aCcE`7zfIJ-@_tJTss1$-$g$ofK>X}Z!yt64?qK@);h zVSgQFZl2_auX5InlGF1}$I|Qi;-T8Lecb93#QuZ{!_mKw9bgKk+=ZT?JO zFi0i~h^o|Lr74VI*E5?+lh`Be4R8Csm)D9T>1U|{ce3@^deTX zi>e=jLpA1l5{jd$7|vait`Pd80d@Ek;W&fJYO^Je1RJXN>x?UuR(`(1!iB)mG7PkNmVarkem(eATtfVx8J*@h4_=;wj7bAQIS((Eh1cJs?p2Y%&?MGyi zUi1=Ah{vF$b`J8sz07D2Jokts;Kyw&r_2iA_x)tt#*HKUaZ`=Uf`!xaVX%7VmMx5l zLDCy+Y*DS$k|hoO_{fqDLdbzr$M6%0fFZAO1EssehJwsl~kn?|2n|Z z3an->d(Udm!Nh)!EBM!RVv9GmFW68n0olC|Jwv@|d?IdiA$k6E2svL!ZF*2CHhqOz zJQf4k`93o5>LAC4MIurrZF!feX;wOet;>U2Tu9O&yQ<>xY>Sv)JDxeO_fQ?@V6O5-vQ zI3VV5(@ld)KO*yPVJ35xS1gz=3(7@}CkD;yt1^XkY3%ei-8TA^O9ys%lx(}$qW(Q< zeai)I{P>(%xDy37HT&5T9#I^$rABU{$>Dezj}azWxg)PUN=Nrw`VE4qOfI`90QR5V z-CpTNuaHX4EGLR45eE$qA8Iq3ik*r5P7Y}^$tuM?v_umOm|e?`N@b_fr0+<_5w`1D z;L7s4jXT|tTFkLU=z6!Xuhe&u2-an*>exkyi4^& zK+-VWjhQqLG0*MpXcniXL1}K-o=|3T!l#dr+dj1Wka)&il}Q%<(cH^-$TE5hx?4)4 zt|q994xRTF7gm3QepIrA7e^RZ9TV7Bcz*!zwr^07J{k;&c1&Qz{tzAaWzGv%Hsk{; z6Y=e!WH+B~`H!5ILf)B(eSymkD)lp`wE5B>e}ko=wIdPwSe$okh_&p^IK4o>Sxe#$ z;^y`Hk$LA|Je!SO<+EKT4GAtu;t{uhx1xd3T*c2vZgwM<@_d>nW&X0(^svg}t-ZE& zvC`Fi*)Kco^m&xe(lu+=OD)j2FV%b-ea4T!5bMYueFZI)dwb~2Tv^j~jXtQx1GadE zGzms5H8_xO z38XIKG!)y@Ka9rc*j90n!1D&waZbuUQbgpmG-EtsGH!qDG^siw-hKWg;kZZ|$b(WF z2K17&nXJ#V*3;Z<+J6r1q9!k|Cj%Xz$QS7MmH17bD(a1@W<#IQ%7d{9*@6`kh$6CL*Sfk=6pVpza0W0#kdE^s05`YldI%Lka7lk3mUbGu z`AhlR&r%n0c?KEgp-taFrEJe5(R1Qk2}+9?;@j!?K<4Lcs+1)!@3EIBdx-Hgc(`#xxRy_XEDnkmj`nsPVN(#q54x`Jr#H`u>o_dP3oJ#H-WNUXWpyh$3|1n)6kYrH;3)IdQ6Uwkx$jf!Ve(!L{dI0}u z{8)Obk!s&4^$X}y<2{uHLQZ8JU$F}Ic_+RbkVRYM+L8#Pj6^d3aa5;`@Y3yArR+{o zfw~WKn2eh|8DtAr;bEzW%T_e`FpYdDX6;Oh;8~OviHsbR$d+I6Ba%eP5c1&-@B0>I zSOgqLL*QI2DtlrO9pSEwYD1h5YR7sd*}6cov`!rAQB6)e7?0=p^V}POZ$SW9A6r*I z-BTn94$$`|tR^8OyKN%sCbx-PHf2wXr+ok06N@|Wf#314r@Ook(j*!xF4$^k*0qz{ zH<;G{L0!5GSW#n%j5Dc7JGfBhfXnqL{PRQ`6Ld&+bPWF}0g69}@Du@oa9ce6aWu96 z2Ei>hk0w3frW#S80RWfz{^6xR6Utn>4CPO`k?weu%N(xCBmvIzla!>v881l34J_)V zf_RW`sVV*9D>v11lGia64YV)uDOGx$hQ_B;5h1eSldwiAh@6boq|#_jtp}P>6-dgV zm#s>!6;-^|r=}8kEU=PFG*2#Bcg_}edkqU_ZN$$dU_a3x4>g>?Wu}Vfb`G~7AkX~7 zO1}Sx;VdODC($~-Rw1Ew>?U4+CQevN9M0om1Amwe%TfP1Eo|9gS9v+NUddQi%}XMO zrG3JrOUjxoDA@`5r{EaKtvR_jslZ)$I-?$M`OPax7&ndy5`Kz!Xz`S6W{Qa6QpfnQ zF%j*VD_Poh56-(P$xC&|@t1kRVFKu*|38wJ8G#GSvpUD= zToLLJDw`S2uZI{-%&f1~TWFIPx5yPoD$$a(Y+#p~8HhwR61>x3ZWK!`X(KWpJ+4NA zckL2rqa5j$ImA-?vslUQFUZ?>f1#%Pf5E1Ecc3#4Y{!|^@6$jiWX^cq`rD?i%U1Yh zeK-1~cAx|OWdX%p`N>HlH9l;cIp0W|!jsyLQYgpCCm1LyuIKKwP@TSxsGsOHj^WI` zQ$g;5WlP7)0!*}T=0wbZ6w6ze(lP9a8-U9S3mdL*zDiU*o+GGFfd&hGKy>Dbk1oC2 z&$apiU%tTZkxOm~mHrT+W(xSjh)=rMbPMj!C2}98(Z}<9N#<^CL*j`C(?w?i+Z`RLF;v++9xHoI<7WsR(b` z+I^hN0V}zkncr;Y+9G^n^)Vjwl52_wM8)oy$swi5HRTl@ zbGKaiWI)>ieEtpdETAcWKU>TqA3nTj7wARp_bzb^zg$RY_}KP2K?8?u5?7J zh(3O?l6+$(%kU_DJ3Qp@Dfmz`7&zm*mr~|jE7Bh+y8|n>`FhHYMnx8@o{!0*Gd*R0 z7-fCkY(jEKxlx{O# z-8b+91#gwN_LAMB5psj@P>J{zn-GqbKhA+OZ}R1~lVm4;I7rI_H}-So1@YVANWiL0 z(L+T?kh7lp(!ExS53tN=AyjZh(mNp&JqK#wTmBIGDH3V$a%MTK$b~H}wF|aH$uqAj z!`3sczw-PaSb8lMevOA`_#MOYAB@0DGNX9-jHW|tvhyQAFF5qw;`&}+Rx~hnP#(|LSr)Fhw_0**{Zz) z@L|>!i`N)N{ycy2JbJ64c{wysAFCM+d6!?GbkMvDUzhd)4#=gM=gBq4=d@q-C=A?W zap*F5yR?{wIp|-2ZgF{NNruGxeHv{vTK4zu$xZ=RU`2=5(^uJ8s5=3;q(QA|mpdT1h|K2Vnr#kU>#Rk(#14{o~BgwOk#ygdT&K2ahWc*1L)Lys*yPO%p z6vil^hJcBT*i!g-KAha%k6H!yivk6E@)j#wEOlkB)IOKeQRwAD#^syCY^&?TaMG+! zs6AAY*gV2yP1J7Ccci&%sZ5dfx)G%`Fp>VPvM?f0gQ*z1-W~s3gx!UyEIO5p`jJh2 zwV|Fbia3q*R|_7WIGIZ{eX>UI;KOkPaS zHmqOA>h9`*+m~N$ssN;NF({bU1ke@S5cz#QwmV=j?v&(kN|z@ffFV=CD(+$>5tzw> z>)0C(GUvsJ*mvgazdSS1s7zp~-%9mJ=&*RY$J$4_y#EEjxC|M}oBgz9p%iC3@nY*e z*zn!%rMJYs?*IX|-Am%ojOV5<12bFk#TjjwlUTyOjO9LjhuO1;)}4~~cf`h)PHNL0 zPI?X0Cmpw%I(%|2A0gN1n-K95_O(Iy$bSTHO%{|V6X!n{J1t!z4(%s%g#o(hlOj6w z6psTY{MwN}6A5T0lP8LQg^*J?ipPHLUp%olYcOGP0=q_q-;5hVKQL<9u7)iS= zb}mtz;{>3UrFr+6vA>+*xgmttL(ccz8&q%npc!G}Zxg0soo}ki(X*(CK2zzcerB|J z1tJ_b8}YnrB;P*E#Lqcp^{HCuw`-ID{#jMIGd#kKf767py`Awa%(y z&y6S6#ZSgwEg|+>Q>Qg<G@Rzi`q!vwXYQ4>VZoTNl6E8a#p#g)0p8ZWo(jW z!RvanN!I<|c(Ac0;YDNEguKS3&{qQ6bD871(;$1bAb&jwqmOwP~>`%(RiJEX?rm8);AFTa34N?4leSBf4Y09 zQqotVu04m59yxxi5wFolZ8SYYt!cV>>BRn}5v|88>z^{?ta;`B)@1`Kb4`J1*;CL7 zo2FNPyH8a3K?;AKwpps$XPv(3k0(8OgjjLz5#By#kX5c12jZ&%i82p!=3^0#yzw%M5ga4 zYv89Zww0HEG(}~}1$vc?s-cXxc>bix*y5Mj%w^{u^Z1GMIDY^eUk}e`QIX#E>T8Vh z!kxglJRqo7|387arHv=wuH(s{+LoCuUJ}RE9GPa6p89Api^`cptT-k4<~Ma5mhlm{ z-$LA&B=!wcP7lt)Y9RRBn(4IBSWo$(9FAX%-t3cv;mUsUZ6F#TCr@3tN;3Zw6_XVH93qG~EXVFOhOTP}i*<*>>dS#E8UhQy0 z_%lu{k3`BPB1O5WnleUie)xc9m}io=uK*R^j!I(OfOtTBG0J>ImEwdJAMY}bTm&bc z!jI*d*I!`GGsdDY<<R^*nkTS0bdM?ZMNX_sl!S(g@G4)TW$i5K z)eZ;U&gW0Su_KKEpCYJFyX%13|v@lWzpzb<6Lkz&U^CSZEh|yK3m!YE5#9o^u zi#W#+5`)a#C#kd^T6&9nMFW(|<#|?KE)PV3JHCsw&Jt<;HK_N1Duux)dIH94f9A`n@Ns{$lmSvZPUcRCjKaS0!el)DEntpFNf^=+`!eI{EShmO` z*s5QOHvFK#JK6sNQRc>BYIZ6Lo8o zDEB*~RFIlr{aDZsf#@cCPqwQ(x>FhE#CY6%_m1!Vpb1p+A%g{D__^f2h>$MlQk&m& zkjq5covG9*2ck>V@LxZwvDVr4x$@|oIb`(<_|ij3iBkD7*liV^us!SDo0ectKrm%gaF>SET zCB|CmvuBX$ZMbB;n7z^i$pAV293hJG+_dgyCV==bhPZeL5KX2M|4ecw9}BgS^C<5Y z;)^Sb(lWu#yUf9&?oJ{@cqmf>)go4>SF@uo5svfrHA`l^8)jXJOk}*= zr21{GK6PKuIn4~`u_bNJ+L-{%6GwO^XQ3ru#c%IrF*b7_Vgmiq(yQIRy6F!d__l_`a2hqT#XtaYG_H^t!V6Pi;1^Za?G31XMDB8M1>3f@II0Vp~W47jEc7lh} z#1N@<=;OvlpfOkB@{a@m{rE=mTI%lGF9Y+~_r#auSIJj%PD0>p2K$_oJoz~r2>{%6 z$E=89#vW-V^YfyJ<8TwnSzERPeRbAdeTx5l6tSWtq~edTg3?Rh_{Nrcy_)=1Bizneg(iJatUY=!*g_M~@~iU+ zfAJM0RiCj(=I7twKB08BN5$6R{czb|CO~ks`#=_Y3+lDK&7 zY|bO|!lEDIlIP%+blShK-U2Z3233tARI>#DH7&1I;u$M!8!Lr@a;-0_)suU0^jT;! zNmt7wAwTA@5f%)BoKvzcvV2Uq>6$o*^GrKSh47??l@(#J&G{-caq?1J|6zaz9}wwn;kI5vM9nHfLjL zMi6_Y*)kOT&&<&w*z!P<86J;y7Jeu9vs0vQgEqQ1M1cE9MD_Ow_G@8J21(NrR zH8{APm6rvuplD(QA zp*#rpoCDRo3NYc@Wv1gp6zoLkGpFmgOQf$kfgzTPpmCn=RoDU#S-6|Vo#As(QdMV* z1p%zkWLtM&l|SN+-TVYC&b%Rq+qw8!aX_(n;~+5=THAu-+nGt+lrjOKZI;5F2>?SX@DTBCWVKl1V&+ym#$dji| zbdbO94w2&7U;en{?zT+x)LL2q?D}l#7^{%H?MTJJMDk=Jbc}eNC%JSUwvJhkhpIv( zPb|^!rhzU_`h%8iis}OKRC56_+s4be*P{L_L%^Pdo8%*}474l3OF;n^HEV<^Jf^yN zRu0wvVkd6|kT7TnYUIEl&T;&|8blXNQe{lK1fJ2O<3MpEKs&elDtW5Ljd(m>-Ts(i zG{TI13&%7KF*U`ISEeY&9x9*q-B(x5*td;%05tbwwJ~#7OFPg=Gu7wQ$FR^lR^;)& zm?y#iE(h`n z9UN!X#g++W6ZGpIu)Uv;#q!IGp{w5_BlaP+-anbH!ANrIC&=egWMms)@!WbC1lino zMgsfi#5a#h|31mLZ{mER)PA3_He}xk@mr_WX*6tol&K?$tVY zv7IVx9;4`cuc_Zew*N0-o#%k)5c~2>_T|uiq%o^^lwT3_HQ5~Q&_X-b|Bs_HkBe#l z|M*$voT+A$_FY1>@1;dEy2`awwxrEusX;OrHME^Gqp}tE+Ts@HUf0#NHQX=~4oQd{ z*Vawy*awv%QmX0q`Tiac|0*7H=A83+zhAHC6Kd!;lQ+A_nnzdrBDNWLw;eYy6mW<@ z{(INO!{7)3H1m?C)2j0PVV=jb$z%gXHJ+w+x6=z3q6?p?uiFMB^@{+g_)@UAX;KkZ z-gQP*?ueJz$aA)k;5rnwHw%-DI38hB3N`_J?sHM?mK|8)q9M*r8`)29ovLGu>O9R` zC7=WUcRDBNt)%II%67viviC4G$Q754Cv8XUse;+`o!;T6-}#h@QEiz?ZO$8ajTw4y zA5@l2CRnL0F?C6*!D*-z~NHe zPdu{(2Fnj%JiC_Z%K#(}PHoOBkvssIFByTn0xURhU4+t2oCPTqcI_^Wh+fAs2TbnL zH(xlhI+tqyuiQi<)y_z~%E+YsEk6`DnSYx6%dJp-{trJ@%NHp7CsgQ6lsuF43}TgM zU*qL}u0vxyIE4GHH{`LGq+3KRP&`Vbc5p*B!54QHgX-kJCT)?zgRi)&YtU2fFVf-E zcDy|p&JvR?mIGgV1oC_LMEW|QHJ!&y%BQdz>bI{Ia) z{$Z$0##wjD(_f9tr$ttqf<$>O`7b65H4iAeW^(u0)oWJ78946#o+Z#xNt$${(6*RG zGBVfOE29&jTA(#U$qpBTg-s+JcFr)@b&)fcj%hL$4)6<|+u3$*C6R_qJGb2ekr3a-=}`h(O>MNr(%ln-9_vY<7{>)SoZ1M z7|mXxt-*k0y|@fpM!UuxLShcppA3-?TZi>O@nMQRsc8<>^yS>swZkS^;Tm7LZ$9ER z!;F*t0&-Y-yML!yYaQlw8u2N(@kjL{0OK9RI>3~V0@d!BrSmWws2gkm(tq?K&APw~pdQHgiyfoO&S z_Q56}t=fgn(oxg$s74>^cS#2O#5$IG)=F>%BY1WveCj5*JBnL1 z5etRTM`7t$-(Ql3_0%eb1hbRX_*MUlEC>Q7n>beP%9C4vcb9WYM2QcGo~{wW$qMo1 zb`kA7kFgorM$da$NR;!jaw8%(Y>+#D1Xf;qD3b1+W~@yuGXq8F*>m!-o~mKa|ERL| z*NyF$42rt0$q5tiNU&G*MF4%NSK4<>WYwMsIZ)K46S z@RI*>_4TZXO`IuDo@?Onz;Y@`SUQF5aBgd+F*;q{>40=4893Nd26~ENY$$`I6oJjCR+My&vc_ zFa=5%gf4bejKJ0JK6C4HU}e%2pI7ARdvD;D_bRVqcs38@Sj(@yEAv--l_8!LNOmfx zssQ%b(t$4gPi?#TBz<#|E+i|1oy?({r;2&3n45YzfAD|YlatN7@Hkj;&rA2@;wn1Y zQr1iv`4ss=rP~aU|L<=4uhSUDUY2PryJW8WfiLo%rr+n~EUnwW01oOWGS8}Qf1|+9 zejU!Vp*f8GIG-z@I*X8wZSKO*6L3ZRRV433&Ed;v-}y)+ZX@a?K~KjGprK>!TB$vp z(-nBxdA-kPpL*o2JItns(nlZg+3q5G5}&!A7=L7;N#gB%xMPLhM0pdEUD@iSbQ|yO zlPzxOtfU^_r}6PV2mXK7Yx|kn&6T)VP&XHE+!&$0^qUJRn^D4(x$6E5^J3c^n1V6a z>2$*d8ml^X|Il*i-b{7h@9KX?=_m)5r1_NR9O@T8Ft_7VtN&zqiQrq{nxeX6#SGhK z(dQz5rI%KNoe|MufE-4njxT<|JDk`@07$kXBRWTa8jXjI>(alvXx{a`w|i~0Du;T8 z5gWTAsrIg#T_?n5WCFYfaKX<&t_ZTyR*oAbGWf^H~ zz?&lJeM^N{D1U4MRJICO;TUG;GaI$q1}#*hG4{j}Un;6Z>@dNZT>&h1e!H-M7=Bi< zs%1ZP>R-HUDv`bTRR-!g_wDk2qq~P^(IuhPpE;q?c8V#(-t3i)*&sHm?@L4{?KDORT(x@$Ngwz5;5+Ecs;otC?(Ew@4Y#1%6q7ZW`O;k|14UwWs3% zI8QDsz{@KPnWK;r3p=^OIN%g7)U4Q{wc-U-uKNPpU7}ArF)K#Qe$eeVx zlaG7rsFxoR(JjS))Q{DdvJv61DTwt4WDvG})Y9*bWM&Kzs^Y!%<{pwMx5J9E z$-&C6#vym$ETua7vUq9~C z_f!Zb+)cjSBDQ!aV%uOqu4Sgoi2u0DE~FR=wc*!37S&$f&edvg#g6gS@!0CTrJUy* zjk;!QV9|c)oSS5Dfuzacr|R*>yF0lpO~m(ZRkjx@OeHOk6K}Id;OCr`5o?jWkP*^G zr059M?UOM31asKR(cpIKBG9L0#Y;)IY0OmX_~zaRyItvd@23Ed>U}QvRJMVaBH@Qt z@gMa{QLjYKxs^r3$f**p*H^^B*u*1i1RVfq^l{Zb$h~G&`OFOb)Hv*34E%1Rl3f2Y zg>7S5q$P44l50=&?8ttW?=kUM zKdRf`*(upXJX=K^*lVG5og|AjR?M^Yms?EH&9zSlRbdgay#%04uTz5X^9Oj^3htx$ zjd&)nu64&OFS&9i#lkmxG3}~?-zfDW}#H`BJp;(2+CU^rm}WMzYmr)oUBCVeRAa zdJU?GveogyD>i8|R|GK7wFgJn_Pq!OR_ghq&d7=K`>!*hqYWTB92lmHj$psuDPlEa zW#zxwh5Yf^CVzQ=+{8$k(-Zgedtt>; zK=r$?SU^1wyj`2jVlMyKL7PsnWJo*uRnmb9Nw1hb#FuY4KSn;sLT2&~m9Oe}n!A|1 zU?|9diXC+M`9kT^p*QcI(k=^0z-(?fV63RHs75g1LVqNtDKSyJ%F^IppEqKw)QKYH z&8GU$#rl1*Z1-Mzw0&)o-6Nw-BG9fv%ON5*o>LY?{Ph9Ae+|?e`}jBfP?b$B_;VT$ zcueErcRzCFBLm*jH{V}H>URj(E$kZUw3{$LnVC_@{L;}?NjGbW@nfsGLfd`A!W647 z4%*~W)Ab0)Bp)>FxL zl8+*>`;EzxXF24t$G*t(yGC`NMT%rZ!(yjaNb!BYP=j$|3*YJltc)PeJF4HdN`kHY zkkW15N<& zOFXFcKO$ly^W;3xADj96oEA5gsLv0tg`0W$i<9ViP!aTM&|7yaT{@m~+`0%!?ir%% z!M@2jU)X*@7~15d@G(X8;X06rN{fmbH$~+}N_+?}vI~`bY9dxgg;~ROlYlpsIwSPEi?QN9j z;alC*H;ZjE<^uaNaw3M6WYRaSWvd0jnj^PNPA)Z^B~QC?(}wve53#z?Qd4F9pdBj% zkg@zLA@V$DC%GpqTg^PS%e5A}>^w-n(nyZbhsnV{$&q5Jcd2;4H5n=h7Z<7iDwJfN zBzo4HzO_(inQ`_t9wuE(D75xZqBJD+^11_XtwEqjFsiOZ%5Zh`EdX|0u=1cAe;u6~ z(?yqz_SZnr?3v`3$S}2>9Yd>XVoQcv9TWLBt5wd z=1pOVPNaLlf28pjr~a21E0{HUE;O313Dr+$5!%WOD9-`hJP&f6wg*oxePGIHW2cTBn-`ymTYe1SIP zbF0R1=Qm&{r4oT4h}kzw+VJY}dd3!GRrb;e%Q#iPh*Hu;wvL-}JTd026V2G41Fn`~6>6*3wD{kn<=L&NyZ>l{VF+ zk(;aocv(WkE^ajPb@;?izKT}Qoq~#(e&f)0P^&awka7bHMGsp&`Uq7m7I_RsLhg?` z=@k_tBjkD=eX(;frCvxxbb8Zf{e@`h+DN#x%Rro`0r$vVZt=p7y$HbXqBpDZ% zy))6TbjKM%dFB6P8&z+io`wP}eABmyx=r)gqcca-b6{rDo?Uqpl_c-C%{I%3^?TNt z{L81#A=FGl{Ooxlk^PXfubq0)C!*66r?8tijA_$VN%CBByg+sXID7A8NTXp-kMP`{ zu?=SI%5MNwvOHaS$bu95fE4aRV&_6j`(5R0&W+K}57i&{lNL1avc^C)J#g%cd~T4k zf)LoltPEHNNuyBs(|;#2>Bo<*TK9`TdJ!l7{g1E+2bm@dX`K~(y1dZ1KF&$e6|CzJ zWw5%tMbhy|(jd|nfvo&`+kFe1H#3W!rx%wt)Q|L``JblfC^yD$8G|jRcyq)jKw)H5 zA?zN;Oj_kcZU@Y;Z6kQ!6|o>SK7=UwdX+2};ZOP~9$2nBV9c;7_00b&>HQ3Dxn;mS zH!WQTz45)r#zMAlVYHM)4^H`kdaNH&TNWeDB1YjNo559N!aD0ry~TTa+YZx;l549Hh_b~D zIgff^mBwtckuDlG4u}I#E5JV40wR>6FpV=7`o&5?K(b6USoy(HDfg2<;)GwuPf9z; z*wbj=k`YzUHK^R6hwQFV_>VC5k)!OnweH4b=0(a?;;lNmUp#L-g(?k5gDBwCm(M)8 z&Oy-?C=Y&|OGS#`oz|;jojExh2FO*%9K-W(kD27jvz-Y$Zphm$Ss15=1MavW_3uRr zd%uaRBe0%d5zp2<dRTW-%2*x}+mY~|}Sgx9N$_w|+mD>+%F zWZ%bLWZ2}mt2k_;p&%3K>4!QhOv2N50mdz3s;fD4RSI?gfM!RYfxlhF%4d9rn=^gc z>Pip&`JYXF*^O>p?W}{4`puyTj`J8Y@hHU-i*3Z;4-t2!#y1()qUEBHbqySQ5j^7 ztzL@Nk-NFtY@woU;(8DLm@!PFIYNsqU`rDU8<#@w`+DK3lZ` zziq1k!jh=T)ZRPPiAh(HHwKuO!KnUOLyxw5^eeZ!h?^RI9ku_1TW;+e4z(O1>_u(J zHO&6s1orb=G9ZsQaTc{3v(iy0?wlDaoMc?-Ws;gj~TL% z{RAz;-8Eb^)Xj3fk4nf#4z0UCX5u)s{Vc%LZQB0}tawU`q*LLlG~70b$W;+3t3~m$$#E-+g7XAI|d;?is@caNqKIfJvUR6Lv|ei3o_ep{oF2?7(J!> z_s?K75TIP(E=$4_X~J?HdES;RzdXdV_aEfhZyZ4DW;(Ra%!Gl(V?hm7JdW}#?Wl2F|fPSV4dDCfMKSQw8#VICgN%X+RZxn(eL9UdW}=&+M~x@84TCcD`bqTjE8 z?-lp?6>jAq;u$~q1+*)_s7Z^&Nkwqqd`Z-%B~;@gTJ<8h`iOC8sJXJu9<8`XLvEw~ z6Gte(>FZ#_2$m%&`Y}`j@A)iwIF@qRQ>4zGj|$JJ-TLF`4Q5x#hDvI{E53#wP-ODO zznTInuzq1zdOdzRIUUV8RRrDlgpR^Yf$>So4s1}2ir@w_g~u@uy)J_}t^iVJgJB6= zHr<~npNh>c_>8;@9YMc;SCw2^L>A^@^?_wptqgQjz)bF>oZmaq>5B`Qax3Xl71nxZ zM3BY$!tT?vS!*xZnNianwehG{JY?4p!6J?fDTyT4{$4!}%*Nq*hxnAu626wZC^pSf z8~rvIl{s67aV& zN0+FL^;Zg4Y@AfGpZ=IqbLbK+|J*hkXDn)|XKz7nw31%o?Kp*5o7OH~x`>ESu<8Hq zsOK-XxeA^5nRQzYByBRDXZ2I8tpKSD*kYwjz#{cuT;o3(B7JtXK&9R9?kC@6*$nQ< zCNg3i5XW2TcUeTUMkZFW;>kKAfc{u;kKQPgrl@0^hJ@{N(8iriIiH5%ZaYT*k*;w%=5@auMTT*-mQ-`}Mq&84@co+&q?PD;uG4|Ngdx ztj5=6;%wyD8?kGzFKqRa{Oem!q!J3>zxjYD;?&(GTRUbNqcl zZTx73r>Bx@B>r{7$~^fT0&s zeTnmn40s9Vuc`kbXe%|&GBy}QNv?V)<-*&ploMgMk38n|1&P@j3EN%WHE1ADq!1ec z@@bi=JRxS2^DCQV|yi>VWboi2lX^U7*#yA|j$Is}YP$)CvoL5*UO!(3#? zF>kuKh|+EjXl=Eon{d=FE}Rau>?F!UqNR(_Ib_B`0L&<*_KN5uw@8oG4-bUzs zs&>*!Y{PU3ILWR!PR-#mrr+6f-t_y032gOvS@Wl*>{e|%_1uGg(6)yDFEE^fTPAMsWb4yJFBFrH~O7wCkVCiKY04K^z8U616W6ganhP` z(1(7cv``#lJ`>LUL-+B6&n@>mzC=r@Rv7+s9|AbWSUI3^Tfv2}*O#~0llztQ11X#1 zhBHgj9i^MnksSQmhS73Pv1#HV!t$g#J85~j@bijMSkEt<@#8>_J0Rvd$E}^*`qE7P z?6Do2KDLWaGnE-}6G}cb-E34KZF2__S%pCZOU8Yp>IElvEf{4+?LYAX88f*bhlo%1K%xq~D)SbU6s*TWp5HJ@DKoZh9SZ-)ET4Md#7Mt7 zl|<6Jog`5P;LV$HfGj&0OyPDi%u(};$)SHR$FpFyG8QZM+5)*(bh2|0pbtYF7{}f< zVt)`f4`F7kiQfr7TJ@UK69j>%weS-1X(k@~ia76YKphxSm&6!)_#juR<|_U+(w#Q3 z1keks(<#fO+&;w=b<%$Tx3BY?7{8nr*`Mj>*(Y(2<}!Em5!`b4{)th`l-%&eaIKqN z?WhE6?WnCbN?kdm*B@}AH&_nQLpOx4|3P9N8lci8oiMM$o1SC`gG1RA_P_uD;+~+l z_4(^IEobF@G3*{BOm47I^nr~1M_1XjP}ys-nX>)F@za*5&K~s4BWpPLfZ6qj#%d+-N9yoG_JL8kO5ryc~@Hy|I%)Y)q| zp3%UtJ0)t-YOjXf$@Inf(kUxMRPOoU zek6Tv6#dI|=9f3rk-3sp3h_cWb!-~i^BwAFH0&j}Z|ByFO#>bu`;)o_t+f9K&fQE{ zS`>0)FOrr?zVOpMgqwu<;g}=;WTWl3QT$@1sYf5bp(c67x35Ew%@NPbE+Sn-RFrgz zx~GR*6#?0Ma=smkgx!UfRFMs7mAMwR`b@q(D_K8G&2fol$0vKx>6?P2(>QIuUqlKq zqIn4gZeB!W5S#W#5}!vPrFi$|Kdl?S{dU3H+=3A7y-IDbARjKK6g-c+SK++BsKA9? zw4dHvdDKq6qs%zqCLZo)ZGD>RZlIh2eAd>6`8zj-j-FioLTI}HS@4{C9@$B_{7m(} zD1u`~cR+T}DRqtkaUbZUqe$R^9AgDuiLGl?v}RCbFX%_ZUMU7}~tqCgk{SBl|OR@Q$pBNazEz z)*}}1>Fuy51YL9psQPO2NP`PhaC1bw4ZkhOB=pcBk@m4gz*%0Xtc$BzhNR9Ev_1Z6 zq0N|Kt}TZYFP*EufM&~LG&S~y@yW;v^8Kram!9&S$cM%|iDM!I=ZVux+TmyFM8OEq zS{ShGk$isp6JFg?xVDdV&@W428s%fw|3t>vpMc|>IaPjx0vXp;zcOF{RiJtJ#YVgQ zt69K^TKN72XP@g`Is^?|Cs{SwfQD^#BC0$JrAJiU*0p;$ZN_bfZgEe#>?NXxl1l2> zR5NOKl;qN=pU8QaQtB!9_ZO`VP_sGMhi0&g`1`=3^MiNzl~*|B9MzL88l*e3 z+-O}k)crfR3RoJ1Sk?9sJ0;J;Uw7xH_*HNSUljU+S4;QU=r{lVFtbHf)6a1b@Z2_o zkJX6r{hM-MA(_XeCMU#;&#KGUV-6pU+6^}Zm67uw{|Z|MoTWFOtD&#kv|b0Iq z?~2b+8x_&)sPVecc^T3ZrM!yCVha=9>rh4&&0G&)HgSYf(N^Qusa$X`ulj7@-U9Le zeOJk*nO}&KJOZejzj>Ro`Dx8|RGm)@C zYwzI!J6ibmet7CuWAL<1x+til)K-dPljZHUiq{_(vTILJ78fXsTh!n`i^!gID7*BB zu}A+^mAg+i&S-+Ys~_Vhjl|sF2@^C;8qN9kujHv&5q{bP^Xx!p2NMZrRhG*TJA!@^ z5R6tYHxB(3blaDXx07EVtvLAKVrk0RUKC)6E$_g2C>ynt*y{;USInJMX8hD#CvaJJ zmo1q8E1q`w4t{0wM=N=wrEUkzq&QT^KnMM~o*+-=_ycX3hQ6C7i4ew0{kJXNQU=!= zy*HB&-YJ^ET;5K99>*>lFC$;CVRNkGtv^G&okjHOsUp&4Oc8n6B;LE!p;g(BcP${J z%f%0;Q!0~yeB9P;7!G}Jnpkm`F!`CaxK0JyQ;k4qc6}=v($$D~6i+7Brvtfr4mB-` z`aJ>!vBPv;7z;2@12L9hb6*Dw9yKH15)6=N4ZPrr*qgY&T#BB01eY`~WhW0FCd-_> z*!PM~5_8rKZTSeR%z1U*3Z0$rI$eBL;lfnbT~M84u? zFC6067x4E)-XI0m687AU#o{AB(`kc)JL$&DbcfwBpD=wE@;|bL^Bl&a`Y;i-mD)H% zu7v$9bXf{U{@F=-Wy9LFOQ6_mej5Ehen#lMOw4O4xHq&Zhx&iUnHO{I=~_P$I-F=+S8Nt?TrUh68hJUu)d#+$$LH`VJCS6tGOiMo3T;0G1^Png&k+xIjW|cm z0PG^haRcL+#i*9VKQ=N!nRF>-vd<#1U;Xq~sKIVN@T3PKZ|>L7;X=2`k?{T3P+&(Z zvD{o)#@CD*z}k4C_CPRL#5W1US2@)GWz>2ENgdT|5^}eh-+rBU&j zZ|GU8`6H?pu>GAdB&h6J2Ddy@ujzcn?LLHfdI8PLSK!z((O+N3&cEx;EVI^3&EWRE zTtuv@5hoW*-Ypu!Tb8RW7fgXVtp508;(fh|)_PWIltVo&Q2eV8mNsGscaHF`xWY0o zJ6X)|8l1Vkk&1<6U(FSvt}^(2E~|;qnLoaoMK{(^s}7S6A@Umg+KDzHwRerPLWt;T zU}9G~0B7AJy-X2@&x3geQCEA#MJ+Ti>+iI%mT*W=65Cfs$#BJfLy(w zuR13Ta$mt%E=pi;J6iXbFTRClWsOld(y2yaBgGpqy3 zjFT!nIF&a!v+c+yN640K>6~&%bH>=0uoY3~GE=BInbP}qiU$_errd*u0h9Xd{bmXr zmuoE*|5?c>Wd4)RBK;PLtyVc~qu2J7?o2~I`NKJ}ByWvm`Jr+0IsLPxE|?+-(5>{g z+ARsAm6tWgReq=vz#pou6;*-N>GyeAe-7cXlZiWX8C4SyC~lucw|rWtuMP}Whsb9@ zk9Kh#jQO_9;n`b1!^6g)|FbuW+AW<{JdSqppx(b+L;oTG)hChb?wq40_P@TZ)0 zo}p%Hj>c>ZKiv5aqvS=@;i|4XHAgrf2v}?45BAxlf}Ia^t5H2hMaB2+Ct2(F<>2&3A(4I+SSI2 z-?=h_rNYG~SU&L=!@%!SB?2A!BQl&D`Q>zL;^M$MpM&q?2zM zCsmnzeVEI-J@lqcwhCHjrXyZgAi-{RAF3`XB0lc40W9qi_32^G^Bv&1F)DG(I>f*0 z>0t`_W~V%b%K+?THQeRv=TB@}Zckysl!b{nkox$$WPK0Sy@2YD9wCdvWG^ga<-6fT zscKXCr;Z}vnF;nqOZy`YaMeeeQ?FH9Aps@@fOwRJlw8}QmpUuJZ?@w7Xlkx zpyrxhq^uD$34!fV6;Q ziL;^?2=mX3mJJGJJL~KI^3!igPRE&?g#U3jO1SdLAq}Ou-eBIY^oJitglWDz12DW{ zd8;1Tz(TLjnajF)IlJa`F z3d1D%M+e<3L+*ViA33t~HC~m)o$)=Kb_@-clU6`&G~Dp9hTgD{o)jT}KESO9^5cHJ zliXaj)5<)q5lxH4`<%+#gv zYQBO4UOb;P(KDqvJ#9@;Xpl{9D%i=yIw&@W$cz$2+PtZbty(0t7C8vuv*56PdGvfo z^89Gk+x?P_#sTY~gP*vk=A?uFGVf&KMPfTHNp>zGEc3~}e|*((Z|n zMN@vY4;clbGX?o0fUR8V$CV#CT)g!#toSh=fQ(#Zq;EA0>YcGmxIhm3gy-w8Iv^Ur`jm86xL-qZ3t>S(Gu#R?@KxK#@a%`j6C6Ed* z3U#zGFZ7@T-RWyk$xeC>6n~8Oh~lokf-I<|3LUB!y5aT@SSb6&Qq;?5IsQ!}u`>Q2 zTTnDBHzqa}iWP)&54q^M$_-km!G`_&0QFm(TVEkz(X}q;wN@Dr_mf&zK5a zMt%HO;!+n$@H!+`+lO)Qq&JzM$adtjy>hCH>~&v+JlJlchh*NoPsH~@JDcNv^~xbq z^3x0>?VE)_-@cVu$jV-AWcRc;41(;(cgrE{$F!fPRY{CPR&x)f!Lvb}M#1#_=HeRb zb8Gr-vgc>)2bNe0#cUC0t|1co)#dZKWtsxuR8t9yQBNu7)Pa6|cZ8+_%f5=2M9OA@ zayT$wo}xCSQQdc_IXf2abOJz@3Uzb=Mt;l;A>ZJ3qrl*?tpExN5+}P#cxe)cg^Wed z-D~6_0p*MZv4!K90|u&b0`)3UvV9epkkxde?gL>Lh?rSOa$y{qn-vL{Bh&9}@zWy< zo3CsV+-YB9Beqoc{ic4qM3T31GKq!g1Iz`Af9WcP!Lnq>XI$Kge>>-e>Z zyPOF!_hM5fM#{bgY3AH8^04mbVAhV2h1c}v+9>h7d1{HNc6zy~j`60WoWy$p(SuXg zvzF*Fg93LE2h3}2hh6mbO6K_oYO)v8A!puirn+ z`ukilAZ8J==Qq4r##uI-W2Lz;ED9Lm0&$JyGs3G;ie#TcmLDIX?_zB@dawibqz3U> zTTap+Lv17rm#EHzAVFB^NwfZ&a?pXXP{c)s#XCFc6h2aQIjjwW0N-CNFJg)n*7<-+gHvwPIu>Y+K64FRhz=|>8Py+*s7Lz`=EkI zHkLG@>P-oEse$A)249*04%HWmi%sREhgHK&cI+4dD-T5F)*uaF3D>6~A$;LFv>NWU z3pxH7HRsYBmu0ZEsLc1@g;JQ~=5aM2t2#FVY{H2TPQ=hd*j=E0;YCZD{!&?fK7%G3 zW>IOQ^`piyQ_lv|+eX)xOvMwcRZn)db34Ww*+P~``8JKp>mRr;MDp~ms(h?LnBp$23^YFu9-SxxX zl;@xHS0md4ui!pgNyBk_dXl{(dpwhwI*FO;HJP2}=C*Pre+iBMIcC=h zd(a~C`Knm9Zp(eAD?as5P=_SyGj*a&GH+KW(c4F@S|V{tr~4vNncFspkfQrS`<1x& zpPZcc;_YHd*pz-^o+mZ)648MjioRpi<@?#6aMNJD`+RS?H~URTMIG?$ZeKL{mrum8 z73)-QpOGI)kb`OaL>Ev0_xf0VC$Scr@s2uY&K5V(e+Mwm5kM$RBZ9a1z7?RJ50mp2 z(SKXTzu_kB=d^ujMkvEAPdG)KL@Z6)_`-- zzC!3Bq>bRrs-f?h(CcAwQ=n>{x0&*VzszB@tiq{w(Q6lhk@y63}H!N?U$ ztBNU|kX_6lblAXTa(PD_dwP64m#-KXqKmHvnaRgZUw~;>e-D%8e+yIl$X|aCmUkeE#YWZhkkC;k^PPE6%=lvR{T91c z=8|zemM|;DTnn6ls4hgxOy7BOhljq05CKuq?hxYAJ8{(#hFl1s5uG)3$Ov8;ig^+R z1Dw{Mv7WR|yp-L2=C|_>2SG_h^@uC+cz18CZjsSV-Y*wuvq$^a-<~+XIdsX zr>E&XPmT~^MC7pUe?{*eT(JwB2@dj@jZSx+JIVz^G!KM3Y(6^aH;1qTV4sr2T=!#s zo)Je{nGvHyA~ik(CY6V|&ube69;d|X3#jgZojsAb$fAfVJQ{&m3MsQ=;?m_ls=j12 z`FHAthpF__fQ@{)cH-fQ%3?qH{H>&@V(S#d3b0}-@zlSr!%69YzdZd*)eAGZ@F&}l zlzvz{!@M<^TT{VZE!n+bJ|}bN0^Ph;Nj6-i=Jkn>d68ZNQ0l`w+{&fg)E+qH*PBqA zC(XC-gg@QJgi+*$XgJwGP1SXmUf@%Md@;74uOI8cxNTzQoH$Hkwz7V!bL`SIqM<{6{Z1hsL;R5X0mnos4|%sq%sVKw55F^J%-zN@Xv*fVc8R7VaMc8(uE`PH zz7lci7}63TEW%~J79!niA6D}`^MB?%nRhQp&x+&&}{;km{)l-Y%N@Z0b& zPKmcvmj4VPLbb|7$~+Mp`(z4u`@9ro$4U*fY0&}K>}{Kn|kZF2%w6Q}D`5%+W$3kNxJ z2&;8Oc_Fso26b_M2Gc%XGflV>zKSKZIRVH#g?fn_DyUWD2*jJgBzylenT(X zFu3z7nS7VvJr(ErK&9u!O@8X=QZ4Bc4R|zHkW#ZEWLU8B+dpWYPYN}8etePv4gJ$d zs~eT5)j;2yRM8#)Vjo4f_{)s|!C}8ixZEi5Hc>)KF1Vo$!sLEA^qV_+yb+&c^cR0s4=X{E|39URz z3P-f-K6;_LT5a+LM}NZ7)C9IVY2bb+>h1BDe=;QFQ?kL?Pr;EH%pdtI z=}$677@4o!2`kPBBlXI7=Gy#Obgdh|y;GF(=BAvRc$^BbXoW zOIRvZ!XUV%S!FwM7Oma%qf3D5zL>$RWD&J$OED3#gz+q(0!L9BA}(Y~Q8mJGDBQiuhPhrN^@A{#3p@^40&a5BRYVXSTB(Ikr5J za6mHRMOLlgRq`G1mx zs$QG_sU@Psj^5pCO*Z_JPiyAQnVSKvK7lVVuOVYbsh@lw!oBA%1?9Drt|tCUy*lU= zT>4$|{a4a$QnYjp79ik-8tZwQe~{1_2e^vYo<5aVpcr!-vX3nP=PlYZ5%Ijc6nVRd z*_Xu_@248mQ)n$x6>(kI)I`Z?52s# zA5+uV1A@*e!}#e9@le{Dq0KLB^wLvd7e4tI!Ew_cKbpTZ9?d>6FJaFT7V0xdE}SmJ zS_TX7?gV7@oXiZo)A^clWexxwgyIf3_;T3S8hst7mt_}3q)O9XrvoRYa*Tys;y+Qi zrlXLC>T;tXtx?}({ft%dpAK*YBC^*Si?YI~cQ>#~(+?4yC>faAwsmii34z$tq1OFlPM(zrBst0pTauTGU$Ft5LU-ivjev(%kIl4AxuS25E zTD0_Jk$R^+*7sg~Ihvi3lp!Sz0&V18UWh`NbV|^c(r2%|Fxq@_7j4<=B$am76MM-Qhfc<7pHg1ahx8pjsd#m~9#`4sDA? z>xd}pkXa*++8O<3x|3OKyT7+)OgfbM%{b|~sB7(2{80Ee5=}h$H6e$68A>IN!X)O=u@Rq2ssUPk^|x z1iybDKIXrf+zQQ)H-^kE|Fv%d01sd0=%W2HSRZHEbZebC&gdt|*7SfnR_7Y23o?IW z0o?H&P`fG{c;UGOrk!hE`@vqpcbgbq1P#MUk9oG+kW-`Zz#E1UD0RY}TTtDE?^c?1 z2Bh7Nf6x*33YPZY*)=iV}Yu00QL3>0Y{^K`DpBN!m=&j zfQK%03<)=>9LdCko=HlDVEUx`Yqa>-KV(k<3kfe848w=u`sJARs4h}BdbE_hC2B80 z>w>%8>T$_x%0=ua{}&oagy|KcDwo{szi& zEM5V%9At~0rjE(jLUGJ24Lf}mlf!0*=fVZbUH>nEDNRIri(XTe!BKt8%tpuMeOvJW z4xdVH{IC`8ZhUx#DET+T>V6q9`Kc|og;xi8zWe;GPaI%rv-Gqgk) zl|w>QuxlO#dqg4&kHq5Bg0-9BKCYcOs^SH=uBOwxx~(5}AD#jUws=@A;!N3O#i8LD z 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 z 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
ym2sWhMQ5 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ïO_wcQLr5@lbkJ1$6atJ^n3g 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

<)%Yyd6`kfctFG>j^BlgF#tnT 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%0Ai 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

?Yv!FOFah+cSyt~kLbWrOVVX>x(Cj+#9? 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

4tw*8;zL<6_ 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 literal 0 HcmV?d00001 diff --git a/3rdparty/tinygltf/models/Cube/Cube_MetallicRoughness.png b/3rdparty/tinygltf/models/Cube/Cube_MetallicRoughness.png new file mode 100644 index 0000000000000000000000000000000000000000..efd20260218a92d097c4005a8167dcdf08180664 GIT binary patch literal 319 zcmeAS@N?(olHy`uVBq!ia0y~yU;;9k7#Nv>)VXbLJAo8Sx}&cn1H;CC?mvmFK)yn< zN02WALzNl>LqiJ#!!Mvv!wUw6QUeBtR|yOZRx=nF#0%!^3bX-Aum$*pxH5<^{Qv*o zVCTB|KoQ0yZ+92Q|4h2~fE@M`PhVH|hb-*uO5zb)HRk|@%sgEjLn>~)J;=xi +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for req_comp + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +typedef unsigned char stbi_uc; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *comp, int req_comp); +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *comp, int req_comp); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *comp, int req_comp); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *comp, int req_comp); + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_HDR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// NOT THREADSAFE +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); + +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + + +#ifdef _MSC_VER +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y)))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && defined(STBI_REALLOC) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,sz) realloc(p,sz) +#define STBI_FREE(p) free(p) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// NOTE: not clear do we actually need this for the 64-bit path? +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// (but compiling with -msse2 allows the compiler to use SSE2 everywhere; +// this is just broken and gcc are jerks for not fixing it properly +// http://www.virtualdub.org/blog/pivot/entry.php?id=363 ) +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && defined(STBI__X86_TARGET) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +static int stbi__sse2_available() +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +static int stbi__sse2_available() +{ +#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 // GCC 4.8 or later + // GCC 4.8+ has a nice way to do this + return __builtin_cpu_supports("sse2"); +#else + // portable way to do this, preferably without using GCC inline ASM? + // just bail for now. + return 0; +#endif +} +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +// assume GCC or Clang on ARM targets +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + fseek((FILE*) user, n, SEEK_CUR); +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static stbi_uc *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static stbi_uc *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static stbi_uc *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static stbi_uc *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static stbi_uc *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static stbi_uc *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +// this is not threadsafe +static const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load = flag_true_if_should_flip; +} + +static unsigned char *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp); + #endif + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static unsigned char *stbi__load_flip(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result = stbi__load_main(s, x, y, comp, req_comp); + + if (stbi__vertically_flip_on_load && result != NULL) { + int w = *x, h = *y; + int depth = req_comp ? req_comp : *comp; + int row,col,z; + stbi_uc temp; + + // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once + for (row = 0; row < (h>>1); row++) { + for (col = 0; col < w; col++) { + for (z = 0; z < depth; z++) { + temp = result[(row * w + col) * depth + z]; + result[(row * w + col) * depth + z] = result[((h - row - 1) * w + col) * depth + z]; + result[((h - row - 1) * w + col) * depth + z] = temp; + } + } + } + } + + return result; +} + +#ifndef STBI_NO_HDR +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int w = *x, h = *y; + int depth = req_comp ? req_comp : *comp; + int row,col,z; + float temp; + + // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once + for (row = 0; row < (h>>1); row++) { + for (col = 0; col < w; col++) { + for (z = 0; z < depth; z++) { + temp = result[(row * w + col) * depth + z]; + result[(row * w + col) * depth + z] = result[((h - row - 1) * w + col) * depth + z]; + result[((h - row - 1) * w + col) * depth + z] = temp; + } + } + } + } +} +#endif + +#ifndef STBI_NO_STDIO + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_flip(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} +#endif //!STBI_NO_STDIO + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_flip(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_flip(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_flip(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_file(&s,f); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +#ifndef STBI_NO_LINEAR +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} + +static void stbi__skip(stbi__context *s, int n) +{ + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} + +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} + +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} + +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + return z + (stbi__get16le(s) << 16); +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + + +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} + +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc(req_comp * x * y); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define COMBO(a,b) ((a)*8+(b)) + #define CASE(a,b) case COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (COMBO(img_n, req_comp)) { + CASE(1,2) dest[0]=src[0], dest[1]=255; break; + CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break; + CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break; + CASE(2,1) dest[0]=src[0]; break; + CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break; + CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break; + CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break; + CASE(3,1) dest[0]=stbi__compute_y(src[0],src[1],src[2]); break; + CASE(3,2) dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = 255; break; + CASE(4,1) dest[0]=stbi__compute_y(src[0],src[1],src[2]); break; + CASE(4,2) dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break; + CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break; + default: STBI_ASSERT(0); + } + #undef CASE + } + + STBI_FREE(data); + return good; +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output = (float *) stbi__malloc(x * y * comp * sizeof(float)); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f; + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output = (stbi_uc *) stbi__malloc(x * y * comp); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi_uc dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0,code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) + for (j=0; j < count[i]; ++j) + h->size[k++] = (stbi_uc) (i+1); + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1 << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (-1 << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k << 8) + (run << 4) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + + sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB + k = stbi_lrot(j->code_buffer, n); + STBI_ASSERT(n >= 0 && n < (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask))); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & ~sgn); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi_uc *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + diff = t ? stbi__extend_receive(j, t) : 0; + + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short) (dc << j->succ_low); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) << shift); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) << shift); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) << 12) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0] << 2; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi_uc *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4; + int t = q & 15,i; + if (p != 0) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = stbi__get8(z->s); + L -= 65; + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + stbi__skip(z->s, stbi__get16be(z->s)-2); + return 1; + } + return 0; +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + c = stbi__get8(s); + if (c != 3 && c != 1) return stbi__err("bad component count","Corrupt JPEG"); // JFIF requires + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + for (i=0; i < s->img_n; ++i) { + z->img_comp[i].id = stbi__get8(s); + if (z->img_comp[i].id != i+1) // JFIF requires + if (z->img_comp[i].id != i) // some version of jpegtran outputs non-JFIF-compliant files! + return stbi__err("bad component ID","Corrupt JPEG"); + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].raw_data = stbi__malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15); + + if (z->img_comp[i].raw_data == NULL) { + for(--i; i >= 0; --i) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + } + return stbi__err("outofmem", "Out of memory"); + } + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + z->img_comp[i].linebuf = NULL; + if (z->progressive) { + z->img_comp[i].coeff_w = (z->img_comp[i].w2 + 7) >> 3; + z->img_comp[i].coeff_h = (z->img_comp[i].h2 + 7) >> 3; + z->img_comp[i].raw_coeff = STBI_MALLOC(z->img_comp[i].coeff_w * z->img_comp[i].coeff_h * 64 * sizeof(short) + 15); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } else { + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + // handle 0s at the end of image data from IP Kamera 9060 + while (!stbi__at_eof(j->s)) { + int x = stbi__get8(j->s); + if (x == 255) { + j->marker = stbi__get8(j->s); + break; + } else if (x != 0) { + return stbi__err("junk before marker", "Corrupt JPEG"); + } + } + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + } else { + if (!stbi__process_marker(j, m)) return 0; + } + m = stbi__get_marker(j); + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +#ifdef STBI_JPEG_OLD +// this is the same YCbCr-to-RGB calculation that stb_image has used +// historically before the algorithm changes in 1.49 +#define float2fixed(x) ((int) ((x) * 65536 + 0.5)) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 16) + 32768; // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr*float2fixed(1.40200f); + g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f); + b = y_fixed + cb*float2fixed(1.77200f); + r >>= 16; + g >>= 16; + b >>= 16; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#else +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* float2fixed(1.40200f); + g = y_fixed + (cr*-float2fixed(0.71414f)) + ((cb*-float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* float2fixed(1.40200f); + g = y_fixed + cr*-float2fixed(0.71414f) + ((cb*-float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + #ifndef STBI_JPEG_OLD + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + #endif + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + #ifndef STBI_JPEG_OLD + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + #endif + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + int i; + for (i=0; i < j->s->img_n; ++i) { + if (j->img_comp[i].raw_data) { + STBI_FREE(j->img_comp[i].raw_data); + j->img_comp[i].raw_data = NULL; + j->img_comp[i].data = NULL; + } + if (j->img_comp[i].raw_coeff) { + STBI_FREE(j->img_comp[i].raw_coeff); + j->img_comp[i].raw_coeff = 0; + j->img_comp[i].coeff = 0; + } + if (j->img_comp[i].linebuf) { + STBI_FREE(j->img_comp[i].linebuf); + j->img_comp[i].linebuf = NULL; + } + } +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n; + + if (z->s->img_n == 3 && n < 3) + decode_n = 1; + else + decode_n = z->s->img_n; + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4]; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc(n * z->s->img_x * z->s->img_y + 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255; + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n; // report original components, not output + return output; + } +} + +static unsigned char *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__jpeg j; + j.s = s; + stbi__setup_jpeg(&j); + return load_jpeg_image(&j, x,y,comp,req_comp); +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg j; + j.s = s; + stbi__setup_jpeg(&j); + r = stbi__decode_jpeg_header(&j, STBI__SCAN_type); + stbi__rewind(s); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__jpeg j; + j.s = s; + return stbi__jpeg_info_raw(&j, x, y, comp); +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[288]; + stbi__uint16 value[288]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + if (z->zbuffer >= z->zbuffer_end) return 0; + return *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + STBI_ASSERT(z->code_buffer < (1U << z->num_bits)); + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s == 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + STBI_ASSERT(z->size[b] == s); + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) stbi__fill_bits(a); + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + int cur, limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (int) (z->zout - z->zout_start); + limit = (int) (z->zout_end - z->zout_start); + while (cur + n > limit) + limit *= 2; + q = (char *) STBI_REALLOC(z->zout_start, limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + return 1; + } + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (zout + len > a->zout_end) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < hlit + hdist) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else if (c == 16) { + c = stbi__zreceive(a,2)+3; + memset(lencodes+n, lencodes[n-1], c); + n += c; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + memset(lencodes+n, 0, c); + n += c; + } else { + STBI_ASSERT(c == 18); + c = stbi__zreceive(a,7)+11; + memset(lencodes+n, 0, c); + n += c; + } + } + if (n != hlit+hdist) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncomperssed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + STBI_ASSERT(a->num_bits == 0); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +// @TODO: should statically initialize these for optimal thread safety +static stbi_uc stbi__zdefault_length[288], stbi__zdefault_distance[32]; +static void stbi__init_zdefaults(void) +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncomperssed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zdefault_distance[31]) stbi__init_zdefaults(); + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , 288)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filters used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first, + STBI__F_paeth_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_paeth_first +}; + +static int stbi__paeth(int a, int b, int c) +{ + int p = a + b - c; + int pa = abs(p-a); + int pb = abs(p-b); + int pc = abs(p-c); + if (pa <= pb && pa <= pc) return a; + if (pb <= pc) return b; + return c; +} + +static stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n; + stbi__uint32 img_len, img_width_bytes; + int k; + int img_n = s->img_n; // copy it into a local for later + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc(x * y * out_n); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + img_len = (img_width_bytes + 1) * y; + if (s->img_x == x && s->img_y == y) { + if (raw_len != img_len) return stbi__err("not enough pixels","Corrupt PNG"); + } else { // interlaced: + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + } + + for (j=0; j < y; ++j) { + stbi_uc *cur = a->out + stride*j; + stbi_uc *prior = cur - stride; + int filter = *raw++; + int filter_bytes = img_n; + int width = x; + if (filter > 4) + return stbi__err("invalid filter","Corrupt PNG"); + + if (depth < 8) { + STBI_ASSERT(img_width_bytes <= x); + cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place + filter_bytes = 1; + width = img_width_bytes; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // handle first byte explicitly + for (k=0; k < filter_bytes; ++k) { + switch (filter) { + case STBI__F_none : cur[k] = raw[k]; break; + case STBI__F_sub : cur[k] = raw[k]; break; + case STBI__F_up : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break; + case STBI__F_avg : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break; + case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break; + case STBI__F_avg_first : cur[k] = raw[k]; break; + case STBI__F_paeth_first: cur[k] = raw[k]; break; + } + } + + if (depth == 8) { + if (img_n != out_n) + cur[img_n] = 255; // first pixel + raw += img_n; + cur += out_n; + prior += out_n; + } else { + raw += 1; + cur += 1; + prior += 1; + } + + // this is a little gross, so that we don't switch per-pixel or per-component + if (depth < 8 || img_n == out_n) { + int nk = (width - 1)*img_n; + #define CASE(f) \ + case f: \ + for (k=0; k < nk; ++k) + switch (filter) { + // "none" filter turns into a memcpy here; make that explicit. + case STBI__F_none: memcpy(cur, raw, nk); break; + CASE(STBI__F_sub) cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); break; + CASE(STBI__F_up) cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break; + CASE(STBI__F_avg) cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); break; + CASE(STBI__F_paeth) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); break; + CASE(STBI__F_avg_first) cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); break; + CASE(STBI__F_paeth_first) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); break; + } + #undef CASE + raw += nk; + } else { + STBI_ASSERT(img_n+1 == out_n); + #define CASE(f) \ + case f: \ + for (i=x-1; i >= 1; --i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \ + for (k=0; k < img_n; ++k) + switch (filter) { + CASE(STBI__F_none) cur[k] = raw[k]; break; + CASE(STBI__F_sub) cur[k] = STBI__BYTECAST(raw[k] + cur[k-out_n]); break; + CASE(STBI__F_up) cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break; + CASE(STBI__F_avg) cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-out_n])>>1)); break; + CASE(STBI__F_paeth) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-out_n],prior[k],prior[k-out_n])); break; + CASE(STBI__F_avg_first) cur[k] = STBI__BYTECAST(raw[k] + (cur[k-out_n] >> 1)); break; + CASE(STBI__F_paeth_first) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-out_n],0,0)); break; + } + #undef CASE + } + } + + // we make a separate pass to expand bits to pixels; for performance, + // this could run two scanlines behind the above code, so it won't + // intefere with filtering but will still be in the cache. + if (depth < 8) { + for (j=0; j < y; ++j) { + stbi_uc *cur = a->out + stride*j; + stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes; + // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit + // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + + // note that the final byte might overshoot and write more data than desired. + // we can allocate enough data that this never writes out of memory, but it + // could also overwrite the next scanline. can it overwrite non-empty data + // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel. + // so we need to explicitly clamp the final ones + + if (depth == 4) { + for (k=x*img_n; k >= 2; k-=2, ++in) { + *cur++ = scale * ((*in >> 4) ); + *cur++ = scale * ((*in ) & 0x0f); + } + if (k > 0) *cur++ = scale * ((*in >> 4) ); + } else if (depth == 2) { + for (k=x*img_n; k >= 4; k-=4, ++in) { + *cur++ = scale * ((*in >> 6) ); + *cur++ = scale * ((*in >> 4) & 0x03); + *cur++ = scale * ((*in >> 2) & 0x03); + *cur++ = scale * ((*in ) & 0x03); + } + if (k > 0) *cur++ = scale * ((*in >> 6) ); + if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03); + if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03); + } else if (depth == 1) { + for (k=x*img_n; k >= 8; k-=8, ++in) { + *cur++ = scale * ((*in >> 7) ); + *cur++ = scale * ((*in >> 6) & 0x01); + *cur++ = scale * ((*in >> 5) & 0x01); + *cur++ = scale * ((*in >> 4) & 0x01); + *cur++ = scale * ((*in >> 3) & 0x01); + *cur++ = scale * ((*in >> 2) & 0x01); + *cur++ = scale * ((*in >> 1) & 0x01); + *cur++ = scale * ((*in ) & 0x01); + } + if (k > 0) *cur++ = scale * ((*in >> 7) ); + if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01); + if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01); + if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01); + if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01); + if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01); + if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01); + } + if (img_n != out_n) { + int q; + // insert alpha = 255 + cur = a->out + stride*j; + if (img_n == 1) { + for (q=x-1; q >= 0; --q) { + cur[q*2+1] = 255; + cur[q*2+0] = cur[q]; + } + } else { + STBI_ASSERT(img_n == 3); + for (q=x-1; q >= 0; --q) { + cur[q*4+3] = 255; + cur[q*4+2] = cur[q*3+2]; + cur[q*4+1] = cur[q*3+1]; + cur[q*4+0] = cur[q*3+0]; + } + } + } + } + } + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc(a->s->img_x * a->s->img_y * out_n); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_n + out_x*out_n, + a->out + (j*x+i)*out_n, out_n); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc(pixel_count * pal_img_n); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load = 0; +static int stbi__de_iphone_flag = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag = flag_true_if_should_convert; +} + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + p[0] = p[2] * 255 / a; + p[1] = p[1] * 255 / a; + p[2] = t * 255 / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, depth=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); if (s->img_x > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)"); + s->img_y = stbi__get32be(s); if (s->img_y > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)"); + depth = stbi__get8(s); if (depth != 1 && depth != 2 && depth != 4 && depth != 8) return stbi__err("1/2/4/8-bit only","PNG not supported: 1/2/4/8-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + if (scan == STBI__SCAN_header) return 1; + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + // if SCAN_header, have to scan to see if we have a tRNS + } + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + for (k=0; k < s->img_n; ++k) + tc[k] = (stbi_uc) (stbi__get16be(s) & 255) * stbi__depth_scale_table[depth]; // non 8-bit images will be larger + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; } + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + p = (stbi_uc *) STBI_REALLOC(z->idata, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, depth, color, interlace)) return 0; + if (has_trans) + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } + STBI_FREE(z->expanded); z->expanded = NULL; + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static unsigned char *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp) +{ + unsigned char *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + result = stbi__convert_format(result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_out_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static unsigned char *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) n += 16, z >>= 16; + if (z >= 0x00100) n += 8, z >>= 8; + if (z >= 0x00010) n += 4, z >>= 4; + if (z >= 0x00004) n += 2, z >>= 2; + if (z >= 0x00002) n += 1, z >>= 1; + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +static int stbi__shiftsigned(int v, int shift, int bits) +{ + int result; + int z=0; + + if (shift < 0) v <<= -shift; + else v >>= shift; + result = v; + + z = bits; + while (z < 8) { + result += v >> z; + z += bits; + } + return result; +} + +static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a=255; + stbi_uc pal[256][4]; + int psize=0,i,j,compress=0,width; + int bpp, flip_vertically, pad, target, offset, hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + offset = stbi__get32le(s); + hsz = stbi__get32le(s); + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + bpp = stbi__get16le(s); + if (bpp == 1) return stbi__errpuc("monochrome", "BMP type not supported: 1-bit"); + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + if (hsz == 12) { + if (bpp < 24) + psize = (offset - 14 - 24) / 3; + } else { + compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (bpp == 16 || bpp == 32) { + mr = mg = mb = 0; + if (compress == 0) { + if (bpp == 32) { + mr = 0xffu << 16; + mg = 0xffu << 8; + mb = 0xffu << 0; + ma = 0xffu << 24; + all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + mr = 31u << 10; + mg = 31u << 5; + mb = 31u << 0; + } + } else if (compress == 3) { + mr = stbi__get32le(s); + mg = stbi__get32le(s); + mb = stbi__get32le(s); + // not documented, but generated by photoshop and handled by mspaint + if (mr == mg && mg == mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + STBI_ASSERT(hsz == 108 || hsz == 124); + mr = stbi__get32le(s); + mg = stbi__get32le(s); + mb = stbi__get32le(s); + ma = stbi__get32le(s); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + if (bpp < 16) + psize = (offset - 14 - hsz) >> 2; + } + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + out = (stbi_uc *) stbi__malloc(target * s->img_x * s->img_y); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4)); + if (bpp == 4) width = (s->img_x + 1) >> 1; + else if (bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, offset - 14 - hsz); + if (bpp == 24) width = 3 * s->img_x; + else if (bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (bpp == 24) { + easy = 1; + } else if (bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i], p1[i] = p2[i], p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp; + int sz; + stbi__get8(s); // discard Offset + sz = stbi__get8(s); // color type + if( sz > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + sz = stbi__get8(s); // image type + // only RGB or grey allowed, +/- RLE + if ((sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11)) return 0; + stbi__skip(s,9); + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + sz = stbi__get8(s); // bits per pixel + // only RGB or RGBA or grey allowed + if ((sz != 8) && (sz != 16) && (sz != 24) && (sz != 32)) { + stbi__rewind(s); + return 0; + } + tga_comp = sz; + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp / 8; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res; + int sz; + stbi__get8(s); // discard Offset + sz = stbi__get8(s); // color type + if ( sz > 1 ) return 0; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( (sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11) ) return 0; // only RGB or grey allowed, +/- RLE + stbi__get16be(s); // discard palette start + stbi__get16be(s); // discard palette length + stbi__get8(s); // discard bits per palette color entry + stbi__get16be(s); // discard x origin + stbi__get16be(s); // discard y origin + if ( stbi__get16be(s) < 1 ) return 0; // test width + if ( stbi__get16be(s) < 1 ) return 0; // test height + sz = stbi__get8(s); // bits per pixel + if ( (sz != 8) && (sz != 16) && (sz != 24) && (sz != 32) ) + res = 0; + else + res = 1; + stbi__rewind(s); + return res; +} + +static stbi_uc *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp = tga_bits_per_pixel / 8; + int tga_inverted = stbi__get8(s); + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4]; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + /* int tga_alpha_bits = tga_inverted & 15; */ + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // error check + if ( //(tga_indexed) || + (tga_width < 1) || (tga_height < 1) || + (tga_image_type < 1) || (tga_image_type > 3) || + ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) && + (tga_bits_per_pixel != 24) && (tga_bits_per_pixel != 32)) + ) + { + return NULL; // we don't report this as a bad TGA because we don't even know if it's TGA + } + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) + { + tga_comp = tga_palette_bits / 8; + } + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + tga_data = (unsigned char*)stbi__malloc( (size_t)tga_width * tga_height * tga_comp ); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc( tga_palette_len * tga_palette_bits / 8 ); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (!stbi__getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 )) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in 1 byte, then perform the lookup + int pal_idx = stbi__get8(s); + if ( pal_idx >= tga_palette_len ) + { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_bits_per_pixel / 8; + for (j = 0; j*8 < tga_bits_per_pixel; ++j) + { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else + { + // read in the data raw + for (j = 0; j*8 < tga_bits_per_pixel; ++j) + { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB + if (tga_comp >= 3) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + int pixelCount; + int channelCount, compression; + int channel, i, count, len; + int bitdepth; + int w,h; + stbi_uc *out; + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Create the destination image. + out = (stbi_uc *) stbi__malloc(4 * w*h); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + count = 0; + while (count < pixelCount) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len ^= 0x0FF; + len += 2; + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out + channel; + if (channel >= channelCount) { + // Fill this channel with default data. + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } else { + // Read the data. + if (bitdepth == 16) { + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + + if (req_comp && req_comp != 4) { + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static stbi_uc *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp) +{ + stbi_uc *result; + int i, x,y; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if ((1 << 28) / x < y) return stbi__errpuc("too large", "Image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc(x*y*4); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out, *old_out; // output buffer (always 4 components) + int flags, bgindex, ratio, transparent, eflags, delay; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[4096]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif g; + if (!stbi__gif_header(s, &g, comp, 1)) { + stbi__rewind( s ); + return 0; + } + if (x) *x = g.w; + if (y) *y = g.h; + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + p = &g->out[g->cur_x + g->cur_y]; + c = &g->color_table[g->codes[code].suffix * 4]; + + if (c[3] >= 128) { + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) return stbi__errpuc("no clear code", "Corrupt GIF"); + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 4096) return stbi__errpuc("too many codes", "Corrupt GIF"); + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +static void stbi__fill_gif_background(stbi__gif *g, int x0, int y0, int x1, int y1) +{ + int x, y; + stbi_uc *c = g->pal[g->bgindex]; + for (y = y0; y < y1; y += 4 * g->w) { + for (x = x0; x < x1; x += 4) { + stbi_uc *p = &g->out[y + x]; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = 0; + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp) +{ + int i; + stbi_uc *prev_out = 0; + + if (g->out == 0 && !stbi__gif_header(s, g, comp,0)) + return 0; // stbi__g_failure_reason set by stbi__gif_header + + prev_out = g->out; + g->out = (stbi_uc *) stbi__malloc(4 * g->w * g->h); + if (g->out == 0) return stbi__errpuc("outofmem", "Out of memory"); + + switch ((g->eflags & 0x1C) >> 2) { + case 0: // unspecified (also always used on 1st frame) + stbi__fill_gif_background(g, 0, 0, 4 * g->w, 4 * g->w * g->h); + break; + case 1: // do not dispose + if (prev_out) memcpy(g->out, prev_out, 4 * g->w * g->h); + g->old_out = prev_out; + break; + case 2: // dispose to background + if (prev_out) memcpy(g->out, prev_out, 4 * g->w * g->h); + stbi__fill_gif_background(g, g->start_x, g->start_y, g->max_x, g->max_y); + break; + case 3: // dispose to previous + if (g->old_out) { + for (i = g->start_y; i < g->max_y; i += 4 * g->w) + memcpy(&g->out[i + g->start_x], &g->old_out[i + g->start_x], g->max_x - g->start_x); + } + break; + } + + for (;;) { + switch (stbi__get8(s)) { + case 0x2C: /* Image Descriptor */ + { + int prev_trans = -1; + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + if (g->transparent >= 0 && (g->eflags & 0x01)) { + prev_trans = g->pal[g->transparent][3]; + g->pal[g->transparent][3] = 0; + } + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (o == NULL) return NULL; + + if (prev_trans != -1) + g->pal[g->transparent][3] = (stbi_uc) prev_trans; + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + if (stbi__get8(s) == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = stbi__get16le(s); + g->transparent = stbi__get8(s); + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) + stbi__skip(s, len); + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } + + STBI_NOTUSED(req_comp); +} + +static stbi_uc *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + + u = stbi__gif_load_next(s, &g, comp, req_comp); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } + else if (g.out) + STBI_FREE(g.out); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s) +{ + const char *signature = "#?RADIANCE\n"; + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s); + stbi__rewind(s); + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + + + // Check identifier + if (strcmp(stbi__hdr_gettoken(s,buffer), "#?RADIANCE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + // Read data + hdr_data = (float *) stbi__malloc(height * width * req_comp * sizeof(float)); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) scanline = (stbi_uc *) stbi__malloc(width * 4); + + for (k = 0; k < 4; ++k) { + i = 0; + while (i < width) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + + if (strcmp(stbi__hdr_gettoken(s,buffer), "#?RADIANCE") != 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') { + stbi__rewind( s ); + return 0; + } + stbi__skip(s,12); + hsz = stbi__get32le(s); + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) { + stbi__rewind( s ); + return 0; + } + if (hsz == 12) { + *x = stbi__get16le(s); + *y = stbi__get16le(s); + } else { + *x = stbi__get32le(s); + *y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) { + stbi__rewind( s ); + return 0; + } + *comp = stbi__get16le(s) / 8; + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + if (stbi__get16be(s) != 8) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained; + stbi__pic_packet packets[10]; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) +// Does not support 16-bit-per-channel + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static stbi_uc *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi_uc *out; + if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n)) + return 0; + *x = s->img_x; + *y = s->img_y; + *comp = s->img_n; + + out = (stbi_uc *) stbi__malloc(s->img_n * s->img_x * s->img_y); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + stbi__getn(s, out, s->img_n * s->img_x * s->img_y); + + if (req_comp && req_comp != s->img_n) { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv; + char c, p, t; + + stbi__rewind( s ); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + + if (maxv > 255) + return stbi__err("max value > 255", "PPM image not 8-bit"); + else + return 1; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bit PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ diff --git a/3rdparty/tinygltf/test_runner.py b/3rdparty/tinygltf/test_runner.py new file mode 100644 index 0000000..26345db --- /dev/null +++ b/3rdparty/tinygltf/test_runner.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python + +# Assume python 2.6 or 2.7 + +import glob +import os +import subprocess + +## Simple test runner. + +# -- config ----------------------- + +# Absolute path pointing to your cloned git repo of https://github.com/KhronosGroup/glTF-Sample-Models +sample_model_dir = "/home/syoyo/work/glTF-Sample-Models" +base_model_dir = os.path.join(sample_model_dir, "2.0") + +kinds = [ "glTF", "glTF-Binary", "glTF-Embedded", "glTF-MaterialsCommon"] +# --------------------------------- + +failed = [] +success = [] + +def run(filename): + + print("Testing: " + filename) + cmd = ["./loader_example", filename] + try: + p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + (stdout, stderr) = p.communicate() + except: + print "Failed to execute: ", cmd + raise + + if p.returncode != 0: + failed.append(filename) + print(stdout) + print(stderr) + else: + success.append(filename) + + +def test(): + + for d in os.listdir(base_model_dir): + p = os.path.join(base_model_dir, d) + if os.path.isdir(p): + for k in kinds: + targetDir = os.path.join(p, k) + g = glob.glob(targetDir + "/*.gltf") + glob.glob(targetDir + "/*.glb") + for gltf in g: + run(gltf) + + +def main(): + + test() + + print("Success : {0}".format(len(success))) + print("Failed : {0}".format(len(failed))) + + for fail in failed: + print("FAIL: " + fail) + +if __name__ == '__main__': + main() diff --git a/3rdparty/tinygltf/tests/catch.hpp b/3rdparty/tinygltf/tests/catch.hpp new file mode 100644 index 0000000..2a7146a --- /dev/null +++ b/3rdparty/tinygltf/tests/catch.hpp @@ -0,0 +1,10445 @@ +/* + * Catch v1.4.0 + * Generated: 2016-03-15 07:23:12.623111 + * ---------------------------------------------------------- + * This file has been merged from multiple headers. Please don't edit it directly + * Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved. + * + * Distributed under the Boost Software License, Version 1.0. (See accompanying + * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + */ +#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED +#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED + +#define TWOBLUECUBES_CATCH_HPP_INCLUDED + +#ifdef __clang__ +# pragma clang system_header +#elif defined __GNUC__ +# pragma GCC system_header +#endif + +// #included from: internal/catch_suppress_warnings.h + +#ifdef __clang__ +# ifdef __ICC // icpc defines the __clang__ macro +# pragma warning(push) +# pragma warning(disable: 161 1682) +# else // __ICC +# pragma clang diagnostic ignored "-Wglobal-constructors" +# pragma clang diagnostic ignored "-Wvariadic-macros" +# pragma clang diagnostic ignored "-Wc99-extensions" +# pragma clang diagnostic ignored "-Wunused-variable" +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wpadded" +# pragma clang diagnostic ignored "-Wc++98-compat" +# pragma clang diagnostic ignored "-Wc++98-compat-pedantic" +# pragma clang diagnostic ignored "-Wswitch-enum" +# pragma clang diagnostic ignored "-Wcovered-switch-default" +# endif +#elif defined __GNUC__ +# pragma GCC diagnostic ignored "-Wvariadic-macros" +# pragma GCC diagnostic ignored "-Wunused-variable" +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wpadded" +#endif +#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER) +# define CATCH_IMPL +#endif + +#ifdef CATCH_IMPL +# ifndef CLARA_CONFIG_MAIN +# define CLARA_CONFIG_MAIN_NOT_DEFINED +# define CLARA_CONFIG_MAIN +# endif +#endif + +// #included from: internal/catch_notimplemented_exception.h +#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED + +// #included from: catch_common.h +#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED + +#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line +#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) +#ifdef CATCH_CONFIG_COUNTER +# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ ) +#else +# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ ) +#endif + +#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr +#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr ) + +#include +#include +#include + +// #included from: catch_compiler_capabilities.h +#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED + +// Detect a number of compiler features - mostly C++11/14 conformance - by compiler +// The following features are defined: +// +// CATCH_CONFIG_CPP11_NULLPTR : is nullptr supported? +// CATCH_CONFIG_CPP11_NOEXCEPT : is noexcept supported? +// CATCH_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods +// CATCH_CONFIG_CPP11_IS_ENUM : std::is_enum is supported? +// CATCH_CONFIG_CPP11_TUPLE : std::tuple is supported +// CATCH_CONFIG_CPP11_LONG_LONG : is long long supported? +// CATCH_CONFIG_CPP11_OVERRIDE : is override supported? +// CATCH_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr) + +// CATCH_CONFIG_CPP11_OR_GREATER : Is C++11 supported? + +// CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported? +// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported? +// **************** +// Note to maintainers: if new toggles are added please document them +// in configuration.md, too +// **************** + +// In general each macro has a _NO_ form +// (e.g. CATCH_CONFIG_CPP11_NO_NULLPTR) which disables the feature. +// Many features, at point of detection, define an _INTERNAL_ macro, so they +// can be combined, en-mass, with the _NO_ forms later. + +// All the C++11 features can be disabled with CATCH_CONFIG_NO_CPP11 + +#if defined(__cplusplus) && __cplusplus >= 201103L +# define CATCH_CPP11_OR_GREATER +#endif + +#ifdef __clang__ + +# if __has_feature(cxx_nullptr) +# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR +# endif + +# if __has_feature(cxx_noexcept) +# define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT +# endif + +# if defined(CATCH_CPP11_OR_GREATER) +# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS _Pragma( "clang diagnostic ignored \"-Wparentheses\"" ) +# endif + +#endif // __clang__ + +//////////////////////////////////////////////////////////////////////////////// +// Borland +#ifdef __BORLANDC__ + +#endif // __BORLANDC__ + +//////////////////////////////////////////////////////////////////////////////// +// EDG +#ifdef __EDG_VERSION__ + +#endif // __EDG_VERSION__ + +//////////////////////////////////////////////////////////////////////////////// +// Digital Mars +#ifdef __DMC__ + +#endif // __DMC__ + +//////////////////////////////////////////////////////////////////////////////// +// GCC +#ifdef __GNUC__ + +# if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) +# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR +# endif + +# if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) && defined(CATCH_CPP11_OR_GREATER) +# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" ) +# endif + +// - otherwise more recent versions define __cplusplus >= 201103L +// and will get picked up below + +#endif // __GNUC__ + +//////////////////////////////////////////////////////////////////////////////// +// Visual C++ +#ifdef _MSC_VER + +#if (_MSC_VER >= 1600) +# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR +# define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR +#endif + +#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015)) +#define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT +#define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +#endif + +#endif // _MSC_VER + +//////////////////////////////////////////////////////////////////////////////// + +// Use variadic macros if the compiler supports them +#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \ + ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \ + ( defined __GNUC__ && __GNUC__ >= 3 ) || \ + ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L ) + +#define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS + +#endif + +// Use __COUNTER__ if the compiler supports it +#if ( defined _MSC_VER && _MSC_VER >= 1300 ) || \ + ( defined __GNUC__ && __GNUC__ >= 4 && __GNUC_MINOR__ >= 3 ) || \ + ( defined __clang__ && __clang_major__ >= 3 ) + +#define CATCH_INTERNAL_CONFIG_COUNTER + +#endif + +//////////////////////////////////////////////////////////////////////////////// +// C++ language feature support + +// catch all support for C++11 +#if defined(CATCH_CPP11_OR_GREATER) + +# if !defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) +# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR +# endif + +# ifndef CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT +# define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT +# endif + +# ifndef CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +# define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +# endif + +# ifndef CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM +# define CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM +# endif + +# ifndef CATCH_INTERNAL_CONFIG_CPP11_TUPLE +# define CATCH_INTERNAL_CONFIG_CPP11_TUPLE +# endif + +# ifndef CATCH_INTERNAL_CONFIG_VARIADIC_MACROS +# define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS +# endif + +# if !defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) +# define CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG +# endif + +# if !defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) +# define CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE +# endif +# if !defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) +# define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR +# endif + +#endif // __cplusplus >= 201103L + +// Now set the actual defines based on the above + anything the user has configured +#if defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NO_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_NO_CPP11) +# define CATCH_CONFIG_CPP11_NULLPTR +#endif +#if defined(CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_NO_CPP11) +# define CATCH_CONFIG_CPP11_NOEXCEPT +#endif +#if defined(CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_NO_CPP11) +# define CATCH_CONFIG_CPP11_GENERATED_METHODS +#endif +#if defined(CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_NO_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_NO_CPP11) +# define CATCH_CONFIG_CPP11_IS_ENUM +#endif +#if defined(CATCH_INTERNAL_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_CPP11_NO_TUPLE) && !defined(CATCH_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_NO_CPP11) +# define CATCH_CONFIG_CPP11_TUPLE +#endif +#if defined(CATCH_INTERNAL_CONFIG_VARIADIC_MACROS) && !defined(CATCH_CONFIG_NO_VARIADIC_MACROS) && !defined(CATCH_CONFIG_VARIADIC_MACROS) +# define CATCH_CONFIG_VARIADIC_MACROS +#endif +#if defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_CPP11) +# define CATCH_CONFIG_CPP11_LONG_LONG +#endif +#if defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_CPP11) +# define CATCH_CONFIG_CPP11_OVERRIDE +#endif +#if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11) +# define CATCH_CONFIG_CPP11_UNIQUE_PTR +#endif +#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) +# define CATCH_CONFIG_COUNTER +#endif + +#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS +#endif + +// noexcept support: +#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT) +# define CATCH_NOEXCEPT noexcept +# define CATCH_NOEXCEPT_IS(x) noexcept(x) +#else +# define CATCH_NOEXCEPT throw() +# define CATCH_NOEXCEPT_IS(x) +#endif + +// nullptr support +#ifdef CATCH_CONFIG_CPP11_NULLPTR +# define CATCH_NULL nullptr +#else +# define CATCH_NULL NULL +#endif + +// override support +#ifdef CATCH_CONFIG_CPP11_OVERRIDE +# define CATCH_OVERRIDE override +#else +# define CATCH_OVERRIDE +#endif + +// unique_ptr support +#ifdef CATCH_CONFIG_CPP11_UNIQUE_PTR +# define CATCH_AUTO_PTR( T ) std::unique_ptr +#else +# define CATCH_AUTO_PTR( T ) std::auto_ptr +#endif + +namespace Catch { + + struct IConfig; + + struct CaseSensitive { enum Choice { + Yes, + No + }; }; + + class NonCopyable { +#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + NonCopyable( NonCopyable const& ) = delete; + NonCopyable( NonCopyable && ) = delete; + NonCopyable& operator = ( NonCopyable const& ) = delete; + NonCopyable& operator = ( NonCopyable && ) = delete; +#else + NonCopyable( NonCopyable const& info ); + NonCopyable& operator = ( NonCopyable const& ); +#endif + + protected: + NonCopyable() {} + virtual ~NonCopyable(); + }; + + class SafeBool { + public: + typedef void (SafeBool::*type)() const; + + static type makeSafe( bool value ) { + return value ? &SafeBool::trueValue : 0; + } + private: + void trueValue() const {} + }; + + template + inline void deleteAll( ContainerT& container ) { + typename ContainerT::const_iterator it = container.begin(); + typename ContainerT::const_iterator itEnd = container.end(); + for(; it != itEnd; ++it ) + delete *it; + } + template + inline void deleteAllValues( AssociativeContainerT& container ) { + typename AssociativeContainerT::const_iterator it = container.begin(); + typename AssociativeContainerT::const_iterator itEnd = container.end(); + for(; it != itEnd; ++it ) + delete it->second; + } + + bool startsWith( std::string const& s, std::string const& prefix ); + bool endsWith( std::string const& s, std::string const& suffix ); + bool contains( std::string const& s, std::string const& infix ); + void toLowerInPlace( std::string& s ); + std::string toLower( std::string const& s ); + std::string trim( std::string const& str ); + bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ); + + struct pluralise { + pluralise( std::size_t count, std::string const& label ); + + friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ); + + std::size_t m_count; + std::string m_label; + }; + + struct SourceLineInfo { + + SourceLineInfo(); + SourceLineInfo( char const* _file, std::size_t _line ); + SourceLineInfo( SourceLineInfo const& other ); +# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + SourceLineInfo( SourceLineInfo && ) = default; + SourceLineInfo& operator = ( SourceLineInfo const& ) = default; + SourceLineInfo& operator = ( SourceLineInfo && ) = default; +# endif + bool empty() const; + bool operator == ( SourceLineInfo const& other ) const; + bool operator < ( SourceLineInfo const& other ) const; + + std::string file; + std::size_t line; + }; + + std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ); + + // This is just here to avoid compiler warnings with macro constants and boolean literals + inline bool isTrue( bool value ){ return value; } + inline bool alwaysTrue() { return true; } + inline bool alwaysFalse() { return false; } + + void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ); + + void seedRng( IConfig const& config ); + unsigned int rngSeed(); + + // Use this in variadic streaming macros to allow + // >> +StreamEndStop + // as well as + // >> stuff +StreamEndStop + struct StreamEndStop { + std::string operator+() { + return std::string(); + } + }; + template + T const& operator + ( T const& value, StreamEndStop ) { + return value; + } +} + +#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) +#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO ); + +#include + +namespace Catch { + + class NotImplementedException : public std::exception + { + public: + NotImplementedException( SourceLineInfo const& lineInfo ); + NotImplementedException( NotImplementedException const& ) {} + + virtual ~NotImplementedException() CATCH_NOEXCEPT {} + + virtual const char* what() const CATCH_NOEXCEPT; + + private: + std::string m_what; + SourceLineInfo m_lineInfo; + }; + +} // end namespace Catch + +/////////////////////////////////////////////////////////////////////////////// +#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO ) + +// #included from: internal/catch_context.h +#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED + +// #included from: catch_interfaces_generators.h +#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED + +#include + +namespace Catch { + + struct IGeneratorInfo { + virtual ~IGeneratorInfo(); + virtual bool moveNext() = 0; + virtual std::size_t getCurrentIndex() const = 0; + }; + + struct IGeneratorsForTest { + virtual ~IGeneratorsForTest(); + + virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0; + virtual bool moveNext() = 0; + }; + + IGeneratorsForTest* createGeneratorsForTest(); + +} // end namespace Catch + +// #included from: catch_ptr.hpp +#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wpadded" +#endif + +namespace Catch { + + // An intrusive reference counting smart pointer. + // T must implement addRef() and release() methods + // typically implementing the IShared interface + template + class Ptr { + public: + Ptr() : m_p( CATCH_NULL ){} + Ptr( T* p ) : m_p( p ){ + if( m_p ) + m_p->addRef(); + } + Ptr( Ptr const& other ) : m_p( other.m_p ){ + if( m_p ) + m_p->addRef(); + } + ~Ptr(){ + if( m_p ) + m_p->release(); + } + void reset() { + if( m_p ) + m_p->release(); + m_p = CATCH_NULL; + } + Ptr& operator = ( T* p ){ + Ptr temp( p ); + swap( temp ); + return *this; + } + Ptr& operator = ( Ptr const& other ){ + Ptr temp( other ); + swap( temp ); + return *this; + } + void swap( Ptr& other ) { std::swap( m_p, other.m_p ); } + T* get() const{ return m_p; } + T& operator*() const { return *m_p; } + T* operator->() const { return m_p; } + bool operator !() const { return m_p == CATCH_NULL; } + operator SafeBool::type() const { return SafeBool::makeSafe( m_p != CATCH_NULL ); } + + private: + T* m_p; + }; + + struct IShared : NonCopyable { + virtual ~IShared(); + virtual void addRef() const = 0; + virtual void release() const = 0; + }; + + template + struct SharedImpl : T { + + SharedImpl() : m_rc( 0 ){} + + virtual void addRef() const { + ++m_rc; + } + virtual void release() const { + if( --m_rc == 0 ) + delete this; + } + + mutable unsigned int m_rc; + }; + +} // end namespace Catch + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#include +#include +#include + +namespace Catch { + + class TestCase; + class Stream; + struct IResultCapture; + struct IRunner; + struct IGeneratorsForTest; + struct IConfig; + + struct IContext + { + virtual ~IContext(); + + virtual IResultCapture* getResultCapture() = 0; + virtual IRunner* getRunner() = 0; + virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0; + virtual bool advanceGeneratorsForCurrentTest() = 0; + virtual Ptr getConfig() const = 0; + }; + + struct IMutableContext : IContext + { + virtual ~IMutableContext(); + virtual void setResultCapture( IResultCapture* resultCapture ) = 0; + virtual void setRunner( IRunner* runner ) = 0; + virtual void setConfig( Ptr const& config ) = 0; + }; + + IContext& getCurrentContext(); + IMutableContext& getCurrentMutableContext(); + void cleanUpContext(); + Stream createStream( std::string const& streamName ); + +} + +// #included from: internal/catch_test_registry.hpp +#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED + +// #included from: catch_interfaces_testcase.h +#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED + +#include + +namespace Catch { + + class TestSpec; + + struct ITestCase : IShared { + virtual void invoke () const = 0; + protected: + virtual ~ITestCase(); + }; + + class TestCase; + struct IConfig; + + struct ITestCaseRegistry { + virtual ~ITestCaseRegistry(); + virtual std::vector const& getAllTests() const = 0; + virtual std::vector const& getAllTestsSorted( IConfig const& config ) const = 0; + }; + + bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ); + std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config ); + std::vector const& getAllTestCasesSorted( IConfig const& config ); + +} + +namespace Catch { + +template +class MethodTestCase : public SharedImpl { + +public: + MethodTestCase( void (C::*method)() ) : m_method( method ) {} + + virtual void invoke() const { + C obj; + (obj.*m_method)(); + } + +private: + virtual ~MethodTestCase() {} + + void (C::*m_method)(); +}; + +typedef void(*TestFunction)(); + +struct NameAndDesc { + NameAndDesc( const char* _name = "", const char* _description= "" ) + : name( _name ), description( _description ) + {} + + const char* name; + const char* description; +}; + +void registerTestCase + ( ITestCase* testCase, + char const* className, + NameAndDesc const& nameAndDesc, + SourceLineInfo const& lineInfo ); + +struct AutoReg { + + AutoReg + ( TestFunction function, + SourceLineInfo const& lineInfo, + NameAndDesc const& nameAndDesc ); + + template + AutoReg + ( void (C::*method)(), + char const* className, + NameAndDesc const& nameAndDesc, + SourceLineInfo const& lineInfo ) { + + registerTestCase + ( new MethodTestCase( method ), + className, + nameAndDesc, + lineInfo ); + } + + ~AutoReg(); + +private: + AutoReg( AutoReg const& ); + void operator= ( AutoReg const& ); +}; + +void registerTestCaseFunction + ( TestFunction function, + SourceLineInfo const& lineInfo, + NameAndDesc const& nameAndDesc ); + +} // end namespace Catch + +#ifdef CATCH_CONFIG_VARIADIC_MACROS + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \ + static void TestName(); \ + namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); }\ + static void TestName() + #define INTERNAL_CATCH_TESTCASE( ... ) \ + INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ ) + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \ + namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\ + namespace{ \ + struct TestName : ClassName{ \ + void test(); \ + }; \ + Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestName::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \ + } \ + void TestName::test() + #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \ + INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ ) + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \ + Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); + +#else + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TESTCASE2( TestName, Name, Desc ) \ + static void TestName(); \ + namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); }\ + static void TestName() + #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \ + INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), Name, Desc ) + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \ + namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestCaseName, ClassName, TestName, Desc )\ + namespace{ \ + struct TestCaseName : ClassName{ \ + void test(); \ + }; \ + Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestCaseName::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \ + } \ + void TestCaseName::test() + #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\ + INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, TestName, Desc ) + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, Name, Desc ) \ + Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); +#endif + +// #included from: internal/catch_capture.hpp +#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED + +// #included from: catch_result_builder.h +#define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED + +// #included from: catch_result_type.h +#define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED + +namespace Catch { + + // ResultWas::OfType enum + struct ResultWas { enum OfType { + Unknown = -1, + Ok = 0, + Info = 1, + Warning = 2, + + FailureBit = 0x10, + + ExpressionFailed = FailureBit | 1, + ExplicitFailure = FailureBit | 2, + + Exception = 0x100 | FailureBit, + + ThrewException = Exception | 1, + DidntThrowException = Exception | 2, + + FatalErrorCondition = 0x200 | FailureBit + + }; }; + + inline bool isOk( ResultWas::OfType resultType ) { + return ( resultType & ResultWas::FailureBit ) == 0; + } + inline bool isJustInfo( int flags ) { + return flags == ResultWas::Info; + } + + // ResultDisposition::Flags enum + struct ResultDisposition { enum Flags { + Normal = 0x01, + + ContinueOnFailure = 0x02, // Failures fail test, but execution continues + FalseTest = 0x04, // Prefix expression with ! + SuppressFail = 0x08 // Failures are reported but do not fail the test + }; }; + + inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) { + return static_cast( static_cast( lhs ) | static_cast( rhs ) ); + } + + inline bool shouldContinueOnFailure( int flags ) { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; } + inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; } + inline bool shouldSuppressFailure( int flags ) { return ( flags & ResultDisposition::SuppressFail ) != 0; } + +} // end namespace Catch + +// #included from: catch_assertionresult.h +#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED + +#include + +namespace Catch { + + struct AssertionInfo + { + AssertionInfo() {} + AssertionInfo( std::string const& _macroName, + SourceLineInfo const& _lineInfo, + std::string const& _capturedExpression, + ResultDisposition::Flags _resultDisposition ); + + std::string macroName; + SourceLineInfo lineInfo; + std::string capturedExpression; + ResultDisposition::Flags resultDisposition; + }; + + struct AssertionResultData + { + AssertionResultData() : resultType( ResultWas::Unknown ) {} + + std::string reconstructedExpression; + std::string message; + ResultWas::OfType resultType; + }; + + class AssertionResult { + public: + AssertionResult(); + AssertionResult( AssertionInfo const& info, AssertionResultData const& data ); + ~AssertionResult(); +# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + AssertionResult( AssertionResult const& ) = default; + AssertionResult( AssertionResult && ) = default; + AssertionResult& operator = ( AssertionResult const& ) = default; + AssertionResult& operator = ( AssertionResult && ) = default; +# endif + + bool isOk() const; + bool succeeded() const; + ResultWas::OfType getResultType() const; + bool hasExpression() const; + bool hasMessage() const; + std::string getExpression() const; + std::string getExpressionInMacro() const; + bool hasExpandedExpression() const; + std::string getExpandedExpression() const; + std::string getMessage() const; + SourceLineInfo getSourceInfo() const; + std::string getTestMacroName() const; + + protected: + AssertionInfo m_info; + AssertionResultData m_resultData; + }; + +} // end namespace Catch + +// #included from: catch_matchers.hpp +#define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED + +namespace Catch { +namespace Matchers { + namespace Impl { + + namespace Generic { + template class AllOf; + template class AnyOf; + template class Not; + } + + template + struct Matcher : SharedImpl + { + typedef ExpressionT ExpressionType; + + virtual ~Matcher() {} + virtual Ptr clone() const = 0; + virtual bool match( ExpressionT const& expr ) const = 0; + virtual std::string toString() const = 0; + + Generic::AllOf operator && ( Matcher const& other ) const; + Generic::AnyOf operator || ( Matcher const& other ) const; + Generic::Not operator ! () const; + }; + + template + struct MatcherImpl : Matcher { + + virtual Ptr > clone() const { + return Ptr >( new DerivedT( static_cast( *this ) ) ); + } + }; + + namespace Generic { + template + class Not : public MatcherImpl, ExpressionT> { + public: + explicit Not( Matcher const& matcher ) : m_matcher(matcher.clone()) {} + Not( Not const& other ) : m_matcher( other.m_matcher ) {} + + virtual bool match( ExpressionT const& expr ) const CATCH_OVERRIDE { + return !m_matcher->match( expr ); + } + + virtual std::string toString() const CATCH_OVERRIDE { + return "not " + m_matcher->toString(); + } + private: + Ptr< Matcher > m_matcher; + }; + + template + class AllOf : public MatcherImpl, ExpressionT> { + public: + + AllOf() {} + AllOf( AllOf const& other ) : m_matchers( other.m_matchers ) {} + + AllOf& add( Matcher const& matcher ) { + m_matchers.push_back( matcher.clone() ); + return *this; + } + virtual bool match( ExpressionT const& expr ) const + { + for( std::size_t i = 0; i < m_matchers.size(); ++i ) + if( !m_matchers[i]->match( expr ) ) + return false; + return true; + } + virtual std::string toString() const { + std::ostringstream oss; + oss << "( "; + for( std::size_t i = 0; i < m_matchers.size(); ++i ) { + if( i != 0 ) + oss << " and "; + oss << m_matchers[i]->toString(); + } + oss << " )"; + return oss.str(); + } + + AllOf operator && ( Matcher const& other ) const { + AllOf allOfExpr( *this ); + allOfExpr.add( other ); + return allOfExpr; + } + + private: + std::vector > > m_matchers; + }; + + template + class AnyOf : public MatcherImpl, ExpressionT> { + public: + + AnyOf() {} + AnyOf( AnyOf const& other ) : m_matchers( other.m_matchers ) {} + + AnyOf& add( Matcher const& matcher ) { + m_matchers.push_back( matcher.clone() ); + return *this; + } + virtual bool match( ExpressionT const& expr ) const + { + for( std::size_t i = 0; i < m_matchers.size(); ++i ) + if( m_matchers[i]->match( expr ) ) + return true; + return false; + } + virtual std::string toString() const { + std::ostringstream oss; + oss << "( "; + for( std::size_t i = 0; i < m_matchers.size(); ++i ) { + if( i != 0 ) + oss << " or "; + oss << m_matchers[i]->toString(); + } + oss << " )"; + return oss.str(); + } + + AnyOf operator || ( Matcher const& other ) const { + AnyOf anyOfExpr( *this ); + anyOfExpr.add( other ); + return anyOfExpr; + } + + private: + std::vector > > m_matchers; + }; + + } // namespace Generic + + template + Generic::AllOf Matcher::operator && ( Matcher const& other ) const { + Generic::AllOf allOfExpr; + allOfExpr.add( *this ); + allOfExpr.add( other ); + return allOfExpr; + } + + template + Generic::AnyOf Matcher::operator || ( Matcher const& other ) const { + Generic::AnyOf anyOfExpr; + anyOfExpr.add( *this ); + anyOfExpr.add( other ); + return anyOfExpr; + } + + template + Generic::Not Matcher::operator ! () const { + return Generic::Not( *this ); + } + + namespace StdString { + + inline std::string makeString( std::string const& str ) { return str; } + inline std::string makeString( const char* str ) { return str ? std::string( str ) : std::string(); } + + struct CasedString + { + CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity ) + : m_caseSensitivity( caseSensitivity ), + m_str( adjustString( str ) ) + {} + std::string adjustString( std::string const& str ) const { + return m_caseSensitivity == CaseSensitive::No + ? toLower( str ) + : str; + + } + std::string toStringSuffix() const + { + return m_caseSensitivity == CaseSensitive::No + ? " (case insensitive)" + : ""; + } + CaseSensitive::Choice m_caseSensitivity; + std::string m_str; + }; + + struct Equals : MatcherImpl { + Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) + : m_data( str, caseSensitivity ) + {} + Equals( Equals const& other ) : m_data( other.m_data ){} + + virtual ~Equals(); + + virtual bool match( std::string const& expr ) const { + return m_data.m_str == m_data.adjustString( expr );; + } + virtual std::string toString() const { + return "equals: \"" + m_data.m_str + "\"" + m_data.toStringSuffix(); + } + + CasedString m_data; + }; + + struct Contains : MatcherImpl { + Contains( std::string const& substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) + : m_data( substr, caseSensitivity ){} + Contains( Contains const& other ) : m_data( other.m_data ){} + + virtual ~Contains(); + + virtual bool match( std::string const& expr ) const { + return m_data.adjustString( expr ).find( m_data.m_str ) != std::string::npos; + } + virtual std::string toString() const { + return "contains: \"" + m_data.m_str + "\"" + m_data.toStringSuffix(); + } + + CasedString m_data; + }; + + struct StartsWith : MatcherImpl { + StartsWith( std::string const& substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) + : m_data( substr, caseSensitivity ){} + + StartsWith( StartsWith const& other ) : m_data( other.m_data ){} + + virtual ~StartsWith(); + + virtual bool match( std::string const& expr ) const { + return startsWith( m_data.adjustString( expr ), m_data.m_str ); + } + virtual std::string toString() const { + return "starts with: \"" + m_data.m_str + "\"" + m_data.toStringSuffix(); + } + + CasedString m_data; + }; + + struct EndsWith : MatcherImpl { + EndsWith( std::string const& substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) + : m_data( substr, caseSensitivity ){} + EndsWith( EndsWith const& other ) : m_data( other.m_data ){} + + virtual ~EndsWith(); + + virtual bool match( std::string const& expr ) const { + return endsWith( m_data.adjustString( expr ), m_data.m_str ); + } + virtual std::string toString() const { + return "ends with: \"" + m_data.m_str + "\"" + m_data.toStringSuffix(); + } + + CasedString m_data; + }; + } // namespace StdString + } // namespace Impl + + // The following functions create the actual matcher objects. + // This allows the types to be inferred + template + inline Impl::Generic::Not Not( Impl::Matcher const& m ) { + return Impl::Generic::Not( m ); + } + + template + inline Impl::Generic::AllOf AllOf( Impl::Matcher const& m1, + Impl::Matcher const& m2 ) { + return Impl::Generic::AllOf().add( m1 ).add( m2 ); + } + template + inline Impl::Generic::AllOf AllOf( Impl::Matcher const& m1, + Impl::Matcher const& m2, + Impl::Matcher const& m3 ) { + return Impl::Generic::AllOf().add( m1 ).add( m2 ).add( m3 ); + } + template + inline Impl::Generic::AnyOf AnyOf( Impl::Matcher const& m1, + Impl::Matcher const& m2 ) { + return Impl::Generic::AnyOf().add( m1 ).add( m2 ); + } + template + inline Impl::Generic::AnyOf AnyOf( Impl::Matcher const& m1, + Impl::Matcher const& m2, + Impl::Matcher const& m3 ) { + return Impl::Generic::AnyOf().add( m1 ).add( m2 ).add( m3 ); + } + + inline Impl::StdString::Equals Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) { + return Impl::StdString::Equals( str, caseSensitivity ); + } + inline Impl::StdString::Equals Equals( const char* str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) { + return Impl::StdString::Equals( Impl::StdString::makeString( str ), caseSensitivity ); + } + inline Impl::StdString::Contains Contains( std::string const& substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) { + return Impl::StdString::Contains( substr, caseSensitivity ); + } + inline Impl::StdString::Contains Contains( const char* substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) { + return Impl::StdString::Contains( Impl::StdString::makeString( substr ), caseSensitivity ); + } + inline Impl::StdString::StartsWith StartsWith( std::string const& substr ) { + return Impl::StdString::StartsWith( substr ); + } + inline Impl::StdString::StartsWith StartsWith( const char* substr ) { + return Impl::StdString::StartsWith( Impl::StdString::makeString( substr ) ); + } + inline Impl::StdString::EndsWith EndsWith( std::string const& substr ) { + return Impl::StdString::EndsWith( substr ); + } + inline Impl::StdString::EndsWith EndsWith( const char* substr ) { + return Impl::StdString::EndsWith( Impl::StdString::makeString( substr ) ); + } + +} // namespace Matchers + +using namespace Matchers; + +} // namespace Catch + +namespace Catch { + + struct TestFailureException{}; + + template class ExpressionLhs; + + struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison; + + struct CopyableStream { + CopyableStream() {} + CopyableStream( CopyableStream const& other ) { + oss << other.oss.str(); + } + CopyableStream& operator=( CopyableStream const& other ) { + oss.str(""); + oss << other.oss.str(); + return *this; + } + std::ostringstream oss; + }; + + class ResultBuilder { + public: + ResultBuilder( char const* macroName, + SourceLineInfo const& lineInfo, + char const* capturedExpression, + ResultDisposition::Flags resultDisposition, + char const* secondArg = "" ); + + template + ExpressionLhs operator <= ( T const& operand ); + ExpressionLhs operator <= ( bool value ); + + template + ResultBuilder& operator << ( T const& value ) { + m_stream.oss << value; + return *this; + } + + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& ); + + ResultBuilder& setResultType( ResultWas::OfType result ); + ResultBuilder& setResultType( bool result ); + ResultBuilder& setLhs( std::string const& lhs ); + ResultBuilder& setRhs( std::string const& rhs ); + ResultBuilder& setOp( std::string const& op ); + + void endExpression(); + + std::string reconstructExpression() const; + AssertionResult build() const; + + void useActiveException( ResultDisposition::Flags resultDisposition = ResultDisposition::Normal ); + void captureResult( ResultWas::OfType resultType ); + void captureExpression(); + void captureExpectedException( std::string const& expectedMessage ); + void captureExpectedException( Matchers::Impl::Matcher const& matcher ); + void handleResult( AssertionResult const& result ); + void react(); + bool shouldDebugBreak() const; + bool allowThrows() const; + + private: + AssertionInfo m_assertionInfo; + AssertionResultData m_data; + struct ExprComponents { + ExprComponents() : testFalse( false ) {} + bool testFalse; + std::string lhs, rhs, op; + } m_exprComponents; + CopyableStream m_stream; + + bool m_shouldDebugBreak; + bool m_shouldThrow; + }; + +} // namespace Catch + +// Include after due to circular dependency: +// #included from: catch_expression_lhs.hpp +#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED + +// #included from: catch_evaluate.hpp +#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable:4389) // '==' : signed/unsigned mismatch +#endif + +#include + +namespace Catch { +namespace Internal { + + enum Operator { + IsEqualTo, + IsNotEqualTo, + IsLessThan, + IsGreaterThan, + IsLessThanOrEqualTo, + IsGreaterThanOrEqualTo + }; + + template struct OperatorTraits { static const char* getName(){ return "*error*"; } }; + template<> struct OperatorTraits { static const char* getName(){ return "=="; } }; + template<> struct OperatorTraits { static const char* getName(){ return "!="; } }; + template<> struct OperatorTraits { static const char* getName(){ return "<"; } }; + template<> struct OperatorTraits { static const char* getName(){ return ">"; } }; + template<> struct OperatorTraits { static const char* getName(){ return "<="; } }; + template<> struct OperatorTraits{ static const char* getName(){ return ">="; } }; + + template + inline T& opCast(T const& t) { return const_cast(t); } + +// nullptr_t support based on pull request #154 from Konstantin Baumann +#ifdef CATCH_CONFIG_CPP11_NULLPTR + inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; } +#endif // CATCH_CONFIG_CPP11_NULLPTR + + // So the compare overloads can be operator agnostic we convey the operator as a template + // enum, which is used to specialise an Evaluator for doing the comparison. + template + class Evaluator{}; + + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs) { + return bool( opCast( lhs ) == opCast( rhs ) ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return bool( opCast( lhs ) != opCast( rhs ) ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return bool( opCast( lhs ) < opCast( rhs ) ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return bool( opCast( lhs ) > opCast( rhs ) ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return bool( opCast( lhs ) >= opCast( rhs ) ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return bool( opCast( lhs ) <= opCast( rhs ) ); + } + }; + + template + bool applyEvaluator( T1 const& lhs, T2 const& rhs ) { + return Evaluator::evaluate( lhs, rhs ); + } + + // This level of indirection allows us to specialise for integer types + // to avoid signed/ unsigned warnings + + // "base" overload + template + bool compare( T1 const& lhs, T2 const& rhs ) { + return Evaluator::evaluate( lhs, rhs ); + } + + // unsigned X to int + template bool compare( unsigned int lhs, int rhs ) { + return applyEvaluator( lhs, static_cast( rhs ) ); + } + template bool compare( unsigned long lhs, int rhs ) { + return applyEvaluator( lhs, static_cast( rhs ) ); + } + template bool compare( unsigned char lhs, int rhs ) { + return applyEvaluator( lhs, static_cast( rhs ) ); + } + + // unsigned X to long + template bool compare( unsigned int lhs, long rhs ) { + return applyEvaluator( lhs, static_cast( rhs ) ); + } + template bool compare( unsigned long lhs, long rhs ) { + return applyEvaluator( lhs, static_cast( rhs ) ); + } + template bool compare( unsigned char lhs, long rhs ) { + return applyEvaluator( lhs, static_cast( rhs ) ); + } + + // int to unsigned X + template bool compare( int lhs, unsigned int rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( int lhs, unsigned long rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( int lhs, unsigned char rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + + // long to unsigned X + template bool compare( long lhs, unsigned int rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( long lhs, unsigned long rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( long lhs, unsigned char rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + + // pointer to long (when comparing against NULL) + template bool compare( long lhs, T* rhs ) { + return Evaluator::evaluate( reinterpret_cast( lhs ), rhs ); + } + template bool compare( T* lhs, long rhs ) { + return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) ); + } + + // pointer to int (when comparing against NULL) + template bool compare( int lhs, T* rhs ) { + return Evaluator::evaluate( reinterpret_cast( lhs ), rhs ); + } + template bool compare( T* lhs, int rhs ) { + return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) ); + } + +#ifdef CATCH_CONFIG_CPP11_LONG_LONG + // long long to unsigned X + template bool compare( long long lhs, unsigned int rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( long long lhs, unsigned long rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( long long lhs, unsigned long long rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( long long lhs, unsigned char rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + + // unsigned long long to X + template bool compare( unsigned long long lhs, int rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( unsigned long long lhs, long rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( unsigned long long lhs, long long rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( unsigned long long lhs, char rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + + // pointer to long long (when comparing against NULL) + template bool compare( long long lhs, T* rhs ) { + return Evaluator::evaluate( reinterpret_cast( lhs ), rhs ); + } + template bool compare( T* lhs, long long rhs ) { + return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) ); + } +#endif // CATCH_CONFIG_CPP11_LONG_LONG + +#ifdef CATCH_CONFIG_CPP11_NULLPTR + // pointer to nullptr_t (when comparing against nullptr) + template bool compare( std::nullptr_t, T* rhs ) { + return Evaluator::evaluate( nullptr, rhs ); + } + template bool compare( T* lhs, std::nullptr_t ) { + return Evaluator::evaluate( lhs, nullptr ); + } +#endif // CATCH_CONFIG_CPP11_NULLPTR + +} // end of namespace Internal +} // end of namespace Catch + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +// #included from: catch_tostring.h +#define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED + +#include +#include +#include +#include +#include + +#ifdef __OBJC__ +// #included from: catch_objc_arc.hpp +#define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED + +#import + +#ifdef __has_feature +#define CATCH_ARC_ENABLED __has_feature(objc_arc) +#else +#define CATCH_ARC_ENABLED 0 +#endif + +void arcSafeRelease( NSObject* obj ); +id performOptionalSelector( id obj, SEL sel ); + +#if !CATCH_ARC_ENABLED +inline void arcSafeRelease( NSObject* obj ) { + [obj release]; +} +inline id performOptionalSelector( id obj, SEL sel ) { + if( [obj respondsToSelector: sel] ) + return [obj performSelector: sel]; + return nil; +} +#define CATCH_UNSAFE_UNRETAINED +#define CATCH_ARC_STRONG +#else +inline void arcSafeRelease( NSObject* ){} +inline id performOptionalSelector( id obj, SEL sel ) { +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Warc-performSelector-leaks" +#endif + if( [obj respondsToSelector: sel] ) + return [obj performSelector: sel]; +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + return nil; +} +#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained +#define CATCH_ARC_STRONG __strong +#endif + +#endif + +#ifdef CATCH_CONFIG_CPP11_TUPLE +#include +#endif + +#ifdef CATCH_CONFIG_CPP11_IS_ENUM +#include +#endif + +namespace Catch { + +// Why we're here. +template +std::string toString( T const& value ); + +// Built in overloads + +std::string toString( std::string const& value ); +std::string toString( std::wstring const& value ); +std::string toString( const char* const value ); +std::string toString( char* const value ); +std::string toString( const wchar_t* const value ); +std::string toString( wchar_t* const value ); +std::string toString( int value ); +std::string toString( unsigned long value ); +std::string toString( unsigned int value ); +std::string toString( const double value ); +std::string toString( const float value ); +std::string toString( bool value ); +std::string toString( char value ); +std::string toString( signed char value ); +std::string toString( unsigned char value ); + +#ifdef CATCH_CONFIG_CPP11_LONG_LONG +std::string toString( long long value ); +std::string toString( unsigned long long value ); +#endif + +#ifdef CATCH_CONFIG_CPP11_NULLPTR +std::string toString( std::nullptr_t ); +#endif + +#ifdef __OBJC__ + std::string toString( NSString const * const& nsstring ); + std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ); + std::string toString( NSObject* const& nsObject ); +#endif + +namespace Detail { + + extern const std::string unprintableString; + + struct BorgType { + template BorgType( T const& ); + }; + + struct TrueType { char sizer[1]; }; + struct FalseType { char sizer[2]; }; + + TrueType& testStreamable( std::ostream& ); + FalseType testStreamable( FalseType ); + + FalseType operator<<( std::ostream const&, BorgType const& ); + + template + struct IsStreamInsertable { + static std::ostream &s; + static T const&t; + enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) }; + }; + +#if defined(CATCH_CONFIG_CPP11_IS_ENUM) + template::value + > + struct EnumStringMaker + { + static std::string convert( T const& ) { return unprintableString; } + }; + + template + struct EnumStringMaker + { + static std::string convert( T const& v ) + { + return ::Catch::toString( + static_cast::type>(v) + ); + } + }; +#endif + template + struct StringMakerBase { +#if defined(CATCH_CONFIG_CPP11_IS_ENUM) + template + static std::string convert( T const& v ) + { + return EnumStringMaker::convert( v ); + } +#else + template + static std::string convert( T const& ) { return unprintableString; } +#endif + }; + + template<> + struct StringMakerBase { + template + static std::string convert( T const& _value ) { + std::ostringstream oss; + oss << _value; + return oss.str(); + } + }; + + std::string rawMemoryToString( const void *object, std::size_t size ); + + template + inline std::string rawMemoryToString( const T& object ) { + return rawMemoryToString( &object, sizeof(object) ); + } + +} // end namespace Detail + +template +struct StringMaker : + Detail::StringMakerBase::value> {}; + +template +struct StringMaker { + template + static std::string convert( U* p ) { + if( !p ) + return "NULL"; + else + return Detail::rawMemoryToString( p ); + } +}; + +template +struct StringMaker { + static std::string convert( R C::* p ) { + if( !p ) + return "NULL"; + else + return Detail::rawMemoryToString( p ); + } +}; + +namespace Detail { + template + std::string rangeToString( InputIterator first, InputIterator last ); +} + +//template +//struct StringMaker > { +// static std::string convert( std::vector const& v ) { +// return Detail::rangeToString( v.begin(), v.end() ); +// } +//}; + +template +std::string toString( std::vector const& v ) { + return Detail::rangeToString( v.begin(), v.end() ); +} + +#ifdef CATCH_CONFIG_CPP11_TUPLE + +// toString for tuples +namespace TupleDetail { + template< + typename Tuple, + std::size_t N = 0, + bool = (N < std::tuple_size::value) + > + struct ElementPrinter { + static void print( const Tuple& tuple, std::ostream& os ) + { + os << ( N ? ", " : " " ) + << Catch::toString(std::get(tuple)); + ElementPrinter::print(tuple,os); + } + }; + + template< + typename Tuple, + std::size_t N + > + struct ElementPrinter { + static void print( const Tuple&, std::ostream& ) {} + }; + +} + +template +struct StringMaker> { + + static std::string convert( const std::tuple& tuple ) + { + std::ostringstream os; + os << '{'; + TupleDetail::ElementPrinter>::print( tuple, os ); + os << " }"; + return os.str(); + } +}; +#endif // CATCH_CONFIG_CPP11_TUPLE + +namespace Detail { + template + std::string makeString( T const& value ) { + return StringMaker::convert( value ); + } +} // end namespace Detail + +/// \brief converts any type to a string +/// +/// The default template forwards on to ostringstream - except when an +/// ostringstream overload does not exist - in which case it attempts to detect +/// that and writes {?}. +/// Overload (not specialise) this template for custom typs that you don't want +/// to provide an ostream overload for. +template +std::string toString( T const& value ) { + return StringMaker::convert( value ); +} + + namespace Detail { + template + std::string rangeToString( InputIterator first, InputIterator last ) { + std::ostringstream oss; + oss << "{ "; + if( first != last ) { + oss << Catch::toString( *first ); + for( ++first ; first != last ; ++first ) + oss << ", " << Catch::toString( *first ); + } + oss << " }"; + return oss.str(); + } +} + +} // end namespace Catch + +namespace Catch { + +// Wraps the LHS of an expression and captures the operator and RHS (if any) - +// wrapping them all in a ResultBuilder object +template +class ExpressionLhs { + ExpressionLhs& operator = ( ExpressionLhs const& ); +# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + ExpressionLhs& operator = ( ExpressionLhs && ) = delete; +# endif + +public: + ExpressionLhs( ResultBuilder& rb, T lhs ) : m_rb( rb ), m_lhs( lhs ) {} +# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + ExpressionLhs( ExpressionLhs const& ) = default; + ExpressionLhs( ExpressionLhs && ) = default; +# endif + + template + ResultBuilder& operator == ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + ResultBuilder& operator != ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + ResultBuilder& operator < ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + ResultBuilder& operator > ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + ResultBuilder& operator <= ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + ResultBuilder& operator >= ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + ResultBuilder& operator == ( bool rhs ) { + return captureExpression( rhs ); + } + + ResultBuilder& operator != ( bool rhs ) { + return captureExpression( rhs ); + } + + void endExpression() { + bool value = m_lhs ? true : false; + m_rb + .setLhs( Catch::toString( value ) ) + .setResultType( value ) + .endExpression(); + } + + // Only simple binary expressions are allowed on the LHS. + // If more complex compositions are required then place the sub expression in parentheses + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( RhsT const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( RhsT const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( RhsT const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( RhsT const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& ); + +private: + template + ResultBuilder& captureExpression( RhsT const& rhs ) { + return m_rb + .setResultType( Internal::compare( m_lhs, rhs ) ) + .setLhs( Catch::toString( m_lhs ) ) + .setRhs( Catch::toString( rhs ) ) + .setOp( Internal::OperatorTraits::getName() ); + } + +private: + ResultBuilder& m_rb; + T m_lhs; +}; + +} // end namespace Catch + + +namespace Catch { + + template + inline ExpressionLhs ResultBuilder::operator <= ( T const& operand ) { + return ExpressionLhs( *this, operand ); + } + + inline ExpressionLhs ResultBuilder::operator <= ( bool value ) { + return ExpressionLhs( *this, value ); + } + +} // namespace Catch + +// #included from: catch_message.h +#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED + +#include + +namespace Catch { + + struct MessageInfo { + MessageInfo( std::string const& _macroName, + SourceLineInfo const& _lineInfo, + ResultWas::OfType _type ); + + std::string macroName; + SourceLineInfo lineInfo; + ResultWas::OfType type; + std::string message; + unsigned int sequence; + + bool operator == ( MessageInfo const& other ) const { + return sequence == other.sequence; + } + bool operator < ( MessageInfo const& other ) const { + return sequence < other.sequence; + } + private: + static unsigned int globalCount; + }; + + struct MessageBuilder { + MessageBuilder( std::string const& macroName, + SourceLineInfo const& lineInfo, + ResultWas::OfType type ) + : m_info( macroName, lineInfo, type ) + {} + + template + MessageBuilder& operator << ( T const& value ) { + m_stream << value; + return *this; + } + + MessageInfo m_info; + std::ostringstream m_stream; + }; + + class ScopedMessage { + public: + ScopedMessage( MessageBuilder const& builder ); + ScopedMessage( ScopedMessage const& other ); + ~ScopedMessage(); + + MessageInfo m_info; + }; + +} // end namespace Catch + +// #included from: catch_interfaces_capture.h +#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED + +#include + +namespace Catch { + + class TestCase; + class AssertionResult; + struct AssertionInfo; + struct SectionInfo; + struct SectionEndInfo; + struct MessageInfo; + class ScopedMessageBuilder; + struct Counts; + + struct IResultCapture { + + virtual ~IResultCapture(); + + virtual void assertionEnded( AssertionResult const& result ) = 0; + virtual bool sectionStarted( SectionInfo const& sectionInfo, + Counts& assertions ) = 0; + virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0; + virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0; + virtual void pushScopedMessage( MessageInfo const& message ) = 0; + virtual void popScopedMessage( MessageInfo const& message ) = 0; + + virtual std::string getCurrentTestName() const = 0; + virtual const AssertionResult* getLastResult() const = 0; + + virtual void handleFatalErrorCondition( std::string const& message ) = 0; + }; + + IResultCapture& getResultCapture(); +} + +// #included from: catch_debugger.h +#define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED + +// #included from: catch_platform.h +#define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED + +#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) +#define CATCH_PLATFORM_MAC +#elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED) +#define CATCH_PLATFORM_IPHONE +#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) +#define CATCH_PLATFORM_WINDOWS +#endif + +#include + +namespace Catch{ + + bool isDebuggerActive(); + void writeToDebugConsole( std::string const& text ); +} + +#ifdef CATCH_PLATFORM_MAC + + // The following code snippet based on: + // http://cocoawithlove.com/2008/03/break-into-debugger.html + #ifdef DEBUG + #if defined(__ppc64__) || defined(__ppc__) + #define CATCH_BREAK_INTO_DEBUGGER() \ + if( Catch::isDebuggerActive() ) { \ + __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \ + : : : "memory","r0","r3","r4" ); \ + } + #else + #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) {__asm__("int $3\n" : : );} + #endif + #endif + +#elif defined(_MSC_VER) + #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { __debugbreak(); } +#elif defined(__MINGW32__) + extern "C" __declspec(dllimport) void __stdcall DebugBreak(); + #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { DebugBreak(); } +#endif + +#ifndef CATCH_BREAK_INTO_DEBUGGER +#define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue(); +#endif + +// #included from: catch_interfaces_runner.h +#define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED + +namespace Catch { + class TestCase; + + struct IRunner { + virtual ~IRunner(); + virtual bool aborting() const = 0; + }; +} + +/////////////////////////////////////////////////////////////////////////////// +// In the event of a failure works out if the debugger needs to be invoked +// and/or an exception thrown and takes appropriate action. +// This needs to be done as a macro so the debugger will stop in the user +// source code rather than in Catch library code +#define INTERNAL_CATCH_REACT( resultBuilder ) \ + if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \ + resultBuilder.react(); + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ + try { \ + CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ + ( __catchResult <= expr ).endExpression(); \ + } \ + catch( ... ) { \ + __catchResult.useActiveException( Catch::ResultDisposition::Normal ); \ + } \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::isTrue( false && static_cast(expr) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_IF( expr, resultDisposition, macroName ) \ + INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \ + if( Catch::getResultCapture().getLastResult()->succeeded() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_ELSE( expr, resultDisposition, macroName ) \ + INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \ + if( !Catch::getResultCapture().getLastResult()->succeeded() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_NO_THROW( expr, resultDisposition, macroName ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ + try { \ + expr; \ + __catchResult.captureResult( Catch::ResultWas::Ok ); \ + } \ + catch( ... ) { \ + __catchResult.useActiveException( resultDisposition ); \ + } \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::alwaysFalse() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_THROWS( expr, resultDisposition, matcher, macroName ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition, #matcher ); \ + if( __catchResult.allowThrows() ) \ + try { \ + expr; \ + __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \ + } \ + catch( ... ) { \ + __catchResult.captureExpectedException( matcher ); \ + } \ + else \ + __catchResult.captureResult( Catch::ResultWas::Ok ); \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::alwaysFalse() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_THROWS_AS( expr, exceptionType, resultDisposition, macroName ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ + if( __catchResult.allowThrows() ) \ + try { \ + expr; \ + __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \ + } \ + catch( exceptionType ) { \ + __catchResult.captureResult( Catch::ResultWas::Ok ); \ + } \ + catch( ... ) { \ + __catchResult.useActiveException( resultDisposition ); \ + } \ + else \ + __catchResult.captureResult( Catch::ResultWas::Ok ); \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::alwaysFalse() ) + +/////////////////////////////////////////////////////////////////////////////// +#ifdef CATCH_CONFIG_VARIADIC_MACROS + #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, ... ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \ + __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \ + __catchResult.captureResult( messageType ); \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::alwaysFalse() ) +#else + #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, log ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \ + __catchResult << log + ::Catch::StreamEndStop(); \ + __catchResult.captureResult( messageType ); \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::alwaysFalse() ) +#endif + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_INFO( log, macroName ) \ + Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log; + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CHECK_THAT( arg, matcher, resultDisposition, macroName ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg ", " #matcher, resultDisposition ); \ + try { \ + std::string matcherAsString = (matcher).toString(); \ + __catchResult \ + .setLhs( Catch::toString( arg ) ) \ + .setRhs( matcherAsString == Catch::Detail::unprintableString ? #matcher : matcherAsString ) \ + .setOp( "matches" ) \ + .setResultType( (matcher).match( arg ) ); \ + __catchResult.captureExpression(); \ + } catch( ... ) { \ + __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \ + } \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::alwaysFalse() ) + +// #included from: internal/catch_section.h +#define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED + +// #included from: catch_section_info.h +#define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED + +// #included from: catch_totals.hpp +#define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED + +#include + +namespace Catch { + + struct Counts { + Counts() : passed( 0 ), failed( 0 ), failedButOk( 0 ) {} + + Counts operator - ( Counts const& other ) const { + Counts diff; + diff.passed = passed - other.passed; + diff.failed = failed - other.failed; + diff.failedButOk = failedButOk - other.failedButOk; + return diff; + } + Counts& operator += ( Counts const& other ) { + passed += other.passed; + failed += other.failed; + failedButOk += other.failedButOk; + return *this; + } + + std::size_t total() const { + return passed + failed + failedButOk; + } + bool allPassed() const { + return failed == 0 && failedButOk == 0; + } + bool allOk() const { + return failed == 0; + } + + std::size_t passed; + std::size_t failed; + std::size_t failedButOk; + }; + + struct Totals { + + Totals operator - ( Totals const& other ) const { + Totals diff; + diff.assertions = assertions - other.assertions; + diff.testCases = testCases - other.testCases; + return diff; + } + + Totals delta( Totals const& prevTotals ) const { + Totals diff = *this - prevTotals; + if( diff.assertions.failed > 0 ) + ++diff.testCases.failed; + else if( diff.assertions.failedButOk > 0 ) + ++diff.testCases.failedButOk; + else + ++diff.testCases.passed; + return diff; + } + + Totals& operator += ( Totals const& other ) { + assertions += other.assertions; + testCases += other.testCases; + return *this; + } + + Counts assertions; + Counts testCases; + }; +} + +namespace Catch { + + struct SectionInfo { + SectionInfo + ( SourceLineInfo const& _lineInfo, + std::string const& _name, + std::string const& _description = std::string() ); + + std::string name; + std::string description; + SourceLineInfo lineInfo; + }; + + struct SectionEndInfo { + SectionEndInfo( SectionInfo const& _sectionInfo, Counts const& _prevAssertions, double _durationInSeconds ) + : sectionInfo( _sectionInfo ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds ) + {} + + SectionInfo sectionInfo; + Counts prevAssertions; + double durationInSeconds; + }; + +} // end namespace Catch + +// #included from: catch_timer.h +#define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED + +#ifdef CATCH_PLATFORM_WINDOWS +typedef unsigned long long uint64_t; +#else +#include +#endif + +namespace Catch { + + class Timer { + public: + Timer() : m_ticks( 0 ) {} + void start(); + unsigned int getElapsedMicroseconds() const; + unsigned int getElapsedMilliseconds() const; + double getElapsedSeconds() const; + + private: + uint64_t m_ticks; + }; + +} // namespace Catch + +#include + +namespace Catch { + + class Section : NonCopyable { + public: + Section( SectionInfo const& info ); + ~Section(); + + // This indicates whether the section should be executed or not + operator bool() const; + + private: + SectionInfo m_info; + + std::string m_name; + Counts m_assertions; + bool m_sectionIncluded; + Timer m_timer; + }; + +} // end namespace Catch + +#ifdef CATCH_CONFIG_VARIADIC_MACROS + #define INTERNAL_CATCH_SECTION( ... ) \ + if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) +#else + #define INTERNAL_CATCH_SECTION( name, desc ) \ + if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, name, desc ) ) +#endif + +// #included from: internal/catch_generators.hpp +#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED + +#include +#include +#include +#include + +namespace Catch { + +template +struct IGenerator { + virtual ~IGenerator() {} + virtual T getValue( std::size_t index ) const = 0; + virtual std::size_t size () const = 0; +}; + +template +class BetweenGenerator : public IGenerator { +public: + BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){} + + virtual T getValue( std::size_t index ) const { + return m_from+static_cast( index ); + } + + virtual std::size_t size() const { + return static_cast( 1+m_to-m_from ); + } + +private: + + T m_from; + T m_to; +}; + +template +class ValuesGenerator : public IGenerator { +public: + ValuesGenerator(){} + + void add( T value ) { + m_values.push_back( value ); + } + + virtual T getValue( std::size_t index ) const { + return m_values[index]; + } + + virtual std::size_t size() const { + return m_values.size(); + } + +private: + std::vector m_values; +}; + +template +class CompositeGenerator { +public: + CompositeGenerator() : m_totalSize( 0 ) {} + + // *** Move semantics, similar to auto_ptr *** + CompositeGenerator( CompositeGenerator& other ) + : m_fileInfo( other.m_fileInfo ), + m_totalSize( 0 ) + { + move( other ); + } + + CompositeGenerator& setFileInfo( const char* fileInfo ) { + m_fileInfo = fileInfo; + return *this; + } + + ~CompositeGenerator() { + deleteAll( m_composed ); + } + + operator T () const { + size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize ); + + typename std::vector*>::const_iterator it = m_composed.begin(); + typename std::vector*>::const_iterator itEnd = m_composed.end(); + for( size_t index = 0; it != itEnd; ++it ) + { + const IGenerator* generator = *it; + if( overallIndex >= index && overallIndex < index + generator->size() ) + { + return generator->getValue( overallIndex-index ); + } + index += generator->size(); + } + CATCH_INTERNAL_ERROR( "Indexed past end of generated range" ); + return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so + } + + void add( const IGenerator* generator ) { + m_totalSize += generator->size(); + m_composed.push_back( generator ); + } + + CompositeGenerator& then( CompositeGenerator& other ) { + move( other ); + return *this; + } + + CompositeGenerator& then( T value ) { + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( value ); + add( valuesGen ); + return *this; + } + +private: + + void move( CompositeGenerator& other ) { + std::copy( other.m_composed.begin(), other.m_composed.end(), std::back_inserter( m_composed ) ); + m_totalSize += other.m_totalSize; + other.m_composed.clear(); + } + + std::vector*> m_composed; + std::string m_fileInfo; + size_t m_totalSize; +}; + +namespace Generators +{ + template + CompositeGenerator between( T from, T to ) { + CompositeGenerator generators; + generators.add( new BetweenGenerator( from, to ) ); + return generators; + } + + template + CompositeGenerator values( T val1, T val2 ) { + CompositeGenerator generators; + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( val1 ); + valuesGen->add( val2 ); + generators.add( valuesGen ); + return generators; + } + + template + CompositeGenerator values( T val1, T val2, T val3 ){ + CompositeGenerator generators; + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( val1 ); + valuesGen->add( val2 ); + valuesGen->add( val3 ); + generators.add( valuesGen ); + return generators; + } + + template + CompositeGenerator values( T val1, T val2, T val3, T val4 ) { + CompositeGenerator generators; + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( val1 ); + valuesGen->add( val2 ); + valuesGen->add( val3 ); + valuesGen->add( val4 ); + generators.add( valuesGen ); + return generators; + } + +} // end namespace Generators + +using namespace Generators; + +} // end namespace Catch + +#define INTERNAL_CATCH_LINESTR2( line ) #line +#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line ) + +#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" ) + +// #included from: internal/catch_interfaces_exception.h +#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED + +#include +#include + +// #included from: catch_interfaces_registry_hub.h +#define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED + +#include + +namespace Catch { + + class TestCase; + struct ITestCaseRegistry; + struct IExceptionTranslatorRegistry; + struct IExceptionTranslator; + struct IReporterRegistry; + struct IReporterFactory; + + struct IRegistryHub { + virtual ~IRegistryHub(); + + virtual IReporterRegistry const& getReporterRegistry() const = 0; + virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0; + virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0; + }; + + struct IMutableRegistryHub { + virtual ~IMutableRegistryHub(); + virtual void registerReporter( std::string const& name, Ptr const& factory ) = 0; + virtual void registerListener( Ptr const& factory ) = 0; + virtual void registerTest( TestCase const& testInfo ) = 0; + virtual void registerTranslator( const IExceptionTranslator* translator ) = 0; + }; + + IRegistryHub& getRegistryHub(); + IMutableRegistryHub& getMutableRegistryHub(); + void cleanUp(); + std::string translateActiveException(); + +} + +namespace Catch { + + typedef std::string(*exceptionTranslateFunction)(); + + struct IExceptionTranslator; + typedef std::vector ExceptionTranslators; + + struct IExceptionTranslator { + virtual ~IExceptionTranslator(); + virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0; + }; + + struct IExceptionTranslatorRegistry { + virtual ~IExceptionTranslatorRegistry(); + + virtual std::string translateActiveException() const = 0; + }; + + class ExceptionTranslatorRegistrar { + template + class ExceptionTranslator : public IExceptionTranslator { + public: + + ExceptionTranslator( std::string(*translateFunction)( T& ) ) + : m_translateFunction( translateFunction ) + {} + + virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const CATCH_OVERRIDE { + try { + if( it == itEnd ) + throw; + else + return (*it)->translate( it+1, itEnd ); + } + catch( T& ex ) { + return m_translateFunction( ex ); + } + } + + protected: + std::string(*m_translateFunction)( T& ); + }; + + public: + template + ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) { + getMutableRegistryHub().registerTranslator + ( new ExceptionTranslator( translateFunction ) ); + } + }; +} + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \ + static std::string translatorName( signature ); \ + namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); }\ + static std::string translatorName( signature ) + +#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature ) + +// #included from: internal/catch_approx.hpp +#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED + +#include +#include + +namespace Catch { +namespace Detail { + + class Approx { + public: + explicit Approx ( double value ) + : m_epsilon( std::numeric_limits::epsilon()*100 ), + m_scale( 1.0 ), + m_value( value ) + {} + + Approx( Approx const& other ) + : m_epsilon( other.m_epsilon ), + m_scale( other.m_scale ), + m_value( other.m_value ) + {} + + static Approx custom() { + return Approx( 0 ); + } + + Approx operator()( double value ) { + Approx approx( value ); + approx.epsilon( m_epsilon ); + approx.scale( m_scale ); + return approx; + } + + friend bool operator == ( double lhs, Approx const& rhs ) { + // Thanks to Richard Harris for his help refining this formula + return fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( fabs(lhs), fabs(rhs.m_value) ) ); + } + + friend bool operator == ( Approx const& lhs, double rhs ) { + return operator==( rhs, lhs ); + } + + friend bool operator != ( double lhs, Approx const& rhs ) { + return !operator==( lhs, rhs ); + } + + friend bool operator != ( Approx const& lhs, double rhs ) { + return !operator==( rhs, lhs ); + } + + Approx& epsilon( double newEpsilon ) { + m_epsilon = newEpsilon; + return *this; + } + + Approx& scale( double newScale ) { + m_scale = newScale; + return *this; + } + + std::string toString() const { + std::ostringstream oss; + oss << "Approx( " << Catch::toString( m_value ) << " )"; + return oss.str(); + } + + private: + double m_epsilon; + double m_scale; + double m_value; + }; +} + +template<> +inline std::string toString( Detail::Approx const& value ) { + return value.toString(); +} + +} // end namespace Catch + +// #included from: internal/catch_interfaces_tag_alias_registry.h +#define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED + +// #included from: catch_tag_alias.h +#define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED + +#include + +namespace Catch { + + struct TagAlias { + TagAlias( std::string _tag, SourceLineInfo _lineInfo ) : tag( _tag ), lineInfo( _lineInfo ) {} + + std::string tag; + SourceLineInfo lineInfo; + }; + + struct RegistrarForTagAliases { + RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); + }; + +} // end namespace Catch + +#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } +// #included from: catch_option.hpp +#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED + +namespace Catch { + + // An optional type + template + class Option { + public: + Option() : nullableValue( CATCH_NULL ) {} + Option( T const& _value ) + : nullableValue( new( storage ) T( _value ) ) + {} + Option( Option const& _other ) + : nullableValue( _other ? new( storage ) T( *_other ) : CATCH_NULL ) + {} + + ~Option() { + reset(); + } + + Option& operator= ( Option const& _other ) { + if( &_other != this ) { + reset(); + if( _other ) + nullableValue = new( storage ) T( *_other ); + } + return *this; + } + Option& operator = ( T const& _value ) { + reset(); + nullableValue = new( storage ) T( _value ); + return *this; + } + + void reset() { + if( nullableValue ) + nullableValue->~T(); + nullableValue = CATCH_NULL; + } + + T& operator*() { return *nullableValue; } + T const& operator*() const { return *nullableValue; } + T* operator->() { return nullableValue; } + const T* operator->() const { return nullableValue; } + + T valueOr( T const& defaultValue ) const { + return nullableValue ? *nullableValue : defaultValue; + } + + bool some() const { return nullableValue != CATCH_NULL; } + bool none() const { return nullableValue == CATCH_NULL; } + + bool operator !() const { return nullableValue == CATCH_NULL; } + operator SafeBool::type() const { + return SafeBool::makeSafe( some() ); + } + + private: + T* nullableValue; + char storage[sizeof(T)]; + }; + +} // end namespace Catch + +namespace Catch { + + struct ITagAliasRegistry { + virtual ~ITagAliasRegistry(); + virtual Option find( std::string const& alias ) const = 0; + virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0; + + static ITagAliasRegistry const& get(); + }; + +} // end namespace Catch + +// These files are included here so the single_include script doesn't put them +// in the conditionally compiled sections +// #included from: internal/catch_test_case_info.h +#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED + +#include +#include + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wpadded" +#endif + +namespace Catch { + + struct ITestCase; + + struct TestCaseInfo { + enum SpecialProperties{ + None = 0, + IsHidden = 1 << 1, + ShouldFail = 1 << 2, + MayFail = 1 << 3, + Throws = 1 << 4 + }; + + TestCaseInfo( std::string const& _name, + std::string const& _className, + std::string const& _description, + std::set const& _tags, + SourceLineInfo const& _lineInfo ); + + TestCaseInfo( TestCaseInfo const& other ); + + friend void setTags( TestCaseInfo& testCaseInfo, std::set const& tags ); + + bool isHidden() const; + bool throws() const; + bool okToFail() const; + bool expectedToFail() const; + + std::string name; + std::string className; + std::string description; + std::set tags; + std::set lcaseTags; + std::string tagsAsString; + SourceLineInfo lineInfo; + SpecialProperties properties; + }; + + class TestCase : public TestCaseInfo { + public: + + TestCase( ITestCase* testCase, TestCaseInfo const& info ); + TestCase( TestCase const& other ); + + TestCase withName( std::string const& _newName ) const; + + void invoke() const; + + TestCaseInfo const& getTestCaseInfo() const; + + void swap( TestCase& other ); + bool operator == ( TestCase const& other ) const; + bool operator < ( TestCase const& other ) const; + TestCase& operator = ( TestCase const& other ); + + private: + Ptr test; + }; + + TestCase makeTestCase( ITestCase* testCase, + std::string const& className, + std::string const& name, + std::string const& description, + SourceLineInfo const& lineInfo ); +} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + + +#ifdef __OBJC__ +// #included from: internal/catch_objc.hpp +#define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED + +#import + +#include + +// NB. Any general catch headers included here must be included +// in catch.hpp first to make sure they are included by the single +// header for non obj-usage + +/////////////////////////////////////////////////////////////////////////////// +// This protocol is really only here for (self) documenting purposes, since +// all its methods are optional. +@protocol OcFixture + +@optional + +-(void) setUp; +-(void) tearDown; + +@end + +namespace Catch { + + class OcMethod : public SharedImpl { + + public: + OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {} + + virtual void invoke() const { + id obj = [[m_cls alloc] init]; + + performOptionalSelector( obj, @selector(setUp) ); + performOptionalSelector( obj, m_sel ); + performOptionalSelector( obj, @selector(tearDown) ); + + arcSafeRelease( obj ); + } + private: + virtual ~OcMethod() {} + + Class m_cls; + SEL m_sel; + }; + + namespace Detail{ + + inline std::string getAnnotation( Class cls, + std::string const& annotationName, + std::string const& testCaseName ) { + NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()]; + SEL sel = NSSelectorFromString( selStr ); + arcSafeRelease( selStr ); + id value = performOptionalSelector( cls, sel ); + if( value ) + return [(NSString*)value UTF8String]; + return ""; + } + } + + inline size_t registerTestMethods() { + size_t noTestMethods = 0; + int noClasses = objc_getClassList( CATCH_NULL, 0 ); + + Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses); + objc_getClassList( classes, noClasses ); + + for( int c = 0; c < noClasses; c++ ) { + Class cls = classes[c]; + { + u_int count; + Method* methods = class_copyMethodList( cls, &count ); + for( u_int m = 0; m < count ; m++ ) { + SEL selector = method_getName(methods[m]); + std::string methodName = sel_getName(selector); + if( startsWith( methodName, "Catch_TestCase_" ) ) { + std::string testCaseName = methodName.substr( 15 ); + std::string name = Detail::getAnnotation( cls, "Name", testCaseName ); + std::string desc = Detail::getAnnotation( cls, "Description", testCaseName ); + const char* className = class_getName( cls ); + + getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) ); + noTestMethods++; + } + } + free(methods); + } + } + return noTestMethods; + } + + namespace Matchers { + namespace Impl { + namespace NSStringMatchers { + + template + struct StringHolder : MatcherImpl{ + StringHolder( NSString* substr ) : m_substr( [substr copy] ){} + StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){} + StringHolder() { + arcSafeRelease( m_substr ); + } + + NSString* m_substr; + }; + + struct Equals : StringHolder { + Equals( NSString* substr ) : StringHolder( substr ){} + + virtual bool match( ExpressionType const& str ) const { + return (str != nil || m_substr == nil ) && + [str isEqualToString:m_substr]; + } + + virtual std::string toString() const { + return "equals string: " + Catch::toString( m_substr ); + } + }; + + struct Contains : StringHolder { + Contains( NSString* substr ) : StringHolder( substr ){} + + virtual bool match( ExpressionType const& str ) const { + return (str != nil || m_substr == nil ) && + [str rangeOfString:m_substr].location != NSNotFound; + } + + virtual std::string toString() const { + return "contains string: " + Catch::toString( m_substr ); + } + }; + + struct StartsWith : StringHolder { + StartsWith( NSString* substr ) : StringHolder( substr ){} + + virtual bool match( ExpressionType const& str ) const { + return (str != nil || m_substr == nil ) && + [str rangeOfString:m_substr].location == 0; + } + + virtual std::string toString() const { + return "starts with: " + Catch::toString( m_substr ); + } + }; + struct EndsWith : StringHolder { + EndsWith( NSString* substr ) : StringHolder( substr ){} + + virtual bool match( ExpressionType const& str ) const { + return (str != nil || m_substr == nil ) && + [str rangeOfString:m_substr].location == [str length] - [m_substr length]; + } + + virtual std::string toString() const { + return "ends with: " + Catch::toString( m_substr ); + } + }; + + } // namespace NSStringMatchers + } // namespace Impl + + inline Impl::NSStringMatchers::Equals + Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); } + + inline Impl::NSStringMatchers::Contains + Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); } + + inline Impl::NSStringMatchers::StartsWith + StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); } + + inline Impl::NSStringMatchers::EndsWith + EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); } + + } // namespace Matchers + + using namespace Matchers; + +} // namespace Catch + +/////////////////////////////////////////////////////////////////////////////// +#define OC_TEST_CASE( name, desc )\ ++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \ +{\ +return @ name; \ +}\ ++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \ +{ \ +return @ desc; \ +} \ +-(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test ) + +#endif + +#ifdef CATCH_IMPL +// #included from: internal/catch_impl.hpp +#define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED + +// Collect all the implementation files together here +// These are the equivalent of what would usually be cpp files + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wweak-vtables" +#endif + +// #included from: ../catch_session.hpp +#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED + +// #included from: internal/catch_commandline.hpp +#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED + +// #included from: catch_config.hpp +#define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED + +// #included from: catch_test_spec_parser.hpp +#define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wpadded" +#endif + +// #included from: catch_test_spec.hpp +#define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wpadded" +#endif + +// #included from: catch_wildcard_pattern.hpp +#define TWOBLUECUBES_CATCH_WILDCARD_PATTERN_HPP_INCLUDED + +namespace Catch +{ + class WildcardPattern { + enum WildcardPosition { + NoWildcard = 0, + WildcardAtStart = 1, + WildcardAtEnd = 2, + WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd + }; + + public: + + WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity ) + : m_caseSensitivity( caseSensitivity ), + m_wildcard( NoWildcard ), + m_pattern( adjustCase( pattern ) ) + { + if( startsWith( m_pattern, "*" ) ) { + m_pattern = m_pattern.substr( 1 ); + m_wildcard = WildcardAtStart; + } + if( endsWith( m_pattern, "*" ) ) { + m_pattern = m_pattern.substr( 0, m_pattern.size()-1 ); + m_wildcard = static_cast( m_wildcard | WildcardAtEnd ); + } + } + virtual ~WildcardPattern(); + virtual bool matches( std::string const& str ) const { + switch( m_wildcard ) { + case NoWildcard: + return m_pattern == adjustCase( str ); + case WildcardAtStart: + return endsWith( adjustCase( str ), m_pattern ); + case WildcardAtEnd: + return startsWith( adjustCase( str ), m_pattern ); + case WildcardAtBothEnds: + return contains( adjustCase( str ), m_pattern ); + } + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunreachable-code" +#endif + throw std::logic_error( "Unknown enum" ); +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + } + private: + std::string adjustCase( std::string const& str ) const { + return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str; + } + CaseSensitive::Choice m_caseSensitivity; + WildcardPosition m_wildcard; + std::string m_pattern; + }; +} + +#include +#include + +namespace Catch { + + class TestSpec { + struct Pattern : SharedImpl<> { + virtual ~Pattern(); + virtual bool matches( TestCaseInfo const& testCase ) const = 0; + }; + class NamePattern : public Pattern { + public: + NamePattern( std::string const& name ) + : m_wildcardPattern( toLower( name ), CaseSensitive::No ) + {} + virtual ~NamePattern(); + virtual bool matches( TestCaseInfo const& testCase ) const { + return m_wildcardPattern.matches( toLower( testCase.name ) ); + } + private: + WildcardPattern m_wildcardPattern; + }; + + class TagPattern : public Pattern { + public: + TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {} + virtual ~TagPattern(); + virtual bool matches( TestCaseInfo const& testCase ) const { + return testCase.lcaseTags.find( m_tag ) != testCase.lcaseTags.end(); + } + private: + std::string m_tag; + }; + + class ExcludedPattern : public Pattern { + public: + ExcludedPattern( Ptr const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {} + virtual ~ExcludedPattern(); + virtual bool matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); } + private: + Ptr m_underlyingPattern; + }; + + struct Filter { + std::vector > m_patterns; + + bool matches( TestCaseInfo const& testCase ) const { + // All patterns in a filter must match for the filter to be a match + for( std::vector >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it ) + if( !(*it)->matches( testCase ) ) + return false; + return true; + } + }; + + public: + bool hasFilters() const { + return !m_filters.empty(); + } + bool matches( TestCaseInfo const& testCase ) const { + // A TestSpec matches if any filter matches + for( std::vector::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it ) + if( it->matches( testCase ) ) + return true; + return false; + } + + private: + std::vector m_filters; + + friend class TestSpecParser; + }; +} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +namespace Catch { + + class TestSpecParser { + enum Mode{ None, Name, QuotedName, Tag }; + Mode m_mode; + bool m_exclusion; + std::size_t m_start, m_pos; + std::string m_arg; + TestSpec::Filter m_currentFilter; + TestSpec m_testSpec; + ITagAliasRegistry const* m_tagAliases; + + public: + TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {} + + TestSpecParser& parse( std::string const& arg ) { + m_mode = None; + m_exclusion = false; + m_start = std::string::npos; + m_arg = m_tagAliases->expandAliases( arg ); + for( m_pos = 0; m_pos < m_arg.size(); ++m_pos ) + visitChar( m_arg[m_pos] ); + if( m_mode == Name ) + addPattern(); + return *this; + } + TestSpec testSpec() { + addFilter(); + return m_testSpec; + } + private: + void visitChar( char c ) { + if( m_mode == None ) { + switch( c ) { + case ' ': return; + case '~': m_exclusion = true; return; + case '[': return startNewMode( Tag, ++m_pos ); + case '"': return startNewMode( QuotedName, ++m_pos ); + default: startNewMode( Name, m_pos ); break; + } + } + if( m_mode == Name ) { + if( c == ',' ) { + addPattern(); + addFilter(); + } + else if( c == '[' ) { + if( subString() == "exclude:" ) + m_exclusion = true; + else + addPattern(); + startNewMode( Tag, ++m_pos ); + } + } + else if( m_mode == QuotedName && c == '"' ) + addPattern(); + else if( m_mode == Tag && c == ']' ) + addPattern(); + } + void startNewMode( Mode mode, std::size_t start ) { + m_mode = mode; + m_start = start; + } + std::string subString() const { return m_arg.substr( m_start, m_pos - m_start ); } + template + void addPattern() { + std::string token = subString(); + if( startsWith( token, "exclude:" ) ) { + m_exclusion = true; + token = token.substr( 8 ); + } + if( !token.empty() ) { + Ptr pattern = new T( token ); + if( m_exclusion ) + pattern = new TestSpec::ExcludedPattern( pattern ); + m_currentFilter.m_patterns.push_back( pattern ); + } + m_exclusion = false; + m_mode = None; + } + void addFilter() { + if( !m_currentFilter.m_patterns.empty() ) { + m_testSpec.m_filters.push_back( m_currentFilter ); + m_currentFilter = TestSpec::Filter(); + } + } + }; + inline TestSpec parseTestSpec( std::string const& arg ) { + return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec(); + } + +} // namespace Catch + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +// #included from: catch_interfaces_config.h +#define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED + +#include +#include +#include + +namespace Catch { + + struct Verbosity { enum Level { + NoOutput = 0, + Quiet, + Normal + }; }; + + struct WarnAbout { enum What { + Nothing = 0x00, + NoAssertions = 0x01 + }; }; + + struct ShowDurations { enum OrNot { + DefaultForReporter, + Always, + Never + }; }; + struct RunTests { enum InWhatOrder { + InDeclarationOrder, + InLexicographicalOrder, + InRandomOrder + }; }; + struct UseColour { enum YesOrNo { + Auto, + Yes, + No + }; }; + + class TestSpec; + + struct IConfig : IShared { + + virtual ~IConfig(); + + virtual bool allowThrows() const = 0; + virtual std::ostream& stream() const = 0; + virtual std::string name() const = 0; + virtual bool includeSuccessfulResults() const = 0; + virtual bool shouldDebugBreak() const = 0; + virtual bool warnAboutMissingAssertions() const = 0; + virtual int abortAfter() const = 0; + virtual bool showInvisibles() const = 0; + virtual ShowDurations::OrNot showDurations() const = 0; + virtual TestSpec const& testSpec() const = 0; + virtual RunTests::InWhatOrder runOrder() const = 0; + virtual unsigned int rngSeed() const = 0; + virtual UseColour::YesOrNo useColour() const = 0; + }; +} + +// #included from: catch_stream.h +#define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED + +// #included from: catch_streambuf.h +#define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED + +#include + +namespace Catch { + + class StreamBufBase : public std::streambuf { + public: + virtual ~StreamBufBase() CATCH_NOEXCEPT; + }; +} + +#include +#include +#include + +namespace Catch { + + std::ostream& cout(); + std::ostream& cerr(); + + struct IStream { + virtual ~IStream() CATCH_NOEXCEPT; + virtual std::ostream& stream() const = 0; + }; + + class FileStream : public IStream { + mutable std::ofstream m_ofs; + public: + FileStream( std::string const& filename ); + virtual ~FileStream() CATCH_NOEXCEPT; + public: // IStream + virtual std::ostream& stream() const CATCH_OVERRIDE; + }; + + class CoutStream : public IStream { + mutable std::ostream m_os; + public: + CoutStream(); + virtual ~CoutStream() CATCH_NOEXCEPT; + + public: // IStream + virtual std::ostream& stream() const CATCH_OVERRIDE; + }; + + class DebugOutStream : public IStream { + std::auto_ptr m_streamBuf; + mutable std::ostream m_os; + public: + DebugOutStream(); + virtual ~DebugOutStream() CATCH_NOEXCEPT; + + public: // IStream + virtual std::ostream& stream() const CATCH_OVERRIDE; + }; +} + +#include +#include +#include +#include +#include + +#ifndef CATCH_CONFIG_CONSOLE_WIDTH +#define CATCH_CONFIG_CONSOLE_WIDTH 80 +#endif + +namespace Catch { + + struct ConfigData { + + ConfigData() + : listTests( false ), + listTags( false ), + listReporters( false ), + listTestNamesOnly( false ), + showSuccessfulTests( false ), + shouldDebugBreak( false ), + noThrow( false ), + showHelp( false ), + showInvisibles( false ), + filenamesAsTags( false ), + abortAfter( -1 ), + rngSeed( 0 ), + verbosity( Verbosity::Normal ), + warnings( WarnAbout::Nothing ), + showDurations( ShowDurations::DefaultForReporter ), + runOrder( RunTests::InDeclarationOrder ), + useColour( UseColour::Auto ) + {} + + bool listTests; + bool listTags; + bool listReporters; + bool listTestNamesOnly; + + bool showSuccessfulTests; + bool shouldDebugBreak; + bool noThrow; + bool showHelp; + bool showInvisibles; + bool filenamesAsTags; + + int abortAfter; + unsigned int rngSeed; + + Verbosity::Level verbosity; + WarnAbout::What warnings; + ShowDurations::OrNot showDurations; + RunTests::InWhatOrder runOrder; + UseColour::YesOrNo useColour; + + std::string outputFilename; + std::string name; + std::string processName; + + std::vector reporterNames; + std::vector testsOrTags; + }; + + class Config : public SharedImpl { + private: + Config( Config const& other ); + Config& operator = ( Config const& other ); + virtual void dummy(); + public: + + Config() + {} + + Config( ConfigData const& data ) + : m_data( data ), + m_stream( openStream() ) + { + if( !data.testsOrTags.empty() ) { + TestSpecParser parser( ITagAliasRegistry::get() ); + for( std::size_t i = 0; i < data.testsOrTags.size(); ++i ) + parser.parse( data.testsOrTags[i] ); + m_testSpec = parser.testSpec(); + } + } + + virtual ~Config() { + } + + std::string const& getFilename() const { + return m_data.outputFilename ; + } + + bool listTests() const { return m_data.listTests; } + bool listTestNamesOnly() const { return m_data.listTestNamesOnly; } + bool listTags() const { return m_data.listTags; } + bool listReporters() const { return m_data.listReporters; } + + std::string getProcessName() const { return m_data.processName; } + + bool shouldDebugBreak() const { return m_data.shouldDebugBreak; } + + std::vector getReporterNames() const { return m_data.reporterNames; } + + int abortAfter() const { return m_data.abortAfter; } + + TestSpec const& testSpec() const { return m_testSpec; } + + bool showHelp() const { return m_data.showHelp; } + bool showInvisibles() const { return m_data.showInvisibles; } + + // IConfig interface + virtual bool allowThrows() const { return !m_data.noThrow; } + virtual std::ostream& stream() const { return m_stream->stream(); } + virtual std::string name() const { return m_data.name.empty() ? m_data.processName : m_data.name; } + virtual bool includeSuccessfulResults() const { return m_data.showSuccessfulTests; } + virtual bool warnAboutMissingAssertions() const { return m_data.warnings & WarnAbout::NoAssertions; } + virtual ShowDurations::OrNot showDurations() const { return m_data.showDurations; } + virtual RunTests::InWhatOrder runOrder() const { return m_data.runOrder; } + virtual unsigned int rngSeed() const { return m_data.rngSeed; } + virtual UseColour::YesOrNo useColour() const { return m_data.useColour; } + + private: + + IStream const* openStream() { + if( m_data.outputFilename.empty() ) + return new CoutStream(); + else if( m_data.outputFilename[0] == '%' ) { + if( m_data.outputFilename == "%debug" ) + return new DebugOutStream(); + else + throw std::domain_error( "Unrecognised stream: " + m_data.outputFilename ); + } + else + return new FileStream( m_data.outputFilename ); + } + ConfigData m_data; + + std::auto_ptr m_stream; + TestSpec m_testSpec; + }; + +} // end namespace Catch + +// #included from: catch_clara.h +#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED + +// Use Catch's value for console width (store Clara's off to the side, if present) +#ifdef CLARA_CONFIG_CONSOLE_WIDTH +#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH +#undef CLARA_CONFIG_CONSOLE_WIDTH +#endif +#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH + +// Declare Clara inside the Catch namespace +#define STITCH_CLARA_OPEN_NAMESPACE namespace Catch { +// #included from: ../external/clara.h + +// Version 0.0.1.1 + +// Only use header guard if we are not using an outer namespace +#if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE) + +#ifndef STITCH_CLARA_OPEN_NAMESPACE +#define TWOBLUECUBES_CLARA_H_INCLUDED +#define STITCH_CLARA_OPEN_NAMESPACE +#define STITCH_CLARA_CLOSE_NAMESPACE +#else +#define STITCH_CLARA_CLOSE_NAMESPACE } +#endif + +#define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE + +// ----------- #included from tbc_text_format.h ----------- + +// Only use header guard if we are not using an outer namespace +#if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE) +#ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE +#define TBC_TEXT_FORMAT_H_INCLUDED +#endif + +#include +#include +#include +#include + +// Use optional outer namespace +#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE +namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE { +#endif + +namespace Tbc { + +#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH + const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH; +#else + const unsigned int consoleWidth = 80; +#endif + + struct TextAttributes { + TextAttributes() + : initialIndent( std::string::npos ), + indent( 0 ), + width( consoleWidth-1 ), + tabChar( '\t' ) + {} + + TextAttributes& setInitialIndent( std::size_t _value ) { initialIndent = _value; return *this; } + TextAttributes& setIndent( std::size_t _value ) { indent = _value; return *this; } + TextAttributes& setWidth( std::size_t _value ) { width = _value; return *this; } + TextAttributes& setTabChar( char _value ) { tabChar = _value; return *this; } + + std::size_t initialIndent; // indent of first line, or npos + std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos + std::size_t width; // maximum width of text, including indent. Longer text will wrap + char tabChar; // If this char is seen the indent is changed to current pos + }; + + class Text { + public: + Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() ) + : attr( _attr ) + { + std::string wrappableChars = " [({.,/|\\-"; + std::size_t indent = _attr.initialIndent != std::string::npos + ? _attr.initialIndent + : _attr.indent; + std::string remainder = _str; + + while( !remainder.empty() ) { + if( lines.size() >= 1000 ) { + lines.push_back( "... message truncated due to excessive size" ); + return; + } + std::size_t tabPos = std::string::npos; + std::size_t width = (std::min)( remainder.size(), _attr.width - indent ); + std::size_t pos = remainder.find_first_of( '\n' ); + if( pos <= width ) { + width = pos; + } + pos = remainder.find_last_of( _attr.tabChar, width ); + if( pos != std::string::npos ) { + tabPos = pos; + if( remainder[width] == '\n' ) + width--; + remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 ); + } + + if( width == remainder.size() ) { + spliceLine( indent, remainder, width ); + } + else if( remainder[width] == '\n' ) { + spliceLine( indent, remainder, width ); + if( width <= 1 || remainder.size() != 1 ) + remainder = remainder.substr( 1 ); + indent = _attr.indent; + } + else { + pos = remainder.find_last_of( wrappableChars, width ); + if( pos != std::string::npos && pos > 0 ) { + spliceLine( indent, remainder, pos ); + if( remainder[0] == ' ' ) + remainder = remainder.substr( 1 ); + } + else { + spliceLine( indent, remainder, width-1 ); + lines.back() += "-"; + } + if( lines.size() == 1 ) + indent = _attr.indent; + if( tabPos != std::string::npos ) + indent += tabPos; + } + } + } + + void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) { + lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) ); + _remainder = _remainder.substr( _pos ); + } + + typedef std::vector::const_iterator const_iterator; + + const_iterator begin() const { return lines.begin(); } + const_iterator end() const { return lines.end(); } + std::string const& last() const { return lines.back(); } + std::size_t size() const { return lines.size(); } + std::string const& operator[]( std::size_t _index ) const { return lines[_index]; } + std::string toString() const { + std::ostringstream oss; + oss << *this; + return oss.str(); + } + + inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) { + for( Text::const_iterator it = _text.begin(), itEnd = _text.end(); + it != itEnd; ++it ) { + if( it != _text.begin() ) + _stream << "\n"; + _stream << *it; + } + return _stream; + } + + private: + std::string str; + TextAttributes attr; + std::vector lines; + }; + +} // end namespace Tbc + +#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE +} // end outer namespace +#endif + +#endif // TBC_TEXT_FORMAT_H_INCLUDED + +// ----------- end of #include from tbc_text_format.h ----------- +// ........... back in clara.h + +#undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE + +// ----------- #included from clara_compilers.h ----------- + +#ifndef TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED +#define TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED + +// Detect a number of compiler features - mostly C++11/14 conformance - by compiler +// The following features are defined: +// +// CLARA_CONFIG_CPP11_NULLPTR : is nullptr supported? +// CLARA_CONFIG_CPP11_NOEXCEPT : is noexcept supported? +// CLARA_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods +// CLARA_CONFIG_CPP11_OVERRIDE : is override supported? +// CLARA_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr) + +// CLARA_CONFIG_CPP11_OR_GREATER : Is C++11 supported? + +// CLARA_CONFIG_VARIADIC_MACROS : are variadic macros supported? + +// In general each macro has a _NO_ form +// (e.g. CLARA_CONFIG_CPP11_NO_NULLPTR) which disables the feature. +// Many features, at point of detection, define an _INTERNAL_ macro, so they +// can be combined, en-mass, with the _NO_ forms later. + +// All the C++11 features can be disabled with CLARA_CONFIG_NO_CPP11 + +#ifdef __clang__ + +#if __has_feature(cxx_nullptr) +#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR +#endif + +#if __has_feature(cxx_noexcept) +#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT +#endif + +#endif // __clang__ + +//////////////////////////////////////////////////////////////////////////////// +// GCC +#ifdef __GNUC__ + +#if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) +#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR +#endif + +// - otherwise more recent versions define __cplusplus >= 201103L +// and will get picked up below + +#endif // __GNUC__ + +//////////////////////////////////////////////////////////////////////////////// +// Visual C++ +#ifdef _MSC_VER + +#if (_MSC_VER >= 1600) +#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR +#define CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR +#endif + +#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015)) +#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT +#define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +#endif + +#endif // _MSC_VER + +//////////////////////////////////////////////////////////////////////////////// +// C++ language feature support + +// catch all support for C++11 +#if defined(__cplusplus) && __cplusplus >= 201103L + +#define CLARA_CPP11_OR_GREATER + +#if !defined(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR) +#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR +#endif + +#ifndef CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT +#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT +#endif + +#ifndef CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +#define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +#endif + +#if !defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE) +#define CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE +#endif +#if !defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) +#define CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR +#endif + +#endif // __cplusplus >= 201103L + +// Now set the actual defines based on the above + anything the user has configured +#if defined(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NO_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_NO_CPP11) +#define CLARA_CONFIG_CPP11_NULLPTR +#endif +#if defined(CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_NO_CPP11) +#define CLARA_CONFIG_CPP11_NOEXCEPT +#endif +#if defined(CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_NO_CPP11) +#define CLARA_CONFIG_CPP11_GENERATED_METHODS +#endif +#if defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_OVERRIDE) && !defined(CLARA_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_CPP11) +#define CLARA_CONFIG_CPP11_OVERRIDE +#endif +#if defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_UNIQUE_PTR) && !defined(CLARA_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_CPP11) +#define CLARA_CONFIG_CPP11_UNIQUE_PTR +#endif + +// noexcept support: +#if defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_NOEXCEPT) +#define CLARA_NOEXCEPT noexcept +# define CLARA_NOEXCEPT_IS(x) noexcept(x) +#else +#define CLARA_NOEXCEPT throw() +# define CLARA_NOEXCEPT_IS(x) +#endif + +// nullptr support +#ifdef CLARA_CONFIG_CPP11_NULLPTR +#define CLARA_NULL nullptr +#else +#define CLARA_NULL NULL +#endif + +// override support +#ifdef CLARA_CONFIG_CPP11_OVERRIDE +#define CLARA_OVERRIDE override +#else +#define CLARA_OVERRIDE +#endif + +// unique_ptr support +#ifdef CLARA_CONFIG_CPP11_UNIQUE_PTR +# define CLARA_AUTO_PTR( T ) std::unique_ptr +#else +# define CLARA_AUTO_PTR( T ) std::auto_ptr +#endif + +#endif // TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED + +// ----------- end of #include from clara_compilers.h ----------- +// ........... back in clara.h + +#include +#include +#include + +// Use optional outer namespace +#ifdef STITCH_CLARA_OPEN_NAMESPACE +STITCH_CLARA_OPEN_NAMESPACE +#endif + +namespace Clara { + + struct UnpositionalTag {}; + + extern UnpositionalTag _; + +#ifdef CLARA_CONFIG_MAIN + UnpositionalTag _; +#endif + + namespace Detail { + +#ifdef CLARA_CONSOLE_WIDTH + const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH; +#else + const unsigned int consoleWidth = 80; +#endif + + // Use this to try and stop compiler from warning about unreachable code + inline bool isTrue( bool value ) { return value; } + + using namespace Tbc; + + inline bool startsWith( std::string const& str, std::string const& prefix ) { + return str.size() >= prefix.size() && str.substr( 0, prefix.size() ) == prefix; + } + + template struct RemoveConstRef{ typedef T type; }; + template struct RemoveConstRef{ typedef T type; }; + template struct RemoveConstRef{ typedef T type; }; + template struct RemoveConstRef{ typedef T type; }; + + template struct IsBool { static const bool value = false; }; + template<> struct IsBool { static const bool value = true; }; + + template + void convertInto( std::string const& _source, T& _dest ) { + std::stringstream ss; + ss << _source; + ss >> _dest; + if( ss.fail() ) + throw std::runtime_error( "Unable to convert " + _source + " to destination type" ); + } + inline void convertInto( std::string const& _source, std::string& _dest ) { + _dest = _source; + } + inline void convertInto( std::string const& _source, bool& _dest ) { + std::string sourceLC = _source; + std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), ::tolower ); + if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" ) + _dest = true; + else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" ) + _dest = false; + else + throw std::runtime_error( "Expected a boolean value but did not recognise:\n '" + _source + "'" ); + } + inline void convertInto( bool _source, bool& _dest ) { + _dest = _source; + } + template + inline void convertInto( bool, T& ) { + if( isTrue( true ) ) + throw std::runtime_error( "Invalid conversion" ); + } + + template + struct IArgFunction { + virtual ~IArgFunction() {} +#ifdef CLARA_CONFIG_CPP11_GENERATED_METHODS + IArgFunction() = default; + IArgFunction( IArgFunction const& ) = default; +#endif + virtual void set( ConfigT& config, std::string const& value ) const = 0; + virtual void setFlag( ConfigT& config ) const = 0; + virtual bool takesArg() const = 0; + virtual IArgFunction* clone() const = 0; + }; + + template + class BoundArgFunction { + public: + BoundArgFunction() : functionObj( CLARA_NULL ) {} + BoundArgFunction( IArgFunction* _functionObj ) : functionObj( _functionObj ) {} + BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj ? other.functionObj->clone() : CLARA_NULL ) {} + BoundArgFunction& operator = ( BoundArgFunction const& other ) { + IArgFunction* newFunctionObj = other.functionObj ? other.functionObj->clone() : CLARA_NULL; + delete functionObj; + functionObj = newFunctionObj; + return *this; + } + ~BoundArgFunction() { delete functionObj; } + + void set( ConfigT& config, std::string const& value ) const { + functionObj->set( config, value ); + } + void setFlag( ConfigT& config ) const { + functionObj->setFlag( config ); + } + bool takesArg() const { return functionObj->takesArg(); } + + bool isSet() const { + return functionObj != CLARA_NULL; + } + private: + IArgFunction* functionObj; + }; + + template + struct NullBinder : IArgFunction{ + virtual void set( C&, std::string const& ) const {} + virtual void setFlag( C& ) const {} + virtual bool takesArg() const { return true; } + virtual IArgFunction* clone() const { return new NullBinder( *this ); } + }; + + template + struct BoundDataMember : IArgFunction{ + BoundDataMember( M C::* _member ) : member( _member ) {} + virtual void set( C& p, std::string const& stringValue ) const { + convertInto( stringValue, p.*member ); + } + virtual void setFlag( C& p ) const { + convertInto( true, p.*member ); + } + virtual bool takesArg() const { return !IsBool::value; } + virtual IArgFunction* clone() const { return new BoundDataMember( *this ); } + M C::* member; + }; + template + struct BoundUnaryMethod : IArgFunction{ + BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {} + virtual void set( C& p, std::string const& stringValue ) const { + typename RemoveConstRef::type value; + convertInto( stringValue, value ); + (p.*member)( value ); + } + virtual void setFlag( C& p ) const { + typename RemoveConstRef::type value; + convertInto( true, value ); + (p.*member)( value ); + } + virtual bool takesArg() const { return !IsBool::value; } + virtual IArgFunction* clone() const { return new BoundUnaryMethod( *this ); } + void (C::*member)( M ); + }; + template + struct BoundNullaryMethod : IArgFunction{ + BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {} + virtual void set( C& p, std::string const& stringValue ) const { + bool value; + convertInto( stringValue, value ); + if( value ) + (p.*member)(); + } + virtual void setFlag( C& p ) const { + (p.*member)(); + } + virtual bool takesArg() const { return false; } + virtual IArgFunction* clone() const { return new BoundNullaryMethod( *this ); } + void (C::*member)(); + }; + + template + struct BoundUnaryFunction : IArgFunction{ + BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {} + virtual void set( C& obj, std::string const& stringValue ) const { + bool value; + convertInto( stringValue, value ); + if( value ) + function( obj ); + } + virtual void setFlag( C& p ) const { + function( p ); + } + virtual bool takesArg() const { return false; } + virtual IArgFunction* clone() const { return new BoundUnaryFunction( *this ); } + void (*function)( C& ); + }; + + template + struct BoundBinaryFunction : IArgFunction{ + BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {} + virtual void set( C& obj, std::string const& stringValue ) const { + typename RemoveConstRef::type value; + convertInto( stringValue, value ); + function( obj, value ); + } + virtual void setFlag( C& obj ) const { + typename RemoveConstRef::type value; + convertInto( true, value ); + function( obj, value ); + } + virtual bool takesArg() const { return !IsBool::value; } + virtual IArgFunction* clone() const { return new BoundBinaryFunction( *this ); } + void (*function)( C&, T ); + }; + + } // namespace Detail + + struct Parser { + Parser() : separators( " \t=:" ) {} + + struct Token { + enum Type { Positional, ShortOpt, LongOpt }; + Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {} + Type type; + std::string data; + }; + + void parseIntoTokens( int argc, char const* const argv[], std::vector& tokens ) const { + const std::string doubleDash = "--"; + for( int i = 1; i < argc && argv[i] != doubleDash; ++i ) + parseIntoTokens( argv[i] , tokens); + } + void parseIntoTokens( std::string arg, std::vector& tokens ) const { + while( !arg.empty() ) { + Parser::Token token( Parser::Token::Positional, arg ); + arg = ""; + if( token.data[0] == '-' ) { + if( token.data.size() > 1 && token.data[1] == '-' ) { + token = Parser::Token( Parser::Token::LongOpt, token.data.substr( 2 ) ); + } + else { + token = Parser::Token( Parser::Token::ShortOpt, token.data.substr( 1 ) ); + if( token.data.size() > 1 && separators.find( token.data[1] ) == std::string::npos ) { + arg = "-" + token.data.substr( 1 ); + token.data = token.data.substr( 0, 1 ); + } + } + } + if( token.type != Parser::Token::Positional ) { + std::size_t pos = token.data.find_first_of( separators ); + if( pos != std::string::npos ) { + arg = token.data.substr( pos+1 ); + token.data = token.data.substr( 0, pos ); + } + } + tokens.push_back( token ); + } + } + std::string separators; + }; + + template + struct CommonArgProperties { + CommonArgProperties() {} + CommonArgProperties( Detail::BoundArgFunction const& _boundField ) : boundField( _boundField ) {} + + Detail::BoundArgFunction boundField; + std::string description; + std::string detail; + std::string placeholder; // Only value if boundField takes an arg + + bool takesArg() const { + return !placeholder.empty(); + } + void validate() const { + if( !boundField.isSet() ) + throw std::logic_error( "option not bound" ); + } + }; + struct OptionArgProperties { + std::vector shortNames; + std::string longName; + + bool hasShortName( std::string const& shortName ) const { + return std::find( shortNames.begin(), shortNames.end(), shortName ) != shortNames.end(); + } + bool hasLongName( std::string const& _longName ) const { + return _longName == longName; + } + }; + struct PositionalArgProperties { + PositionalArgProperties() : position( -1 ) {} + int position; // -1 means non-positional (floating) + + bool isFixedPositional() const { + return position != -1; + } + }; + + template + class CommandLine { + + struct Arg : CommonArgProperties, OptionArgProperties, PositionalArgProperties { + Arg() {} + Arg( Detail::BoundArgFunction const& _boundField ) : CommonArgProperties( _boundField ) {} + + using CommonArgProperties::placeholder; // !TBD + + std::string dbgName() const { + if( !longName.empty() ) + return "--" + longName; + if( !shortNames.empty() ) + return "-" + shortNames[0]; + return "positional args"; + } + std::string commands() const { + std::ostringstream oss; + bool first = true; + std::vector::const_iterator it = shortNames.begin(), itEnd = shortNames.end(); + for(; it != itEnd; ++it ) { + if( first ) + first = false; + else + oss << ", "; + oss << "-" << *it; + } + if( !longName.empty() ) { + if( !first ) + oss << ", "; + oss << "--" << longName; + } + if( !placeholder.empty() ) + oss << " <" << placeholder << ">"; + return oss.str(); + } + }; + + typedef CLARA_AUTO_PTR( Arg ) ArgAutoPtr; + + friend void addOptName( Arg& arg, std::string const& optName ) + { + if( optName.empty() ) + return; + if( Detail::startsWith( optName, "--" ) ) { + if( !arg.longName.empty() ) + throw std::logic_error( "Only one long opt may be specified. '" + + arg.longName + + "' already specified, now attempting to add '" + + optName + "'" ); + arg.longName = optName.substr( 2 ); + } + else if( Detail::startsWith( optName, "-" ) ) + arg.shortNames.push_back( optName.substr( 1 ) ); + else + throw std::logic_error( "option must begin with - or --. Option was: '" + optName + "'" ); + } + friend void setPositionalArg( Arg& arg, int position ) + { + arg.position = position; + } + + class ArgBuilder { + public: + ArgBuilder( Arg* arg ) : m_arg( arg ) {} + + // Bind a non-boolean data member (requires placeholder string) + template + void bind( M C::* field, std::string const& placeholder ) { + m_arg->boundField = new Detail::BoundDataMember( field ); + m_arg->placeholder = placeholder; + } + // Bind a boolean data member (no placeholder required) + template + void bind( bool C::* field ) { + m_arg->boundField = new Detail::BoundDataMember( field ); + } + + // Bind a method taking a single, non-boolean argument (requires a placeholder string) + template + void bind( void (C::* unaryMethod)( M ), std::string const& placeholder ) { + m_arg->boundField = new Detail::BoundUnaryMethod( unaryMethod ); + m_arg->placeholder = placeholder; + } + + // Bind a method taking a single, boolean argument (no placeholder string required) + template + void bind( void (C::* unaryMethod)( bool ) ) { + m_arg->boundField = new Detail::BoundUnaryMethod( unaryMethod ); + } + + // Bind a method that takes no arguments (will be called if opt is present) + template + void bind( void (C::* nullaryMethod)() ) { + m_arg->boundField = new Detail::BoundNullaryMethod( nullaryMethod ); + } + + // Bind a free function taking a single argument - the object to operate on (no placeholder string required) + template + void bind( void (* unaryFunction)( C& ) ) { + m_arg->boundField = new Detail::BoundUnaryFunction( unaryFunction ); + } + + // Bind a free function taking a single argument - the object to operate on (requires a placeholder string) + template + void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) { + m_arg->boundField = new Detail::BoundBinaryFunction( binaryFunction ); + m_arg->placeholder = placeholder; + } + + ArgBuilder& describe( std::string const& description ) { + m_arg->description = description; + return *this; + } + ArgBuilder& detail( std::string const& detail ) { + m_arg->detail = detail; + return *this; + } + + protected: + Arg* m_arg; + }; + + class OptBuilder : public ArgBuilder { + public: + OptBuilder( Arg* arg ) : ArgBuilder( arg ) {} + OptBuilder( OptBuilder& other ) : ArgBuilder( other ) {} + + OptBuilder& operator[]( std::string const& optName ) { + addOptName( *ArgBuilder::m_arg, optName ); + return *this; + } + }; + + public: + + CommandLine() + : m_boundProcessName( new Detail::NullBinder() ), + m_highestSpecifiedArgPosition( 0 ), + m_throwOnUnrecognisedTokens( false ) + {} + CommandLine( CommandLine const& other ) + : m_boundProcessName( other.m_boundProcessName ), + m_options ( other.m_options ), + m_positionalArgs( other.m_positionalArgs ), + m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ), + m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens ) + { + if( other.m_floatingArg.get() ) + m_floatingArg.reset( new Arg( *other.m_floatingArg ) ); + } + + CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) { + m_throwOnUnrecognisedTokens = shouldThrow; + return *this; + } + + OptBuilder operator[]( std::string const& optName ) { + m_options.push_back( Arg() ); + addOptName( m_options.back(), optName ); + OptBuilder builder( &m_options.back() ); + return builder; + } + + ArgBuilder operator[]( int position ) { + m_positionalArgs.insert( std::make_pair( position, Arg() ) ); + if( position > m_highestSpecifiedArgPosition ) + m_highestSpecifiedArgPosition = position; + setPositionalArg( m_positionalArgs[position], position ); + ArgBuilder builder( &m_positionalArgs[position] ); + return builder; + } + + // Invoke this with the _ instance + ArgBuilder operator[]( UnpositionalTag ) { + if( m_floatingArg.get() ) + throw std::logic_error( "Only one unpositional argument can be added" ); + m_floatingArg.reset( new Arg() ); + ArgBuilder builder( m_floatingArg.get() ); + return builder; + } + + template + void bindProcessName( M C::* field ) { + m_boundProcessName = new Detail::BoundDataMember( field ); + } + template + void bindProcessName( void (C::*_unaryMethod)( M ) ) { + m_boundProcessName = new Detail::BoundUnaryMethod( _unaryMethod ); + } + + void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const { + typename std::vector::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it; + std::size_t maxWidth = 0; + for( it = itBegin; it != itEnd; ++it ) + maxWidth = (std::max)( maxWidth, it->commands().size() ); + + for( it = itBegin; it != itEnd; ++it ) { + Detail::Text usage( it->commands(), Detail::TextAttributes() + .setWidth( maxWidth+indent ) + .setIndent( indent ) ); + Detail::Text desc( it->description, Detail::TextAttributes() + .setWidth( width - maxWidth - 3 ) ); + + for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) { + std::string usageCol = i < usage.size() ? usage[i] : ""; + os << usageCol; + + if( i < desc.size() && !desc[i].empty() ) + os << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' ) + << desc[i]; + os << "\n"; + } + } + } + std::string optUsage() const { + std::ostringstream oss; + optUsage( oss ); + return oss.str(); + } + + void argSynopsis( std::ostream& os ) const { + for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) { + if( i > 1 ) + os << " "; + typename std::map::const_iterator it = m_positionalArgs.find( i ); + if( it != m_positionalArgs.end() ) + os << "<" << it->second.placeholder << ">"; + else if( m_floatingArg.get() ) + os << "<" << m_floatingArg->placeholder << ">"; + else + throw std::logic_error( "non consecutive positional arguments with no floating args" ); + } + // !TBD No indication of mandatory args + if( m_floatingArg.get() ) { + if( m_highestSpecifiedArgPosition > 1 ) + os << " "; + os << "[<" << m_floatingArg->placeholder << "> ...]"; + } + } + std::string argSynopsis() const { + std::ostringstream oss; + argSynopsis( oss ); + return oss.str(); + } + + void usage( std::ostream& os, std::string const& procName ) const { + validate(); + os << "usage:\n " << procName << " "; + argSynopsis( os ); + if( !m_options.empty() ) { + os << " [options]\n\nwhere options are: \n"; + optUsage( os, 2 ); + } + os << "\n"; + } + std::string usage( std::string const& procName ) const { + std::ostringstream oss; + usage( oss, procName ); + return oss.str(); + } + + ConfigT parse( int argc, char const* const argv[] ) const { + ConfigT config; + parseInto( argc, argv, config ); + return config; + } + + std::vector parseInto( int argc, char const* argv[], ConfigT& config ) const { + std::string processName = argv[0]; + std::size_t lastSlash = processName.find_last_of( "/\\" ); + if( lastSlash != std::string::npos ) + processName = processName.substr( lastSlash+1 ); + m_boundProcessName.set( config, processName ); + std::vector tokens; + Parser parser; + parser.parseIntoTokens( argc, argv, tokens ); + return populate( tokens, config ); + } + + std::vector populate( std::vector const& tokens, ConfigT& config ) const { + validate(); + std::vector unusedTokens = populateOptions( tokens, config ); + unusedTokens = populateFixedArgs( unusedTokens, config ); + unusedTokens = populateFloatingArgs( unusedTokens, config ); + return unusedTokens; + } + + std::vector populateOptions( std::vector const& tokens, ConfigT& config ) const { + std::vector unusedTokens; + std::vector errors; + for( std::size_t i = 0; i < tokens.size(); ++i ) { + Parser::Token const& token = tokens[i]; + typename std::vector::const_iterator it = m_options.begin(), itEnd = m_options.end(); + for(; it != itEnd; ++it ) { + Arg const& arg = *it; + + try { + if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) || + ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) { + if( arg.takesArg() ) { + if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional ) + errors.push_back( "Expected argument to option: " + token.data ); + else + arg.boundField.set( config, tokens[++i].data ); + } + else { + arg.boundField.setFlag( config ); + } + break; + } + } + catch( std::exception& ex ) { + errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" ); + } + } + if( it == itEnd ) { + if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens ) + unusedTokens.push_back( token ); + else if( errors.empty() && m_throwOnUnrecognisedTokens ) + errors.push_back( "unrecognised option: " + token.data ); + } + } + if( !errors.empty() ) { + std::ostringstream oss; + for( std::vector::const_iterator it = errors.begin(), itEnd = errors.end(); + it != itEnd; + ++it ) { + if( it != errors.begin() ) + oss << "\n"; + oss << *it; + } + throw std::runtime_error( oss.str() ); + } + return unusedTokens; + } + std::vector populateFixedArgs( std::vector const& tokens, ConfigT& config ) const { + std::vector unusedTokens; + int position = 1; + for( std::size_t i = 0; i < tokens.size(); ++i ) { + Parser::Token const& token = tokens[i]; + typename std::map::const_iterator it = m_positionalArgs.find( position ); + if( it != m_positionalArgs.end() ) + it->second.boundField.set( config, token.data ); + else + unusedTokens.push_back( token ); + if( token.type == Parser::Token::Positional ) + position++; + } + return unusedTokens; + } + std::vector populateFloatingArgs( std::vector const& tokens, ConfigT& config ) const { + if( !m_floatingArg.get() ) + return tokens; + std::vector unusedTokens; + for( std::size_t i = 0; i < tokens.size(); ++i ) { + Parser::Token const& token = tokens[i]; + if( token.type == Parser::Token::Positional ) + m_floatingArg->boundField.set( config, token.data ); + else + unusedTokens.push_back( token ); + } + return unusedTokens; + } + + void validate() const + { + if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() ) + throw std::logic_error( "No options or arguments specified" ); + + for( typename std::vector::const_iterator it = m_options.begin(), + itEnd = m_options.end(); + it != itEnd; ++it ) + it->validate(); + } + + private: + Detail::BoundArgFunction m_boundProcessName; + std::vector m_options; + std::map m_positionalArgs; + ArgAutoPtr m_floatingArg; + int m_highestSpecifiedArgPosition; + bool m_throwOnUnrecognisedTokens; + }; + +} // end namespace Clara + +STITCH_CLARA_CLOSE_NAMESPACE +#undef STITCH_CLARA_OPEN_NAMESPACE +#undef STITCH_CLARA_CLOSE_NAMESPACE + +#endif // TWOBLUECUBES_CLARA_H_INCLUDED +#undef STITCH_CLARA_OPEN_NAMESPACE + +// Restore Clara's value for console width, if present +#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH +#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH +#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH +#endif + +#include + +namespace Catch { + + inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; } + inline void abortAfterX( ConfigData& config, int x ) { + if( x < 1 ) + throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" ); + config.abortAfter = x; + } + inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); } + inline void addReporterName( ConfigData& config, std::string const& _reporterName ) { config.reporterNames.push_back( _reporterName ); } + + inline void addWarning( ConfigData& config, std::string const& _warning ) { + if( _warning == "NoAssertions" ) + config.warnings = static_cast( config.warnings | WarnAbout::NoAssertions ); + else + throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" ); + } + inline void setOrder( ConfigData& config, std::string const& order ) { + if( startsWith( "declared", order ) ) + config.runOrder = RunTests::InDeclarationOrder; + else if( startsWith( "lexical", order ) ) + config.runOrder = RunTests::InLexicographicalOrder; + else if( startsWith( "random", order ) ) + config.runOrder = RunTests::InRandomOrder; + else + throw std::runtime_error( "Unrecognised ordering: '" + order + "'" ); + } + inline void setRngSeed( ConfigData& config, std::string const& seed ) { + if( seed == "time" ) { + config.rngSeed = static_cast( std::time(0) ); + } + else { + std::stringstream ss; + ss << seed; + ss >> config.rngSeed; + if( ss.fail() ) + throw std::runtime_error( "Argment to --rng-seed should be the word 'time' or a number" ); + } + } + inline void setVerbosity( ConfigData& config, int level ) { + // !TBD: accept strings? + config.verbosity = static_cast( level ); + } + inline void setShowDurations( ConfigData& config, bool _showDurations ) { + config.showDurations = _showDurations + ? ShowDurations::Always + : ShowDurations::Never; + } + inline void setUseColour( ConfigData& config, std::string const& value ) { + std::string mode = toLower( value ); + + if( mode == "yes" ) + config.useColour = UseColour::Yes; + else if( mode == "no" ) + config.useColour = UseColour::No; + else if( mode == "auto" ) + config.useColour = UseColour::Auto; + else + throw std::runtime_error( "colour mode must be one of: auto, yes or no" ); + } + inline void forceColour( ConfigData& config ) { + config.useColour = UseColour::Yes; + } + inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) { + std::ifstream f( _filename.c_str() ); + if( !f.is_open() ) + throw std::domain_error( "Unable to load input file: " + _filename ); + + std::string line; + while( std::getline( f, line ) ) { + line = trim(line); + if( !line.empty() && !startsWith( line, "#" ) ) + addTestOrTags( config, "\"" + line + "\"," ); + } + } + + inline Clara::CommandLine makeCommandLineParser() { + + using namespace Clara; + CommandLine cli; + + cli.bindProcessName( &ConfigData::processName ); + + cli["-?"]["-h"]["--help"] + .describe( "display usage information" ) + .bind( &ConfigData::showHelp ); + + cli["-l"]["--list-tests"] + .describe( "list all/matching test cases" ) + .bind( &ConfigData::listTests ); + + cli["-t"]["--list-tags"] + .describe( "list all/matching tags" ) + .bind( &ConfigData::listTags ); + + cli["-s"]["--success"] + .describe( "include successful tests in output" ) + .bind( &ConfigData::showSuccessfulTests ); + + cli["-b"]["--break"] + .describe( "break into debugger on failure" ) + .bind( &ConfigData::shouldDebugBreak ); + + cli["-e"]["--nothrow"] + .describe( "skip exception tests" ) + .bind( &ConfigData::noThrow ); + + cli["-i"]["--invisibles"] + .describe( "show invisibles (tabs, newlines)" ) + .bind( &ConfigData::showInvisibles ); + + cli["-o"]["--out"] + .describe( "output filename" ) + .bind( &ConfigData::outputFilename, "filename" ); + + cli["-r"]["--reporter"] +// .placeholder( "name[:filename]" ) + .describe( "reporter to use (defaults to console)" ) + .bind( &addReporterName, "name" ); + + cli["-n"]["--name"] + .describe( "suite name" ) + .bind( &ConfigData::name, "name" ); + + cli["-a"]["--abort"] + .describe( "abort at first failure" ) + .bind( &abortAfterFirst ); + + cli["-x"]["--abortx"] + .describe( "abort after x failures" ) + .bind( &abortAfterX, "no. failures" ); + + cli["-w"]["--warn"] + .describe( "enable warnings" ) + .bind( &addWarning, "warning name" ); + +// - needs updating if reinstated +// cli.into( &setVerbosity ) +// .describe( "level of verbosity (0=no output)" ) +// .shortOpt( "v") +// .longOpt( "verbosity" ) +// .placeholder( "level" ); + + cli[_] + .describe( "which test or tests to use" ) + .bind( &addTestOrTags, "test name, pattern or tags" ); + + cli["-d"]["--durations"] + .describe( "show test durations" ) + .bind( &setShowDurations, "yes|no" ); + + cli["-f"]["--input-file"] + .describe( "load test names to run from a file" ) + .bind( &loadTestNamesFromFile, "filename" ); + + cli["-#"]["--filenames-as-tags"] + .describe( "adds a tag for the filename" ) + .bind( &ConfigData::filenamesAsTags ); + + // Less common commands which don't have a short form + cli["--list-test-names-only"] + .describe( "list all/matching test cases names only" ) + .bind( &ConfigData::listTestNamesOnly ); + + cli["--list-reporters"] + .describe( "list all reporters" ) + .bind( &ConfigData::listReporters ); + + cli["--order"] + .describe( "test case order (defaults to decl)" ) + .bind( &setOrder, "decl|lex|rand" ); + + cli["--rng-seed"] + .describe( "set a specific seed for random numbers" ) + .bind( &setRngSeed, "'time'|number" ); + + cli["--force-colour"] + .describe( "force colourised output (deprecated)" ) + .bind( &forceColour ); + + cli["--use-colour"] + .describe( "should output be colourised" ) + .bind( &setUseColour, "yes|no" ); + + return cli; + } + +} // end namespace Catch + +// #included from: internal/catch_list.hpp +#define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED + +// #included from: catch_text.h +#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED + +#define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH + +#define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch +// #included from: ../external/tbc_text_format.h +// Only use header guard if we are not using an outer namespace +#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE +# ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED +# ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED +# define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED +# endif +# else +# define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED +# endif +#endif +#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED +#include +#include +#include + +// Use optional outer namespace +#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE +namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE { +#endif + +namespace Tbc { + +#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH + const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH; +#else + const unsigned int consoleWidth = 80; +#endif + + struct TextAttributes { + TextAttributes() + : initialIndent( std::string::npos ), + indent( 0 ), + width( consoleWidth-1 ), + tabChar( '\t' ) + {} + + TextAttributes& setInitialIndent( std::size_t _value ) { initialIndent = _value; return *this; } + TextAttributes& setIndent( std::size_t _value ) { indent = _value; return *this; } + TextAttributes& setWidth( std::size_t _value ) { width = _value; return *this; } + TextAttributes& setTabChar( char _value ) { tabChar = _value; return *this; } + + std::size_t initialIndent; // indent of first line, or npos + std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos + std::size_t width; // maximum width of text, including indent. Longer text will wrap + char tabChar; // If this char is seen the indent is changed to current pos + }; + + class Text { + public: + Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() ) + : attr( _attr ) + { + std::string wrappableChars = " [({.,/|\\-"; + std::size_t indent = _attr.initialIndent != std::string::npos + ? _attr.initialIndent + : _attr.indent; + std::string remainder = _str; + + while( !remainder.empty() ) { + if( lines.size() >= 1000 ) { + lines.push_back( "... message truncated due to excessive size" ); + return; + } + std::size_t tabPos = std::string::npos; + std::size_t width = (std::min)( remainder.size(), _attr.width - indent ); + std::size_t pos = remainder.find_first_of( '\n' ); + if( pos <= width ) { + width = pos; + } + pos = remainder.find_last_of( _attr.tabChar, width ); + if( pos != std::string::npos ) { + tabPos = pos; + if( remainder[width] == '\n' ) + width--; + remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 ); + } + + if( width == remainder.size() ) { + spliceLine( indent, remainder, width ); + } + else if( remainder[width] == '\n' ) { + spliceLine( indent, remainder, width ); + if( width <= 1 || remainder.size() != 1 ) + remainder = remainder.substr( 1 ); + indent = _attr.indent; + } + else { + pos = remainder.find_last_of( wrappableChars, width ); + if( pos != std::string::npos && pos > 0 ) { + spliceLine( indent, remainder, pos ); + if( remainder[0] == ' ' ) + remainder = remainder.substr( 1 ); + } + else { + spliceLine( indent, remainder, width-1 ); + lines.back() += "-"; + } + if( lines.size() == 1 ) + indent = _attr.indent; + if( tabPos != std::string::npos ) + indent += tabPos; + } + } + } + + void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) { + lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) ); + _remainder = _remainder.substr( _pos ); + } + + typedef std::vector::const_iterator const_iterator; + + const_iterator begin() const { return lines.begin(); } + const_iterator end() const { return lines.end(); } + std::string const& last() const { return lines.back(); } + std::size_t size() const { return lines.size(); } + std::string const& operator[]( std::size_t _index ) const { return lines[_index]; } + std::string toString() const { + std::ostringstream oss; + oss << *this; + return oss.str(); + } + + inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) { + for( Text::const_iterator it = _text.begin(), itEnd = _text.end(); + it != itEnd; ++it ) { + if( it != _text.begin() ) + _stream << "\n"; + _stream << *it; + } + return _stream; + } + + private: + std::string str; + TextAttributes attr; + std::vector lines; + }; + +} // end namespace Tbc + +#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE +} // end outer namespace +#endif + +#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED +#undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE + +namespace Catch { + using Tbc::Text; + using Tbc::TextAttributes; +} + +// #included from: catch_console_colour.hpp +#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED + +namespace Catch { + + struct Colour { + enum Code { + None = 0, + + White, + Red, + Green, + Blue, + Cyan, + Yellow, + Grey, + + Bright = 0x10, + + BrightRed = Bright | Red, + BrightGreen = Bright | Green, + LightGrey = Bright | Grey, + BrightWhite = Bright | White, + + // By intention + FileName = LightGrey, + Warning = Yellow, + ResultError = BrightRed, + ResultSuccess = BrightGreen, + ResultExpectedFailure = Warning, + + Error = BrightRed, + Success = Green, + + OriginalExpression = Cyan, + ReconstructedExpression = Yellow, + + SecondaryText = LightGrey, + Headers = White + }; + + // Use constructed object for RAII guard + Colour( Code _colourCode ); + Colour( Colour const& other ); + ~Colour(); + + // Use static method for one-shot changes + static void use( Code _colourCode ); + + private: + bool m_moved; + }; + + inline std::ostream& operator << ( std::ostream& os, Colour const& ) { return os; } + +} // end namespace Catch + +// #included from: catch_interfaces_reporter.h +#define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED + +#include +#include +#include +#include + +namespace Catch +{ + struct ReporterConfig { + explicit ReporterConfig( Ptr const& _fullConfig ) + : m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {} + + ReporterConfig( Ptr const& _fullConfig, std::ostream& _stream ) + : m_stream( &_stream ), m_fullConfig( _fullConfig ) {} + + std::ostream& stream() const { return *m_stream; } + Ptr fullConfig() const { return m_fullConfig; } + + private: + std::ostream* m_stream; + Ptr m_fullConfig; + }; + + struct ReporterPreferences { + ReporterPreferences() + : shouldRedirectStdOut( false ) + {} + + bool shouldRedirectStdOut; + }; + + template + struct LazyStat : Option { + LazyStat() : used( false ) {} + LazyStat& operator=( T const& _value ) { + Option::operator=( _value ); + used = false; + return *this; + } + void reset() { + Option::reset(); + used = false; + } + bool used; + }; + + struct TestRunInfo { + TestRunInfo( std::string const& _name ) : name( _name ) {} + std::string name; + }; + struct GroupInfo { + GroupInfo( std::string const& _name, + std::size_t _groupIndex, + std::size_t _groupsCount ) + : name( _name ), + groupIndex( _groupIndex ), + groupsCounts( _groupsCount ) + {} + + std::string name; + std::size_t groupIndex; + std::size_t groupsCounts; + }; + + struct AssertionStats { + AssertionStats( AssertionResult const& _assertionResult, + std::vector const& _infoMessages, + Totals const& _totals ) + : assertionResult( _assertionResult ), + infoMessages( _infoMessages ), + totals( _totals ) + { + if( assertionResult.hasMessage() ) { + // Copy message into messages list. + // !TBD This should have been done earlier, somewhere + MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() ); + builder << assertionResult.getMessage(); + builder.m_info.message = builder.m_stream.str(); + + infoMessages.push_back( builder.m_info ); + } + } + virtual ~AssertionStats(); + +# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + AssertionStats( AssertionStats const& ) = default; + AssertionStats( AssertionStats && ) = default; + AssertionStats& operator = ( AssertionStats const& ) = default; + AssertionStats& operator = ( AssertionStats && ) = default; +# endif + + AssertionResult assertionResult; + std::vector infoMessages; + Totals totals; + }; + + struct SectionStats { + SectionStats( SectionInfo const& _sectionInfo, + Counts const& _assertions, + double _durationInSeconds, + bool _missingAssertions ) + : sectionInfo( _sectionInfo ), + assertions( _assertions ), + durationInSeconds( _durationInSeconds ), + missingAssertions( _missingAssertions ) + {} + virtual ~SectionStats(); +# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + SectionStats( SectionStats const& ) = default; + SectionStats( SectionStats && ) = default; + SectionStats& operator = ( SectionStats const& ) = default; + SectionStats& operator = ( SectionStats && ) = default; +# endif + + SectionInfo sectionInfo; + Counts assertions; + double durationInSeconds; + bool missingAssertions; + }; + + struct TestCaseStats { + TestCaseStats( TestCaseInfo const& _testInfo, + Totals const& _totals, + std::string const& _stdOut, + std::string const& _stdErr, + bool _aborting ) + : testInfo( _testInfo ), + totals( _totals ), + stdOut( _stdOut ), + stdErr( _stdErr ), + aborting( _aborting ) + {} + virtual ~TestCaseStats(); + +# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + TestCaseStats( TestCaseStats const& ) = default; + TestCaseStats( TestCaseStats && ) = default; + TestCaseStats& operator = ( TestCaseStats const& ) = default; + TestCaseStats& operator = ( TestCaseStats && ) = default; +# endif + + TestCaseInfo testInfo; + Totals totals; + std::string stdOut; + std::string stdErr; + bool aborting; + }; + + struct TestGroupStats { + TestGroupStats( GroupInfo const& _groupInfo, + Totals const& _totals, + bool _aborting ) + : groupInfo( _groupInfo ), + totals( _totals ), + aborting( _aborting ) + {} + TestGroupStats( GroupInfo const& _groupInfo ) + : groupInfo( _groupInfo ), + aborting( false ) + {} + virtual ~TestGroupStats(); + +# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + TestGroupStats( TestGroupStats const& ) = default; + TestGroupStats( TestGroupStats && ) = default; + TestGroupStats& operator = ( TestGroupStats const& ) = default; + TestGroupStats& operator = ( TestGroupStats && ) = default; +# endif + + GroupInfo groupInfo; + Totals totals; + bool aborting; + }; + + struct TestRunStats { + TestRunStats( TestRunInfo const& _runInfo, + Totals const& _totals, + bool _aborting ) + : runInfo( _runInfo ), + totals( _totals ), + aborting( _aborting ) + {} + virtual ~TestRunStats(); + +# ifndef CATCH_CONFIG_CPP11_GENERATED_METHODS + TestRunStats( TestRunStats const& _other ) + : runInfo( _other.runInfo ), + totals( _other.totals ), + aborting( _other.aborting ) + {} +# else + TestRunStats( TestRunStats const& ) = default; + TestRunStats( TestRunStats && ) = default; + TestRunStats& operator = ( TestRunStats const& ) = default; + TestRunStats& operator = ( TestRunStats && ) = default; +# endif + + TestRunInfo runInfo; + Totals totals; + bool aborting; + }; + + struct IStreamingReporter : IShared { + virtual ~IStreamingReporter(); + + // Implementing class must also provide the following static method: + // static std::string getDescription(); + + virtual ReporterPreferences getPreferences() const = 0; + + virtual void noMatchingTestCases( std::string const& spec ) = 0; + + virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0; + virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0; + + virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0; + virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0; + + virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0; + + // The return value indicates if the messages buffer should be cleared: + virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0; + + virtual void sectionEnded( SectionStats const& sectionStats ) = 0; + virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0; + virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0; + virtual void testRunEnded( TestRunStats const& testRunStats ) = 0; + + virtual void skipTest( TestCaseInfo const& testInfo ) = 0; + }; + + struct IReporterFactory : IShared { + virtual ~IReporterFactory(); + virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0; + virtual std::string getDescription() const = 0; + }; + + struct IReporterRegistry { + typedef std::map > FactoryMap; + typedef std::vector > Listeners; + + virtual ~IReporterRegistry(); + virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const = 0; + virtual FactoryMap const& getFactories() const = 0; + virtual Listeners const& getListeners() const = 0; + }; + + Ptr addReporter( Ptr const& existingReporter, Ptr const& additionalReporter ); + +} + +#include +#include + +namespace Catch { + + inline std::size_t listTests( Config const& config ) { + + TestSpec testSpec = config.testSpec(); + if( config.testSpec().hasFilters() ) + Catch::cout() << "Matching test cases:\n"; + else { + Catch::cout() << "All available test cases:\n"; + testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); + } + + std::size_t matchedTests = 0; + TextAttributes nameAttr, tagsAttr; + nameAttr.setInitialIndent( 2 ).setIndent( 4 ); + tagsAttr.setIndent( 6 ); + + std::vector matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config ); + for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); + it != itEnd; + ++it ) { + matchedTests++; + TestCaseInfo const& testCaseInfo = it->getTestCaseInfo(); + Colour::Code colour = testCaseInfo.isHidden() + ? Colour::SecondaryText + : Colour::None; + Colour colourGuard( colour ); + + Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl; + if( !testCaseInfo.tags.empty() ) + Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl; + } + + if( !config.testSpec().hasFilters() ) + Catch::cout() << pluralise( matchedTests, "test case" ) << "\n" << std::endl; + else + Catch::cout() << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl; + return matchedTests; + } + + inline std::size_t listTestsNamesOnly( Config const& config ) { + TestSpec testSpec = config.testSpec(); + if( !config.testSpec().hasFilters() ) + testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); + std::size_t matchedTests = 0; + std::vector matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config ); + for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); + it != itEnd; + ++it ) { + matchedTests++; + TestCaseInfo const& testCaseInfo = it->getTestCaseInfo(); + Catch::cout() << testCaseInfo.name << std::endl; + } + return matchedTests; + } + + struct TagInfo { + TagInfo() : count ( 0 ) {} + void add( std::string const& spelling ) { + ++count; + spellings.insert( spelling ); + } + std::string all() const { + std::string out; + for( std::set::const_iterator it = spellings.begin(), itEnd = spellings.end(); + it != itEnd; + ++it ) + out += "[" + *it + "]"; + return out; + } + std::set spellings; + std::size_t count; + }; + + inline std::size_t listTags( Config const& config ) { + TestSpec testSpec = config.testSpec(); + if( config.testSpec().hasFilters() ) + Catch::cout() << "Tags for matching test cases:\n"; + else { + Catch::cout() << "All available tags:\n"; + testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); + } + + std::map tagCounts; + + std::vector matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config ); + for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); + it != itEnd; + ++it ) { + for( std::set::const_iterator tagIt = it->getTestCaseInfo().tags.begin(), + tagItEnd = it->getTestCaseInfo().tags.end(); + tagIt != tagItEnd; + ++tagIt ) { + std::string tagName = *tagIt; + std::string lcaseTagName = toLower( tagName ); + std::map::iterator countIt = tagCounts.find( lcaseTagName ); + if( countIt == tagCounts.end() ) + countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first; + countIt->second.add( tagName ); + } + } + + for( std::map::const_iterator countIt = tagCounts.begin(), + countItEnd = tagCounts.end(); + countIt != countItEnd; + ++countIt ) { + std::ostringstream oss; + oss << " " << std::setw(2) << countIt->second.count << " "; + Text wrapper( countIt->second.all(), TextAttributes() + .setInitialIndent( 0 ) + .setIndent( oss.str().size() ) + .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) ); + Catch::cout() << oss.str() << wrapper << "\n"; + } + Catch::cout() << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl; + return tagCounts.size(); + } + + inline std::size_t listReporters( Config const& /*config*/ ) { + Catch::cout() << "Available reporters:\n"; + IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories(); + IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it; + std::size_t maxNameLen = 0; + for(it = itBegin; it != itEnd; ++it ) + maxNameLen = (std::max)( maxNameLen, it->first.size() ); + + for(it = itBegin; it != itEnd; ++it ) { + Text wrapper( it->second->getDescription(), TextAttributes() + .setInitialIndent( 0 ) + .setIndent( 7+maxNameLen ) + .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) ); + Catch::cout() << " " + << it->first + << ":" + << std::string( maxNameLen - it->first.size() + 2, ' ' ) + << wrapper << "\n"; + } + Catch::cout() << std::endl; + return factories.size(); + } + + inline Option list( Config const& config ) { + Option listedCount; + if( config.listTests() ) + listedCount = listedCount.valueOr(0) + listTests( config ); + if( config.listTestNamesOnly() ) + listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config ); + if( config.listTags() ) + listedCount = listedCount.valueOr(0) + listTags( config ); + if( config.listReporters() ) + listedCount = listedCount.valueOr(0) + listReporters( config ); + return listedCount; + } + +} // end namespace Catch + +// #included from: internal/catch_run_context.hpp +#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED + +// #included from: catch_test_case_tracker.hpp +#define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED + +#include +#include +#include +#include + +namespace Catch { +namespace TestCaseTracking { + + struct ITracker : SharedImpl<> { + virtual ~ITracker(); + + // static queries + virtual std::string name() const = 0; + + // dynamic queries + virtual bool isComplete() const = 0; // Successfully completed or failed + virtual bool isSuccessfullyCompleted() const = 0; + virtual bool isOpen() const = 0; // Started but not complete + virtual bool hasChildren() const = 0; + + virtual ITracker& parent() = 0; + + // actions + virtual void close() = 0; // Successfully complete + virtual void fail() = 0; + virtual void markAsNeedingAnotherRun() = 0; + + virtual void addChild( Ptr const& child ) = 0; + virtual ITracker* findChild( std::string const& name ) = 0; + virtual void openChild() = 0; + }; + + class TrackerContext { + + enum RunState { + NotStarted, + Executing, + CompletedCycle + }; + + Ptr m_rootTracker; + ITracker* m_currentTracker; + RunState m_runState; + + public: + + static TrackerContext& instance() { + static TrackerContext s_instance; + return s_instance; + } + + TrackerContext() + : m_currentTracker( CATCH_NULL ), + m_runState( NotStarted ) + {} + + ITracker& startRun(); + + void endRun() { + m_rootTracker.reset(); + m_currentTracker = CATCH_NULL; + m_runState = NotStarted; + } + + void startCycle() { + m_currentTracker = m_rootTracker.get(); + m_runState = Executing; + } + void completeCycle() { + m_runState = CompletedCycle; + } + + bool completedCycle() const { + return m_runState == CompletedCycle; + } + ITracker& currentTracker() { + return *m_currentTracker; + } + void setCurrentTracker( ITracker* tracker ) { + m_currentTracker = tracker; + } + }; + + class TrackerBase : public ITracker { + protected: + enum CycleState { + NotStarted, + Executing, + ExecutingChildren, + NeedsAnotherRun, + CompletedSuccessfully, + Failed + }; + class TrackerHasName { + std::string m_name; + public: + TrackerHasName( std::string const& name ) : m_name( name ) {} + bool operator ()( Ptr const& tracker ) { + return tracker->name() == m_name; + } + }; + typedef std::vector > Children; + std::string m_name; + TrackerContext& m_ctx; + ITracker* m_parent; + Children m_children; + CycleState m_runState; + public: + TrackerBase( std::string const& name, TrackerContext& ctx, ITracker* parent ) + : m_name( name ), + m_ctx( ctx ), + m_parent( parent ), + m_runState( NotStarted ) + {} + virtual ~TrackerBase(); + + virtual std::string name() const CATCH_OVERRIDE { + return m_name; + } + virtual bool isComplete() const CATCH_OVERRIDE { + return m_runState == CompletedSuccessfully || m_runState == Failed; + } + virtual bool isSuccessfullyCompleted() const CATCH_OVERRIDE { + return m_runState == CompletedSuccessfully; + } + virtual bool isOpen() const CATCH_OVERRIDE { + return m_runState != NotStarted && !isComplete(); + } + virtual bool hasChildren() const CATCH_OVERRIDE { + return !m_children.empty(); + } + + virtual void addChild( Ptr const& child ) CATCH_OVERRIDE { + m_children.push_back( child ); + } + + virtual ITracker* findChild( std::string const& name ) CATCH_OVERRIDE { + Children::const_iterator it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( name ) ); + return( it != m_children.end() ) + ? it->get() + : CATCH_NULL; + } + virtual ITracker& parent() CATCH_OVERRIDE { + assert( m_parent ); // Should always be non-null except for root + return *m_parent; + } + + virtual void openChild() CATCH_OVERRIDE { + if( m_runState != ExecutingChildren ) { + m_runState = ExecutingChildren; + if( m_parent ) + m_parent->openChild(); + } + } + void open() { + m_runState = Executing; + moveToThis(); + if( m_parent ) + m_parent->openChild(); + } + + virtual void close() CATCH_OVERRIDE { + + // Close any still open children (e.g. generators) + while( &m_ctx.currentTracker() != this ) + m_ctx.currentTracker().close(); + + switch( m_runState ) { + case NotStarted: + case CompletedSuccessfully: + case Failed: + throw std::logic_error( "Illogical state" ); + + case NeedsAnotherRun: + break;; + + case Executing: + m_runState = CompletedSuccessfully; + break; + case ExecutingChildren: + if( m_children.empty() || m_children.back()->isComplete() ) + m_runState = CompletedSuccessfully; + break; + + default: + throw std::logic_error( "Unexpected state" ); + } + moveToParent(); + m_ctx.completeCycle(); + } + virtual void fail() CATCH_OVERRIDE { + m_runState = Failed; + if( m_parent ) + m_parent->markAsNeedingAnotherRun(); + moveToParent(); + m_ctx.completeCycle(); + } + virtual void markAsNeedingAnotherRun() CATCH_OVERRIDE { + m_runState = NeedsAnotherRun; + } + private: + void moveToParent() { + assert( m_parent ); + m_ctx.setCurrentTracker( m_parent ); + } + void moveToThis() { + m_ctx.setCurrentTracker( this ); + } + }; + + class SectionTracker : public TrackerBase { + public: + SectionTracker( std::string const& name, TrackerContext& ctx, ITracker* parent ) + : TrackerBase( name, ctx, parent ) + {} + virtual ~SectionTracker(); + + static SectionTracker& acquire( TrackerContext& ctx, std::string const& name ) { + SectionTracker* section = CATCH_NULL; + + ITracker& currentTracker = ctx.currentTracker(); + if( ITracker* childTracker = currentTracker.findChild( name ) ) { + section = dynamic_cast( childTracker ); + assert( section ); + } + else { + section = new SectionTracker( name, ctx, ¤tTracker ); + currentTracker.addChild( section ); + } + if( !ctx.completedCycle() && !section->isComplete() ) { + + section->open(); + } + return *section; + } + }; + + class IndexTracker : public TrackerBase { + int m_size; + int m_index; + public: + IndexTracker( std::string const& name, TrackerContext& ctx, ITracker* parent, int size ) + : TrackerBase( name, ctx, parent ), + m_size( size ), + m_index( -1 ) + {} + virtual ~IndexTracker(); + + static IndexTracker& acquire( TrackerContext& ctx, std::string const& name, int size ) { + IndexTracker* tracker = CATCH_NULL; + + ITracker& currentTracker = ctx.currentTracker(); + if( ITracker* childTracker = currentTracker.findChild( name ) ) { + tracker = dynamic_cast( childTracker ); + assert( tracker ); + } + else { + tracker = new IndexTracker( name, ctx, ¤tTracker, size ); + currentTracker.addChild( tracker ); + } + + if( !ctx.completedCycle() && !tracker->isComplete() ) { + if( tracker->m_runState != ExecutingChildren && tracker->m_runState != NeedsAnotherRun ) + tracker->moveNext(); + tracker->open(); + } + + return *tracker; + } + + int index() const { return m_index; } + + void moveNext() { + m_index++; + m_children.clear(); + } + + virtual void close() CATCH_OVERRIDE { + TrackerBase::close(); + if( m_runState == CompletedSuccessfully && m_index < m_size-1 ) + m_runState = Executing; + } + }; + + inline ITracker& TrackerContext::startRun() { + m_rootTracker = new SectionTracker( "{root}", *this, CATCH_NULL ); + m_currentTracker = CATCH_NULL; + m_runState = Executing; + return *m_rootTracker; + } + +} // namespace TestCaseTracking + +using TestCaseTracking::ITracker; +using TestCaseTracking::TrackerContext; +using TestCaseTracking::SectionTracker; +using TestCaseTracking::IndexTracker; + +} // namespace Catch + +// #included from: catch_fatal_condition.hpp +#define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED + +namespace Catch { + + // Report the error condition then exit the process + inline void fatal( std::string const& message, int exitCode ) { + IContext& context = Catch::getCurrentContext(); + IResultCapture* resultCapture = context.getResultCapture(); + resultCapture->handleFatalErrorCondition( message ); + + if( Catch::alwaysTrue() ) // avoids "no return" warnings + exit( exitCode ); + } + +} // namespace Catch + +#if defined ( CATCH_PLATFORM_WINDOWS ) ///////////////////////////////////////// + +namespace Catch { + + struct FatalConditionHandler { + void reset() {} + }; + +} // namespace Catch + +#else // Not Windows - assumed to be POSIX compatible ////////////////////////// + +#include + +namespace Catch { + + struct SignalDefs { int id; const char* name; }; + extern SignalDefs signalDefs[]; + SignalDefs signalDefs[] = { + { SIGINT, "SIGINT - Terminal interrupt signal" }, + { SIGILL, "SIGILL - Illegal instruction signal" }, + { SIGFPE, "SIGFPE - Floating point error signal" }, + { SIGSEGV, "SIGSEGV - Segmentation violation signal" }, + { SIGTERM, "SIGTERM - Termination request signal" }, + { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" } + }; + + struct FatalConditionHandler { + + static void handleSignal( int sig ) { + for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) + if( sig == signalDefs[i].id ) + fatal( signalDefs[i].name, -sig ); + fatal( "", -sig ); + } + + FatalConditionHandler() : m_isSet( true ) { + for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) + signal( signalDefs[i].id, handleSignal ); + } + ~FatalConditionHandler() { + reset(); + } + void reset() { + if( m_isSet ) { + for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) + signal( signalDefs[i].id, SIG_DFL ); + m_isSet = false; + } + } + + bool m_isSet; + }; + +} // namespace Catch + +#endif // not Windows + +#include +#include + +namespace Catch { + + class StreamRedirect { + + public: + StreamRedirect( std::ostream& stream, std::string& targetString ) + : m_stream( stream ), + m_prevBuf( stream.rdbuf() ), + m_targetString( targetString ) + { + stream.rdbuf( m_oss.rdbuf() ); + } + + ~StreamRedirect() { + m_targetString += m_oss.str(); + m_stream.rdbuf( m_prevBuf ); + } + + private: + std::ostream& m_stream; + std::streambuf* m_prevBuf; + std::ostringstream m_oss; + std::string& m_targetString; + }; + + /////////////////////////////////////////////////////////////////////////// + + class RunContext : public IResultCapture, public IRunner { + + RunContext( RunContext const& ); + void operator =( RunContext const& ); + + public: + + explicit RunContext( Ptr const& _config, Ptr const& reporter ) + : m_runInfo( _config->name() ), + m_context( getCurrentMutableContext() ), + m_activeTestCase( CATCH_NULL ), + m_config( _config ), + m_reporter( reporter ) + { + m_context.setRunner( this ); + m_context.setConfig( m_config ); + m_context.setResultCapture( this ); + m_reporter->testRunStarting( m_runInfo ); + } + + virtual ~RunContext() { + m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) ); + } + + void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) { + m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) ); + } + void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) { + m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) ); + } + + Totals runTest( TestCase const& testCase ) { + Totals prevTotals = m_totals; + + std::string redirectedCout; + std::string redirectedCerr; + + TestCaseInfo testInfo = testCase.getTestCaseInfo(); + + m_reporter->testCaseStarting( testInfo ); + + m_activeTestCase = &testCase; + + do { + m_trackerContext.startRun(); + do { + m_trackerContext.startCycle(); + m_testCaseTracker = &SectionTracker::acquire( m_trackerContext, testInfo.name ); + runCurrentTest( redirectedCout, redirectedCerr ); + } + while( !m_testCaseTracker->isSuccessfullyCompleted() && !aborting() ); + } + // !TBD: deprecated - this will be replaced by indexed trackers + while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() ); + + Totals deltaTotals = m_totals.delta( prevTotals ); + if( testInfo.expectedToFail() && deltaTotals.testCases.passed > 0 ) { + deltaTotals.assertions.failed++; + deltaTotals.testCases.passed--; + deltaTotals.testCases.failed++; + } + m_totals.testCases += deltaTotals.testCases; + m_reporter->testCaseEnded( TestCaseStats( testInfo, + deltaTotals, + redirectedCout, + redirectedCerr, + aborting() ) ); + + m_activeTestCase = CATCH_NULL; + m_testCaseTracker = CATCH_NULL; + + return deltaTotals; + } + + Ptr config() const { + return m_config; + } + + private: // IResultCapture + + virtual void assertionEnded( AssertionResult const& result ) { + if( result.getResultType() == ResultWas::Ok ) { + m_totals.assertions.passed++; + } + else if( !result.isOk() ) { + m_totals.assertions.failed++; + } + + if( m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ) ) + m_messages.clear(); + + // Reset working state + m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition ); + m_lastResult = result; + } + + virtual bool sectionStarted ( + SectionInfo const& sectionInfo, + Counts& assertions + ) + { + std::ostringstream oss; + oss << sectionInfo.name << "@" << sectionInfo.lineInfo; + + ITracker& sectionTracker = SectionTracker::acquire( m_trackerContext, oss.str() ); + if( !sectionTracker.isOpen() ) + return false; + m_activeSections.push_back( §ionTracker ); + + m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo; + + m_reporter->sectionStarting( sectionInfo ); + + assertions = m_totals.assertions; + + return true; + } + bool testForMissingAssertions( Counts& assertions ) { + if( assertions.total() != 0 ) + return false; + if( !m_config->warnAboutMissingAssertions() ) + return false; + if( m_trackerContext.currentTracker().hasChildren() ) + return false; + m_totals.assertions.failed++; + assertions.failed++; + return true; + } + + virtual void sectionEnded( SectionEndInfo const& endInfo ) { + Counts assertions = m_totals.assertions - endInfo.prevAssertions; + bool missingAssertions = testForMissingAssertions( assertions ); + + if( !m_activeSections.empty() ) { + m_activeSections.back()->close(); + m_activeSections.pop_back(); + } + + m_reporter->sectionEnded( SectionStats( endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions ) ); + m_messages.clear(); + } + + virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) { + if( m_unfinishedSections.empty() ) + m_activeSections.back()->fail(); + else + m_activeSections.back()->close(); + m_activeSections.pop_back(); + + m_unfinishedSections.push_back( endInfo ); + } + + virtual void pushScopedMessage( MessageInfo const& message ) { + m_messages.push_back( message ); + } + + virtual void popScopedMessage( MessageInfo const& message ) { + m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() ); + } + + virtual std::string getCurrentTestName() const { + return m_activeTestCase + ? m_activeTestCase->getTestCaseInfo().name + : ""; + } + + virtual const AssertionResult* getLastResult() const { + return &m_lastResult; + } + + virtual void handleFatalErrorCondition( std::string const& message ) { + ResultBuilder resultBuilder = makeUnexpectedResultBuilder(); + resultBuilder.setResultType( ResultWas::FatalErrorCondition ); + resultBuilder << message; + resultBuilder.captureExpression(); + + handleUnfinishedSections(); + + // Recreate section for test case (as we will lose the one that was in scope) + TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); + SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description ); + + Counts assertions; + assertions.failed = 1; + SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false ); + m_reporter->sectionEnded( testCaseSectionStats ); + + TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo(); + + Totals deltaTotals; + deltaTotals.testCases.failed = 1; + m_reporter->testCaseEnded( TestCaseStats( testInfo, + deltaTotals, + "", + "", + false ) ); + m_totals.testCases.failed++; + testGroupEnded( "", m_totals, 1, 1 ); + m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) ); + } + + public: + // !TBD We need to do this another way! + bool aborting() const { + return m_totals.assertions.failed == static_cast( m_config->abortAfter() ); + } + + private: + + void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) { + TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); + SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description ); + m_reporter->sectionStarting( testCaseSection ); + Counts prevAssertions = m_totals.assertions; + double duration = 0; + try { + m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal ); + + seedRng( *m_config ); + + Timer timer; + timer.start(); + if( m_reporter->getPreferences().shouldRedirectStdOut ) { + StreamRedirect coutRedir( Catch::cout(), redirectedCout ); + StreamRedirect cerrRedir( Catch::cerr(), redirectedCerr ); + invokeActiveTestCase(); + } + else { + invokeActiveTestCase(); + } + duration = timer.getElapsedSeconds(); + } + catch( TestFailureException& ) { + // This just means the test was aborted due to failure + } + catch(...) { + makeUnexpectedResultBuilder().useActiveException(); + } + m_testCaseTracker->close(); + handleUnfinishedSections(); + m_messages.clear(); + + Counts assertions = m_totals.assertions - prevAssertions; + bool missingAssertions = testForMissingAssertions( assertions ); + + if( testCaseInfo.okToFail() ) { + std::swap( assertions.failedButOk, assertions.failed ); + m_totals.assertions.failed -= assertions.failedButOk; + m_totals.assertions.failedButOk += assertions.failedButOk; + } + + SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions ); + m_reporter->sectionEnded( testCaseSectionStats ); + } + + void invokeActiveTestCase() { + FatalConditionHandler fatalConditionHandler; // Handle signals + m_activeTestCase->invoke(); + fatalConditionHandler.reset(); + } + + private: + + ResultBuilder makeUnexpectedResultBuilder() const { + return ResultBuilder( m_lastAssertionInfo.macroName.c_str(), + m_lastAssertionInfo.lineInfo, + m_lastAssertionInfo.capturedExpression.c_str(), + m_lastAssertionInfo.resultDisposition ); + } + + void handleUnfinishedSections() { + // If sections ended prematurely due to an exception we stored their + // infos here so we can tear them down outside the unwind process. + for( std::vector::const_reverse_iterator it = m_unfinishedSections.rbegin(), + itEnd = m_unfinishedSections.rend(); + it != itEnd; + ++it ) + sectionEnded( *it ); + m_unfinishedSections.clear(); + } + + TestRunInfo m_runInfo; + IMutableContext& m_context; + TestCase const* m_activeTestCase; + ITracker* m_testCaseTracker; + ITracker* m_currentSectionTracker; + AssertionResult m_lastResult; + + Ptr m_config; + Totals m_totals; + Ptr m_reporter; + std::vector m_messages; + AssertionInfo m_lastAssertionInfo; + std::vector m_unfinishedSections; + std::vector m_activeSections; + TrackerContext m_trackerContext; + }; + + IResultCapture& getResultCapture() { + if( IResultCapture* capture = getCurrentContext().getResultCapture() ) + return *capture; + else + throw std::logic_error( "No result capture instance" ); + } + +} // end namespace Catch + +// #included from: internal/catch_version.h +#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED + +namespace Catch { + + // Versioning information + struct Version { + Version( unsigned int _majorVersion, + unsigned int _minorVersion, + unsigned int _patchNumber, + std::string const& _branchName, + unsigned int _buildNumber ); + + unsigned int const majorVersion; + unsigned int const minorVersion; + unsigned int const patchNumber; + + // buildNumber is only used if branchName is not null + std::string const branchName; + unsigned int const buildNumber; + + friend std::ostream& operator << ( std::ostream& os, Version const& version ); + + private: + void operator=( Version const& ); + }; + + extern Version libraryVersion; +} + +#include +#include +#include + +namespace Catch { + + Ptr createReporter( std::string const& reporterName, Ptr const& config ) { + Ptr reporter = getRegistryHub().getReporterRegistry().create( reporterName, config.get() ); + if( !reporter ) { + std::ostringstream oss; + oss << "No reporter registered with name: '" << reporterName << "'"; + throw std::domain_error( oss.str() ); + } + return reporter; + } + + Ptr makeReporter( Ptr const& config ) { + std::vector reporters = config->getReporterNames(); + if( reporters.empty() ) + reporters.push_back( "console" ); + + Ptr reporter; + for( std::vector::const_iterator it = reporters.begin(), itEnd = reporters.end(); + it != itEnd; + ++it ) + reporter = addReporter( reporter, createReporter( *it, config ) ); + return reporter; + } + Ptr addListeners( Ptr const& config, Ptr reporters ) { + IReporterRegistry::Listeners listeners = getRegistryHub().getReporterRegistry().getListeners(); + for( IReporterRegistry::Listeners::const_iterator it = listeners.begin(), itEnd = listeners.end(); + it != itEnd; + ++it ) + reporters = addReporter(reporters, (*it)->create( ReporterConfig( config ) ) ); + return reporters; + } + + Totals runTests( Ptr const& config ) { + + Ptr iconfig = config.get(); + + Ptr reporter = makeReporter( config ); + reporter = addListeners( iconfig, reporter ); + + RunContext context( iconfig, reporter ); + + Totals totals; + + context.testGroupStarting( config->name(), 1, 1 ); + + TestSpec testSpec = config->testSpec(); + if( !testSpec.hasFilters() ) + testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests + + std::vector const& allTestCases = getAllTestCasesSorted( *iconfig ); + for( std::vector::const_iterator it = allTestCases.begin(), itEnd = allTestCases.end(); + it != itEnd; + ++it ) { + if( !context.aborting() && matchTest( *it, testSpec, *iconfig ) ) + totals += context.runTest( *it ); + else + reporter->skipTest( *it ); + } + + context.testGroupEnded( iconfig->name(), totals, 1, 1 ); + return totals; + } + + void applyFilenamesAsTags( IConfig const& config ) { + std::vector const& tests = getAllTestCasesSorted( config ); + for(std::size_t i = 0; i < tests.size(); ++i ) { + TestCase& test = const_cast( tests[i] ); + std::set tags = test.tags; + + std::string filename = test.lineInfo.file; + std::string::size_type lastSlash = filename.find_last_of( "\\/" ); + if( lastSlash != std::string::npos ) + filename = filename.substr( lastSlash+1 ); + + std::string::size_type lastDot = filename.find_last_of( "." ); + if( lastDot != std::string::npos ) + filename = filename.substr( 0, lastDot ); + + tags.insert( "#" + filename ); + setTags( test, tags ); + } + } + + class Session : NonCopyable { + static bool alreadyInstantiated; + + public: + + struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; }; + + Session() + : m_cli( makeCommandLineParser() ) { + if( alreadyInstantiated ) { + std::string msg = "Only one instance of Catch::Session can ever be used"; + Catch::cerr() << msg << std::endl; + throw std::logic_error( msg ); + } + alreadyInstantiated = true; + } + ~Session() { + Catch::cleanUp(); + } + + void showHelp( std::string const& processName ) { + Catch::cout() << "\nCatch v" << libraryVersion << "\n"; + + m_cli.usage( Catch::cout(), processName ); + Catch::cout() << "For more detail usage please see the project docs\n" << std::endl; + } + + int applyCommandLine( int argc, char const* argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) { + try { + m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail ); + m_unusedTokens = m_cli.parseInto( argc, argv, m_configData ); + if( m_configData.showHelp ) + showHelp( m_configData.processName ); + m_config.reset(); + } + catch( std::exception& ex ) { + { + Colour colourGuard( Colour::Red ); + Catch::cerr() + << "\nError(s) in input:\n" + << Text( ex.what(), TextAttributes().setIndent(2) ) + << "\n\n"; + } + m_cli.usage( Catch::cout(), m_configData.processName ); + return (std::numeric_limits::max)(); + } + return 0; + } + + void useConfigData( ConfigData const& _configData ) { + m_configData = _configData; + m_config.reset(); + } + + int run( int argc, char const* argv[] ) { + + int returnCode = applyCommandLine( argc, argv ); + if( returnCode == 0 ) + returnCode = run(); + return returnCode; + } + int run( int argc, char* argv[] ) { + return run( argc, const_cast( argv ) ); + } + + int run() { + if( m_configData.showHelp ) + return 0; + + try + { + config(); // Force config to be constructed + + seedRng( *m_config ); + + if( m_configData.filenamesAsTags ) + applyFilenamesAsTags( *m_config ); + + // Handle list request + if( Option listed = list( config() ) ) + return static_cast( *listed ); + + return static_cast( runTests( m_config ).assertions.failed ); + } + catch( std::exception& ex ) { + Catch::cerr() << ex.what() << std::endl; + return (std::numeric_limits::max)(); + } + } + + Clara::CommandLine const& cli() const { + return m_cli; + } + std::vector const& unusedTokens() const { + return m_unusedTokens; + } + ConfigData& configData() { + return m_configData; + } + Config& config() { + if( !m_config ) + m_config = new Config( m_configData ); + return *m_config; + } + private: + Clara::CommandLine m_cli; + std::vector m_unusedTokens; + ConfigData m_configData; + Ptr m_config; + }; + + bool Session::alreadyInstantiated = false; + +} // end namespace Catch + +// #included from: catch_registry_hub.hpp +#define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED + +// #included from: catch_test_case_registry_impl.hpp +#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED + +#include +#include +#include +#include +#include + +namespace Catch { + + struct LexSort { + bool operator() (TestCase i,TestCase j) const { return (i sortTests( IConfig const& config, std::vector const& unsortedTestCases ) { + + std::vector sorted = unsortedTestCases; + + switch( config.runOrder() ) { + case RunTests::InLexicographicalOrder: + std::sort( sorted.begin(), sorted.end(), LexSort() ); + break; + case RunTests::InRandomOrder: + { + seedRng( config ); + + RandomNumberGenerator rng; + std::random_shuffle( sorted.begin(), sorted.end(), rng ); + } + break; + case RunTests::InDeclarationOrder: + // already in declaration order + break; + } + return sorted; + } + bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) { + return testSpec.matches( testCase ) && ( config.allowThrows() || !testCase.throws() ); + } + + void enforceNoDuplicateTestCases( std::vector const& functions ) { + std::set seenFunctions; + for( std::vector::const_iterator it = functions.begin(), itEnd = functions.end(); + it != itEnd; + ++it ) { + std::pair::const_iterator, bool> prev = seenFunctions.insert( *it ); + if( !prev.second ){ + Catch::cerr() + << Colour( Colour::Red ) + << "error: TEST_CASE( \"" << it->name << "\" ) already defined.\n" + << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n" + << "\tRedefined at " << it->getTestCaseInfo().lineInfo << std::endl; + exit(1); + } + } + } + + std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config ) { + std::vector filtered; + filtered.reserve( testCases.size() ); + for( std::vector::const_iterator it = testCases.begin(), itEnd = testCases.end(); + it != itEnd; + ++it ) + if( matchTest( *it, testSpec, config ) ) + filtered.push_back( *it ); + return filtered; + } + std::vector const& getAllTestCasesSorted( IConfig const& config ) { + return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config ); + } + + class TestRegistry : public ITestCaseRegistry { + public: + TestRegistry() + : m_currentSortOrder( RunTests::InDeclarationOrder ), + m_unnamedCount( 0 ) + {} + virtual ~TestRegistry(); + + virtual void registerTest( TestCase const& testCase ) { + std::string name = testCase.getTestCaseInfo().name; + if( name == "" ) { + std::ostringstream oss; + oss << "Anonymous test case " << ++m_unnamedCount; + return registerTest( testCase.withName( oss.str() ) ); + } + m_functions.push_back( testCase ); + } + + virtual std::vector const& getAllTests() const { + return m_functions; + } + virtual std::vector const& getAllTestsSorted( IConfig const& config ) const { + if( m_sortedFunctions.empty() ) + enforceNoDuplicateTestCases( m_functions ); + + if( m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) { + m_sortedFunctions = sortTests( config, m_functions ); + m_currentSortOrder = config.runOrder(); + } + return m_sortedFunctions; + } + + private: + std::vector m_functions; + mutable RunTests::InWhatOrder m_currentSortOrder; + mutable std::vector m_sortedFunctions; + size_t m_unnamedCount; + std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised + }; + + /////////////////////////////////////////////////////////////////////////// + + class FreeFunctionTestCase : public SharedImpl { + public: + + FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {} + + virtual void invoke() const { + m_fun(); + } + + private: + virtual ~FreeFunctionTestCase(); + + TestFunction m_fun; + }; + + inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) { + std::string className = classOrQualifiedMethodName; + if( startsWith( className, "&" ) ) + { + std::size_t lastColons = className.rfind( "::" ); + std::size_t penultimateColons = className.rfind( "::", lastColons-1 ); + if( penultimateColons == std::string::npos ) + penultimateColons = 1; + className = className.substr( penultimateColons, lastColons-penultimateColons ); + } + return className; + } + + void registerTestCase + ( ITestCase* testCase, + char const* classOrQualifiedMethodName, + NameAndDesc const& nameAndDesc, + SourceLineInfo const& lineInfo ) { + + getMutableRegistryHub().registerTest + ( makeTestCase + ( testCase, + extractClassName( classOrQualifiedMethodName ), + nameAndDesc.name, + nameAndDesc.description, + lineInfo ) ); + } + void registerTestCaseFunction + ( TestFunction function, + SourceLineInfo const& lineInfo, + NameAndDesc const& nameAndDesc ) { + registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo ); + } + + /////////////////////////////////////////////////////////////////////////// + + AutoReg::AutoReg + ( TestFunction function, + SourceLineInfo const& lineInfo, + NameAndDesc const& nameAndDesc ) { + registerTestCaseFunction( function, lineInfo, nameAndDesc ); + } + + AutoReg::~AutoReg() {} + +} // end namespace Catch + +// #included from: catch_reporter_registry.hpp +#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED + +#include + +namespace Catch { + + class ReporterRegistry : public IReporterRegistry { + + public: + + virtual ~ReporterRegistry() CATCH_OVERRIDE {} + + virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const CATCH_OVERRIDE { + FactoryMap::const_iterator it = m_factories.find( name ); + if( it == m_factories.end() ) + return CATCH_NULL; + return it->second->create( ReporterConfig( config ) ); + } + + void registerReporter( std::string const& name, Ptr const& factory ) { + m_factories.insert( std::make_pair( name, factory ) ); + } + void registerListener( Ptr const& factory ) { + m_listeners.push_back( factory ); + } + + virtual FactoryMap const& getFactories() const CATCH_OVERRIDE { + return m_factories; + } + virtual Listeners const& getListeners() const CATCH_OVERRIDE { + return m_listeners; + } + + private: + FactoryMap m_factories; + Listeners m_listeners; + }; +} + +// #included from: catch_exception_translator_registry.hpp +#define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED + +#ifdef __OBJC__ +#import "Foundation/Foundation.h" +#endif + +namespace Catch { + + class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry { + public: + ~ExceptionTranslatorRegistry() { + deleteAll( m_translators ); + } + + virtual void registerTranslator( const IExceptionTranslator* translator ) { + m_translators.push_back( translator ); + } + + virtual std::string translateActiveException() const { + try { +#ifdef __OBJC__ + // In Objective-C try objective-c exceptions first + @try { + return tryTranslators(); + } + @catch (NSException *exception) { + return Catch::toString( [exception description] ); + } +#else + return tryTranslators(); +#endif + } + catch( TestFailureException& ) { + throw; + } + catch( std::exception& ex ) { + return ex.what(); + } + catch( std::string& msg ) { + return msg; + } + catch( const char* msg ) { + return msg; + } + catch(...) { + return "Unknown exception"; + } + } + + std::string tryTranslators() const { + if( m_translators.empty() ) + throw; + else + return m_translators[0]->translate( m_translators.begin()+1, m_translators.end() ); + } + + private: + std::vector m_translators; + }; +} + +namespace Catch { + + namespace { + + class RegistryHub : public IRegistryHub, public IMutableRegistryHub { + + RegistryHub( RegistryHub const& ); + void operator=( RegistryHub const& ); + + public: // IRegistryHub + RegistryHub() { + } + virtual IReporterRegistry const& getReporterRegistry() const CATCH_OVERRIDE { + return m_reporterRegistry; + } + virtual ITestCaseRegistry const& getTestCaseRegistry() const CATCH_OVERRIDE { + return m_testCaseRegistry; + } + virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() CATCH_OVERRIDE { + return m_exceptionTranslatorRegistry; + } + + public: // IMutableRegistryHub + virtual void registerReporter( std::string const& name, Ptr const& factory ) CATCH_OVERRIDE { + m_reporterRegistry.registerReporter( name, factory ); + } + virtual void registerListener( Ptr const& factory ) CATCH_OVERRIDE { + m_reporterRegistry.registerListener( factory ); + } + virtual void registerTest( TestCase const& testInfo ) CATCH_OVERRIDE { + m_testCaseRegistry.registerTest( testInfo ); + } + virtual void registerTranslator( const IExceptionTranslator* translator ) CATCH_OVERRIDE { + m_exceptionTranslatorRegistry.registerTranslator( translator ); + } + + private: + TestRegistry m_testCaseRegistry; + ReporterRegistry m_reporterRegistry; + ExceptionTranslatorRegistry m_exceptionTranslatorRegistry; + }; + + // Single, global, instance + inline RegistryHub*& getTheRegistryHub() { + static RegistryHub* theRegistryHub = CATCH_NULL; + if( !theRegistryHub ) + theRegistryHub = new RegistryHub(); + return theRegistryHub; + } + } + + IRegistryHub& getRegistryHub() { + return *getTheRegistryHub(); + } + IMutableRegistryHub& getMutableRegistryHub() { + return *getTheRegistryHub(); + } + void cleanUp() { + delete getTheRegistryHub(); + getTheRegistryHub() = CATCH_NULL; + cleanUpContext(); + } + std::string translateActiveException() { + return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException(); + } + +} // end namespace Catch + +// #included from: catch_notimplemented_exception.hpp +#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED + +#include + +namespace Catch { + + NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo ) + : m_lineInfo( lineInfo ) { + std::ostringstream oss; + oss << lineInfo << ": function "; + oss << "not implemented"; + m_what = oss.str(); + } + + const char* NotImplementedException::what() const CATCH_NOEXCEPT { + return m_what.c_str(); + } + +} // end namespace Catch + +// #included from: catch_context_impl.hpp +#define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED + +// #included from: catch_stream.hpp +#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED + +#include +#include +#include + +namespace Catch { + + template + class StreamBufImpl : public StreamBufBase { + char data[bufferSize]; + WriterF m_writer; + + public: + StreamBufImpl() { + setp( data, data + sizeof(data) ); + } + + ~StreamBufImpl() CATCH_NOEXCEPT { + sync(); + } + + private: + int overflow( int c ) { + sync(); + + if( c != EOF ) { + if( pbase() == epptr() ) + m_writer( std::string( 1, static_cast( c ) ) ); + else + sputc( static_cast( c ) ); + } + return 0; + } + + int sync() { + if( pbase() != pptr() ) { + m_writer( std::string( pbase(), static_cast( pptr() - pbase() ) ) ); + setp( pbase(), epptr() ); + } + return 0; + } + }; + + /////////////////////////////////////////////////////////////////////////// + + FileStream::FileStream( std::string const& filename ) { + m_ofs.open( filename.c_str() ); + if( m_ofs.fail() ) { + std::ostringstream oss; + oss << "Unable to open file: '" << filename << "'"; + throw std::domain_error( oss.str() ); + } + } + + std::ostream& FileStream::stream() const { + return m_ofs; + } + + struct OutputDebugWriter { + + void operator()( std::string const&str ) { + writeToDebugConsole( str ); + } + }; + + DebugOutStream::DebugOutStream() + : m_streamBuf( new StreamBufImpl() ), + m_os( m_streamBuf.get() ) + {} + + std::ostream& DebugOutStream::stream() const { + return m_os; + } + + // Store the streambuf from cout up-front because + // cout may get redirected when running tests + CoutStream::CoutStream() + : m_os( Catch::cout().rdbuf() ) + {} + + std::ostream& CoutStream::stream() const { + return m_os; + } + +#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions + std::ostream& cout() { + return std::cout; + } + std::ostream& cerr() { + return std::cerr; + } +#endif +} + +namespace Catch { + + class Context : public IMutableContext { + + Context() : m_config( CATCH_NULL ), m_runner( CATCH_NULL ), m_resultCapture( CATCH_NULL ) {} + Context( Context const& ); + void operator=( Context const& ); + + public: // IContext + virtual IResultCapture* getResultCapture() { + return m_resultCapture; + } + virtual IRunner* getRunner() { + return m_runner; + } + virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) { + return getGeneratorsForCurrentTest() + .getGeneratorInfo( fileInfo, totalSize ) + .getCurrentIndex(); + } + virtual bool advanceGeneratorsForCurrentTest() { + IGeneratorsForTest* generators = findGeneratorsForCurrentTest(); + return generators && generators->moveNext(); + } + + virtual Ptr getConfig() const { + return m_config; + } + + public: // IMutableContext + virtual void setResultCapture( IResultCapture* resultCapture ) { + m_resultCapture = resultCapture; + } + virtual void setRunner( IRunner* runner ) { + m_runner = runner; + } + virtual void setConfig( Ptr const& config ) { + m_config = config; + } + + friend IMutableContext& getCurrentMutableContext(); + + private: + IGeneratorsForTest* findGeneratorsForCurrentTest() { + std::string testName = getResultCapture()->getCurrentTestName(); + + std::map::const_iterator it = + m_generatorsByTestName.find( testName ); + return it != m_generatorsByTestName.end() + ? it->second + : CATCH_NULL; + } + + IGeneratorsForTest& getGeneratorsForCurrentTest() { + IGeneratorsForTest* generators = findGeneratorsForCurrentTest(); + if( !generators ) { + std::string testName = getResultCapture()->getCurrentTestName(); + generators = createGeneratorsForTest(); + m_generatorsByTestName.insert( std::make_pair( testName, generators ) ); + } + return *generators; + } + + private: + Ptr m_config; + IRunner* m_runner; + IResultCapture* m_resultCapture; + std::map m_generatorsByTestName; + }; + + namespace { + Context* currentContext = CATCH_NULL; + } + IMutableContext& getCurrentMutableContext() { + if( !currentContext ) + currentContext = new Context(); + return *currentContext; + } + IContext& getCurrentContext() { + return getCurrentMutableContext(); + } + + void cleanUpContext() { + delete currentContext; + currentContext = CATCH_NULL; + } +} + +// #included from: catch_console_colour_impl.hpp +#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED + +namespace Catch { + namespace { + + struct IColourImpl { + virtual ~IColourImpl() {} + virtual void use( Colour::Code _colourCode ) = 0; + }; + + struct NoColourImpl : IColourImpl { + void use( Colour::Code ) {} + + static IColourImpl* instance() { + static NoColourImpl s_instance; + return &s_instance; + } + }; + + } // anon namespace +} // namespace Catch + +#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI ) +# ifdef CATCH_PLATFORM_WINDOWS +# define CATCH_CONFIG_COLOUR_WINDOWS +# else +# define CATCH_CONFIG_COLOUR_ANSI +# endif +#endif + +#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) ///////////////////////////////////////// + +#ifndef NOMINMAX +#define NOMINMAX +#endif + +#ifdef __AFXDLL +#include +#else +#include +#endif + +namespace Catch { +namespace { + + class Win32ColourImpl : public IColourImpl { + public: + Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) ) + { + CONSOLE_SCREEN_BUFFER_INFO csbiInfo; + GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo ); + originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY ); + originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY ); + } + + virtual void use( Colour::Code _colourCode ) { + switch( _colourCode ) { + case Colour::None: return setTextAttribute( originalForegroundAttributes ); + case Colour::White: return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); + case Colour::Red: return setTextAttribute( FOREGROUND_RED ); + case Colour::Green: return setTextAttribute( FOREGROUND_GREEN ); + case Colour::Blue: return setTextAttribute( FOREGROUND_BLUE ); + case Colour::Cyan: return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN ); + case Colour::Yellow: return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN ); + case Colour::Grey: return setTextAttribute( 0 ); + + case Colour::LightGrey: return setTextAttribute( FOREGROUND_INTENSITY ); + case Colour::BrightRed: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED ); + case Colour::BrightGreen: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN ); + case Colour::BrightWhite: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); + + case Colour::Bright: throw std::logic_error( "not a colour" ); + } + } + + private: + void setTextAttribute( WORD _textAttribute ) { + SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes ); + } + HANDLE stdoutHandle; + WORD originalForegroundAttributes; + WORD originalBackgroundAttributes; + }; + + IColourImpl* platformColourInstance() { + static Win32ColourImpl s_instance; + + Ptr config = getCurrentContext().getConfig(); + UseColour::YesOrNo colourMode = config + ? config->useColour() + : UseColour::Auto; + if( colourMode == UseColour::Auto ) + colourMode = !isDebuggerActive() + ? UseColour::Yes + : UseColour::No; + return colourMode == UseColour::Yes + ? &s_instance + : NoColourImpl::instance(); + } + +} // end anon namespace +} // end namespace Catch + +#elif defined( CATCH_CONFIG_COLOUR_ANSI ) ////////////////////////////////////// + +#include + +namespace Catch { +namespace { + + // use POSIX/ ANSI console terminal codes + // Thanks to Adam Strzelecki for original contribution + // (http://github.com/nanoant) + // https://github.com/philsquared/Catch/pull/131 + class PosixColourImpl : public IColourImpl { + public: + virtual void use( Colour::Code _colourCode ) { + switch( _colourCode ) { + case Colour::None: + case Colour::White: return setColour( "[0m" ); + case Colour::Red: return setColour( "[0;31m" ); + case Colour::Green: return setColour( "[0;32m" ); + case Colour::Blue: return setColour( "[0:34m" ); + case Colour::Cyan: return setColour( "[0;36m" ); + case Colour::Yellow: return setColour( "[0;33m" ); + case Colour::Grey: return setColour( "[1;30m" ); + + case Colour::LightGrey: return setColour( "[0;37m" ); + case Colour::BrightRed: return setColour( "[1;31m" ); + case Colour::BrightGreen: return setColour( "[1;32m" ); + case Colour::BrightWhite: return setColour( "[1;37m" ); + + case Colour::Bright: throw std::logic_error( "not a colour" ); + } + } + static IColourImpl* instance() { + static PosixColourImpl s_instance; + return &s_instance; + } + + private: + void setColour( const char* _escapeCode ) { + Catch::cout() << '\033' << _escapeCode; + } + }; + + IColourImpl* platformColourInstance() { + Ptr config = getCurrentContext().getConfig(); + UseColour::YesOrNo colourMode = config + ? config->useColour() + : UseColour::Auto; + if( colourMode == UseColour::Auto ) + colourMode = (!isDebuggerActive() && isatty(STDOUT_FILENO) ) + ? UseColour::Yes + : UseColour::No; + return colourMode == UseColour::Yes + ? PosixColourImpl::instance() + : NoColourImpl::instance(); + } + +} // end anon namespace +} // end namespace Catch + +#else // not Windows or ANSI /////////////////////////////////////////////// + +namespace Catch { + + static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); } + +} // end namespace Catch + +#endif // Windows/ ANSI/ None + +namespace Catch { + + Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); } + Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast( _other ).m_moved = true; } + Colour::~Colour(){ if( !m_moved ) use( None ); } + + void Colour::use( Code _colourCode ) { + static IColourImpl* impl = platformColourInstance(); + impl->use( _colourCode ); + } + +} // end namespace Catch + +// #included from: catch_generators_impl.hpp +#define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED + +#include +#include +#include + +namespace Catch { + + struct GeneratorInfo : IGeneratorInfo { + + GeneratorInfo( std::size_t size ) + : m_size( size ), + m_currentIndex( 0 ) + {} + + bool moveNext() { + if( ++m_currentIndex == m_size ) { + m_currentIndex = 0; + return false; + } + return true; + } + + std::size_t getCurrentIndex() const { + return m_currentIndex; + } + + std::size_t m_size; + std::size_t m_currentIndex; + }; + + /////////////////////////////////////////////////////////////////////////// + + class GeneratorsForTest : public IGeneratorsForTest { + + public: + ~GeneratorsForTest() { + deleteAll( m_generatorsInOrder ); + } + + IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) { + std::map::const_iterator it = m_generatorsByName.find( fileInfo ); + if( it == m_generatorsByName.end() ) { + IGeneratorInfo* info = new GeneratorInfo( size ); + m_generatorsByName.insert( std::make_pair( fileInfo, info ) ); + m_generatorsInOrder.push_back( info ); + return *info; + } + return *it->second; + } + + bool moveNext() { + std::vector::const_iterator it = m_generatorsInOrder.begin(); + std::vector::const_iterator itEnd = m_generatorsInOrder.end(); + for(; it != itEnd; ++it ) { + if( (*it)->moveNext() ) + return true; + } + return false; + } + + private: + std::map m_generatorsByName; + std::vector m_generatorsInOrder; + }; + + IGeneratorsForTest* createGeneratorsForTest() + { + return new GeneratorsForTest(); + } + +} // end namespace Catch + +// #included from: catch_assertionresult.hpp +#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED + +namespace Catch { + + AssertionInfo::AssertionInfo( std::string const& _macroName, + SourceLineInfo const& _lineInfo, + std::string const& _capturedExpression, + ResultDisposition::Flags _resultDisposition ) + : macroName( _macroName ), + lineInfo( _lineInfo ), + capturedExpression( _capturedExpression ), + resultDisposition( _resultDisposition ) + {} + + AssertionResult::AssertionResult() {} + + AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data ) + : m_info( info ), + m_resultData( data ) + {} + + AssertionResult::~AssertionResult() {} + + // Result was a success + bool AssertionResult::succeeded() const { + return Catch::isOk( m_resultData.resultType ); + } + + // Result was a success, or failure is suppressed + bool AssertionResult::isOk() const { + return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition ); + } + + ResultWas::OfType AssertionResult::getResultType() const { + return m_resultData.resultType; + } + + bool AssertionResult::hasExpression() const { + return !m_info.capturedExpression.empty(); + } + + bool AssertionResult::hasMessage() const { + return !m_resultData.message.empty(); + } + + std::string AssertionResult::getExpression() const { + if( isFalseTest( m_info.resultDisposition ) ) + return "!" + m_info.capturedExpression; + else + return m_info.capturedExpression; + } + std::string AssertionResult::getExpressionInMacro() const { + if( m_info.macroName.empty() ) + return m_info.capturedExpression; + else + return m_info.macroName + "( " + m_info.capturedExpression + " )"; + } + + bool AssertionResult::hasExpandedExpression() const { + return hasExpression() && getExpandedExpression() != getExpression(); + } + + std::string AssertionResult::getExpandedExpression() const { + return m_resultData.reconstructedExpression; + } + + std::string AssertionResult::getMessage() const { + return m_resultData.message; + } + SourceLineInfo AssertionResult::getSourceInfo() const { + return m_info.lineInfo; + } + + std::string AssertionResult::getTestMacroName() const { + return m_info.macroName; + } + +} // end namespace Catch + +// #included from: catch_test_case_info.hpp +#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED + +namespace Catch { + + inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) { + if( startsWith( tag, "." ) || + tag == "hide" || + tag == "!hide" ) + return TestCaseInfo::IsHidden; + else if( tag == "!throws" ) + return TestCaseInfo::Throws; + else if( tag == "!shouldfail" ) + return TestCaseInfo::ShouldFail; + else if( tag == "!mayfail" ) + return TestCaseInfo::MayFail; + else + return TestCaseInfo::None; + } + inline bool isReservedTag( std::string const& tag ) { + return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !isalnum( tag[0] ); + } + inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) { + if( isReservedTag( tag ) ) { + { + Colour colourGuard( Colour::Red ); + Catch::cerr() + << "Tag name [" << tag << "] not allowed.\n" + << "Tag names starting with non alpha-numeric characters are reserved\n"; + } + { + Colour colourGuard( Colour::FileName ); + Catch::cerr() << _lineInfo << std::endl; + } + exit(1); + } + } + + TestCase makeTestCase( ITestCase* _testCase, + std::string const& _className, + std::string const& _name, + std::string const& _descOrTags, + SourceLineInfo const& _lineInfo ) + { + bool isHidden( startsWith( _name, "./" ) ); // Legacy support + + // Parse out tags + std::set tags; + std::string desc, tag; + bool inTag = false; + for( std::size_t i = 0; i < _descOrTags.size(); ++i ) { + char c = _descOrTags[i]; + if( !inTag ) { + if( c == '[' ) + inTag = true; + else + desc += c; + } + else { + if( c == ']' ) { + TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag ); + if( prop == TestCaseInfo::IsHidden ) + isHidden = true; + else if( prop == TestCaseInfo::None ) + enforceNotReservedTag( tag, _lineInfo ); + + tags.insert( tag ); + tag.clear(); + inTag = false; + } + else + tag += c; + } + } + if( isHidden ) { + tags.insert( "hide" ); + tags.insert( "." ); + } + + TestCaseInfo info( _name, _className, desc, tags, _lineInfo ); + return TestCase( _testCase, info ); + } + + void setTags( TestCaseInfo& testCaseInfo, std::set const& tags ) + { + testCaseInfo.tags = tags; + testCaseInfo.lcaseTags.clear(); + + std::ostringstream oss; + for( std::set::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it ) { + oss << "[" << *it << "]"; + std::string lcaseTag = toLower( *it ); + testCaseInfo.properties = static_cast( testCaseInfo.properties | parseSpecialTag( lcaseTag ) ); + testCaseInfo.lcaseTags.insert( lcaseTag ); + } + testCaseInfo.tagsAsString = oss.str(); + } + + TestCaseInfo::TestCaseInfo( std::string const& _name, + std::string const& _className, + std::string const& _description, + std::set const& _tags, + SourceLineInfo const& _lineInfo ) + : name( _name ), + className( _className ), + description( _description ), + lineInfo( _lineInfo ), + properties( None ) + { + setTags( *this, _tags ); + } + + TestCaseInfo::TestCaseInfo( TestCaseInfo const& other ) + : name( other.name ), + className( other.className ), + description( other.description ), + tags( other.tags ), + lcaseTags( other.lcaseTags ), + tagsAsString( other.tagsAsString ), + lineInfo( other.lineInfo ), + properties( other.properties ) + {} + + bool TestCaseInfo::isHidden() const { + return ( properties & IsHidden ) != 0; + } + bool TestCaseInfo::throws() const { + return ( properties & Throws ) != 0; + } + bool TestCaseInfo::okToFail() const { + return ( properties & (ShouldFail | MayFail ) ) != 0; + } + bool TestCaseInfo::expectedToFail() const { + return ( properties & (ShouldFail ) ) != 0; + } + + TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {} + + TestCase::TestCase( TestCase const& other ) + : TestCaseInfo( other ), + test( other.test ) + {} + + TestCase TestCase::withName( std::string const& _newName ) const { + TestCase other( *this ); + other.name = _newName; + return other; + } + + void TestCase::swap( TestCase& other ) { + test.swap( other.test ); + name.swap( other.name ); + className.swap( other.className ); + description.swap( other.description ); + tags.swap( other.tags ); + lcaseTags.swap( other.lcaseTags ); + tagsAsString.swap( other.tagsAsString ); + std::swap( TestCaseInfo::properties, static_cast( other ).properties ); + std::swap( lineInfo, other.lineInfo ); + } + + void TestCase::invoke() const { + test->invoke(); + } + + bool TestCase::operator == ( TestCase const& other ) const { + return test.get() == other.test.get() && + name == other.name && + className == other.className; + } + + bool TestCase::operator < ( TestCase const& other ) const { + return name < other.name; + } + TestCase& TestCase::operator = ( TestCase const& other ) { + TestCase temp( other ); + swap( temp ); + return *this; + } + + TestCaseInfo const& TestCase::getTestCaseInfo() const + { + return *this; + } + +} // end namespace Catch + +// #included from: catch_version.hpp +#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED + +namespace Catch { + + Version::Version + ( unsigned int _majorVersion, + unsigned int _minorVersion, + unsigned int _patchNumber, + std::string const& _branchName, + unsigned int _buildNumber ) + : majorVersion( _majorVersion ), + minorVersion( _minorVersion ), + patchNumber( _patchNumber ), + branchName( _branchName ), + buildNumber( _buildNumber ) + {} + + std::ostream& operator << ( std::ostream& os, Version const& version ) { + os << version.majorVersion << "." + << version.minorVersion << "." + << version.patchNumber; + + if( !version.branchName.empty() ) { + os << "-" << version.branchName + << "." << version.buildNumber; + } + return os; + } + + Version libraryVersion( 1, 4, 0, "", 0 ); + +} + +// #included from: catch_message.hpp +#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED + +namespace Catch { + + MessageInfo::MessageInfo( std::string const& _macroName, + SourceLineInfo const& _lineInfo, + ResultWas::OfType _type ) + : macroName( _macroName ), + lineInfo( _lineInfo ), + type( _type ), + sequence( ++globalCount ) + {} + + // This may need protecting if threading support is added + unsigned int MessageInfo::globalCount = 0; + + //////////////////////////////////////////////////////////////////////////// + + ScopedMessage::ScopedMessage( MessageBuilder const& builder ) + : m_info( builder.m_info ) + { + m_info.message = builder.m_stream.str(); + getResultCapture().pushScopedMessage( m_info ); + } + ScopedMessage::ScopedMessage( ScopedMessage const& other ) + : m_info( other.m_info ) + {} + + ScopedMessage::~ScopedMessage() { + getResultCapture().popScopedMessage( m_info ); + } + +} // end namespace Catch + +// #included from: catch_legacy_reporter_adapter.hpp +#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED + +// #included from: catch_legacy_reporter_adapter.h +#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED + +namespace Catch +{ + // Deprecated + struct IReporter : IShared { + virtual ~IReporter(); + + virtual bool shouldRedirectStdout() const = 0; + + virtual void StartTesting() = 0; + virtual void EndTesting( Totals const& totals ) = 0; + virtual void StartGroup( std::string const& groupName ) = 0; + virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0; + virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0; + virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0; + virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0; + virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0; + virtual void NoAssertionsInSection( std::string const& sectionName ) = 0; + virtual void NoAssertionsInTestCase( std::string const& testName ) = 0; + virtual void Aborted() = 0; + virtual void Result( AssertionResult const& result ) = 0; + }; + + class LegacyReporterAdapter : public SharedImpl + { + public: + LegacyReporterAdapter( Ptr const& legacyReporter ); + virtual ~LegacyReporterAdapter(); + + virtual ReporterPreferences getPreferences() const; + virtual void noMatchingTestCases( std::string const& ); + virtual void testRunStarting( TestRunInfo const& ); + virtual void testGroupStarting( GroupInfo const& groupInfo ); + virtual void testCaseStarting( TestCaseInfo const& testInfo ); + virtual void sectionStarting( SectionInfo const& sectionInfo ); + virtual void assertionStarting( AssertionInfo const& ); + virtual bool assertionEnded( AssertionStats const& assertionStats ); + virtual void sectionEnded( SectionStats const& sectionStats ); + virtual void testCaseEnded( TestCaseStats const& testCaseStats ); + virtual void testGroupEnded( TestGroupStats const& testGroupStats ); + virtual void testRunEnded( TestRunStats const& testRunStats ); + virtual void skipTest( TestCaseInfo const& ); + + private: + Ptr m_legacyReporter; + }; +} + +namespace Catch +{ + LegacyReporterAdapter::LegacyReporterAdapter( Ptr const& legacyReporter ) + : m_legacyReporter( legacyReporter ) + {} + LegacyReporterAdapter::~LegacyReporterAdapter() {} + + ReporterPreferences LegacyReporterAdapter::getPreferences() const { + ReporterPreferences prefs; + prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout(); + return prefs; + } + + void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {} + void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) { + m_legacyReporter->StartTesting(); + } + void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) { + m_legacyReporter->StartGroup( groupInfo.name ); + } + void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) { + m_legacyReporter->StartTestCase( testInfo ); + } + void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) { + m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description ); + } + void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) { + // Not on legacy interface + } + + bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) { + if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) { + for( std::vector::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end(); + it != itEnd; + ++it ) { + if( it->type == ResultWas::Info ) { + ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal ); + rb << it->message; + rb.setResultType( ResultWas::Info ); + AssertionResult result = rb.build(); + m_legacyReporter->Result( result ); + } + } + } + m_legacyReporter->Result( assertionStats.assertionResult ); + return true; + } + void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) { + if( sectionStats.missingAssertions ) + m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name ); + m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions ); + } + void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) { + m_legacyReporter->EndTestCase + ( testCaseStats.testInfo, + testCaseStats.totals, + testCaseStats.stdOut, + testCaseStats.stdErr ); + } + void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) { + if( testGroupStats.aborting ) + m_legacyReporter->Aborted(); + m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals ); + } + void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) { + m_legacyReporter->EndTesting( testRunStats.totals ); + } + void LegacyReporterAdapter::skipTest( TestCaseInfo const& ) { + } +} + +// #included from: catch_timer.hpp + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wc++11-long-long" +#endif + +#ifdef CATCH_PLATFORM_WINDOWS +#include +#else +#include +#endif + +namespace Catch { + + namespace { +#ifdef CATCH_PLATFORM_WINDOWS + uint64_t getCurrentTicks() { + static uint64_t hz=0, hzo=0; + if (!hz) { + QueryPerformanceFrequency( reinterpret_cast( &hz ) ); + QueryPerformanceCounter( reinterpret_cast( &hzo ) ); + } + uint64_t t; + QueryPerformanceCounter( reinterpret_cast( &t ) ); + return ((t-hzo)*1000000)/hz; + } +#else + uint64_t getCurrentTicks() { + timeval t; + gettimeofday(&t,CATCH_NULL); + return static_cast( t.tv_sec ) * 1000000ull + static_cast( t.tv_usec ); + } +#endif + } + + void Timer::start() { + m_ticks = getCurrentTicks(); + } + unsigned int Timer::getElapsedMicroseconds() const { + return static_cast(getCurrentTicks() - m_ticks); + } + unsigned int Timer::getElapsedMilliseconds() const { + return static_cast(getElapsedMicroseconds()/1000); + } + double Timer::getElapsedSeconds() const { + return getElapsedMicroseconds()/1000000.0; + } + +} // namespace Catch + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif +// #included from: catch_common.hpp +#define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED + +namespace Catch { + + bool startsWith( std::string const& s, std::string const& prefix ) { + return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix; + } + bool endsWith( std::string const& s, std::string const& suffix ) { + return s.size() >= suffix.size() && s.substr( s.size()-suffix.size(), suffix.size() ) == suffix; + } + bool contains( std::string const& s, std::string const& infix ) { + return s.find( infix ) != std::string::npos; + } + void toLowerInPlace( std::string& s ) { + std::transform( s.begin(), s.end(), s.begin(), ::tolower ); + } + std::string toLower( std::string const& s ) { + std::string lc = s; + toLowerInPlace( lc ); + return lc; + } + std::string trim( std::string const& str ) { + static char const* whitespaceChars = "\n\r\t "; + std::string::size_type start = str.find_first_not_of( whitespaceChars ); + std::string::size_type end = str.find_last_not_of( whitespaceChars ); + + return start != std::string::npos ? str.substr( start, 1+end-start ) : ""; + } + + bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) { + bool replaced = false; + std::size_t i = str.find( replaceThis ); + while( i != std::string::npos ) { + replaced = true; + str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() ); + if( i < str.size()-withThis.size() ) + i = str.find( replaceThis, i+withThis.size() ); + else + i = std::string::npos; + } + return replaced; + } + + pluralise::pluralise( std::size_t count, std::string const& label ) + : m_count( count ), + m_label( label ) + {} + + std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) { + os << pluraliser.m_count << " " << pluraliser.m_label; + if( pluraliser.m_count != 1 ) + os << "s"; + return os; + } + + SourceLineInfo::SourceLineInfo() : line( 0 ){} + SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line ) + : file( _file ), + line( _line ) + {} + SourceLineInfo::SourceLineInfo( SourceLineInfo const& other ) + : file( other.file ), + line( other.line ) + {} + bool SourceLineInfo::empty() const { + return file.empty(); + } + bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const { + return line == other.line && file == other.file; + } + bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const { + return line < other.line || ( line == other.line && file < other.file ); + } + + void seedRng( IConfig const& config ) { + if( config.rngSeed() != 0 ) + std::srand( config.rngSeed() ); + } + unsigned int rngSeed() { + return getCurrentContext().getConfig()->rngSeed(); + } + + std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) { +#ifndef __GNUG__ + os << info.file << "(" << info.line << ")"; +#else + os << info.file << ":" << info.line; +#endif + return os; + } + + void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) { + std::ostringstream oss; + oss << locationInfo << ": Internal Catch error: '" << message << "'"; + if( alwaysTrue() ) + throw std::logic_error( oss.str() ); + } +} + +// #included from: catch_section.hpp +#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED + +namespace Catch { + + SectionInfo::SectionInfo + ( SourceLineInfo const& _lineInfo, + std::string const& _name, + std::string const& _description ) + : name( _name ), + description( _description ), + lineInfo( _lineInfo ) + {} + + Section::Section( SectionInfo const& info ) + : m_info( info ), + m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) ) + { + m_timer.start(); + } + + Section::~Section() { + if( m_sectionIncluded ) { + SectionEndInfo endInfo( m_info, m_assertions, m_timer.getElapsedSeconds() ); + if( std::uncaught_exception() ) + getResultCapture().sectionEndedEarly( endInfo ); + else + getResultCapture().sectionEnded( endInfo ); + } + } + + // This indicates whether the section should be executed or not + Section::operator bool() const { + return m_sectionIncluded; + } + +} // end namespace Catch + +// #included from: catch_debugger.hpp +#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED + +#include + +#ifdef CATCH_PLATFORM_MAC + + #include + #include + #include + #include + #include + + namespace Catch{ + + // The following function is taken directly from the following technical note: + // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html + + // Returns true if the current process is being debugged (either + // running under the debugger or has a debugger attached post facto). + bool isDebuggerActive(){ + + int mib[4]; + struct kinfo_proc info; + size_t size; + + // Initialize the flags so that, if sysctl fails for some bizarre + // reason, we get a predictable result. + + info.kp_proc.p_flag = 0; + + // Initialize mib, which tells sysctl the info we want, in this case + // we're looking for information about a specific process ID. + + mib[0] = CTL_KERN; + mib[1] = KERN_PROC; + mib[2] = KERN_PROC_PID; + mib[3] = getpid(); + + // Call sysctl. + + size = sizeof(info); + if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, CATCH_NULL, 0) != 0 ) { + Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl; + return false; + } + + // We're being debugged if the P_TRACED flag is set. + + return ( (info.kp_proc.p_flag & P_TRACED) != 0 ); + } + } // namespace Catch + +#elif defined(_MSC_VER) + extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); + namespace Catch { + bool isDebuggerActive() { + return IsDebuggerPresent() != 0; + } + } +#elif defined(__MINGW32__) + extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); + namespace Catch { + bool isDebuggerActive() { + return IsDebuggerPresent() != 0; + } + } +#else + namespace Catch { + inline bool isDebuggerActive() { return false; } + } +#endif // Platform + +#ifdef CATCH_PLATFORM_WINDOWS + extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA( const char* ); + namespace Catch { + void writeToDebugConsole( std::string const& text ) { + ::OutputDebugStringA( text.c_str() ); + } + } +#else + namespace Catch { + void writeToDebugConsole( std::string const& text ) { + // !TBD: Need a version for Mac/ XCode and other IDEs + Catch::cout() << text; + } + } +#endif // Platform + +// #included from: catch_tostring.hpp +#define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED + +namespace Catch { + +namespace Detail { + + const std::string unprintableString = "{?}"; + + namespace { + const int hexThreshold = 255; + + struct Endianness { + enum Arch { Big, Little }; + + static Arch which() { + union _{ + int asInt; + char asChar[sizeof (int)]; + } u; + + u.asInt = 1; + return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little; + } + }; + } + + std::string rawMemoryToString( const void *object, std::size_t size ) + { + // Reverse order for little endian architectures + int i = 0, end = static_cast( size ), inc = 1; + if( Endianness::which() == Endianness::Little ) { + i = end-1; + end = inc = -1; + } + + unsigned char const *bytes = static_cast(object); + std::ostringstream os; + os << "0x" << std::setfill('0') << std::hex; + for( ; i != end; i += inc ) + os << std::setw(2) << static_cast(bytes[i]); + return os.str(); + } +} + +std::string toString( std::string const& value ) { + std::string s = value; + if( getCurrentContext().getConfig()->showInvisibles() ) { + for(size_t i = 0; i < s.size(); ++i ) { + std::string subs; + switch( s[i] ) { + case '\n': subs = "\\n"; break; + case '\t': subs = "\\t"; break; + default: break; + } + if( !subs.empty() ) { + s = s.substr( 0, i ) + subs + s.substr( i+1 ); + ++i; + } + } + } + return "\"" + s + "\""; +} +std::string toString( std::wstring const& value ) { + + std::string s; + s.reserve( value.size() ); + for(size_t i = 0; i < value.size(); ++i ) + s += value[i] <= 0xff ? static_cast( value[i] ) : '?'; + return Catch::toString( s ); +} + +std::string toString( const char* const value ) { + return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" ); +} + +std::string toString( char* const value ) { + return Catch::toString( static_cast( value ) ); +} + +std::string toString( const wchar_t* const value ) +{ + return value ? Catch::toString( std::wstring(value) ) : std::string( "{null string}" ); +} + +std::string toString( wchar_t* const value ) +{ + return Catch::toString( static_cast( value ) ); +} + +std::string toString( int value ) { + std::ostringstream oss; + oss << value; + if( value > Detail::hexThreshold ) + oss << " (0x" << std::hex << value << ")"; + return oss.str(); +} + +std::string toString( unsigned long value ) { + std::ostringstream oss; + oss << value; + if( value > Detail::hexThreshold ) + oss << " (0x" << std::hex << value << ")"; + return oss.str(); +} + +std::string toString( unsigned int value ) { + return Catch::toString( static_cast( value ) ); +} + +template +std::string fpToString( T value, int precision ) { + std::ostringstream oss; + oss << std::setprecision( precision ) + << std::fixed + << value; + std::string d = oss.str(); + std::size_t i = d.find_last_not_of( '0' ); + if( i != std::string::npos && i != d.size()-1 ) { + if( d[i] == '.' ) + i++; + d = d.substr( 0, i+1 ); + } + return d; +} + +std::string toString( const double value ) { + return fpToString( value, 10 ); +} +std::string toString( const float value ) { + return fpToString( value, 5 ) + "f"; +} + +std::string toString( bool value ) { + return value ? "true" : "false"; +} + +std::string toString( char value ) { + return value < ' ' + ? toString( static_cast( value ) ) + : Detail::makeString( value ); +} + +std::string toString( signed char value ) { + return toString( static_cast( value ) ); +} + +std::string toString( unsigned char value ) { + return toString( static_cast( value ) ); +} + +#ifdef CATCH_CONFIG_CPP11_LONG_LONG +std::string toString( long long value ) { + std::ostringstream oss; + oss << value; + if( value > Detail::hexThreshold ) + oss << " (0x" << std::hex << value << ")"; + return oss.str(); +} +std::string toString( unsigned long long value ) { + std::ostringstream oss; + oss << value; + if( value > Detail::hexThreshold ) + oss << " (0x" << std::hex << value << ")"; + return oss.str(); +} +#endif + +#ifdef CATCH_CONFIG_CPP11_NULLPTR +std::string toString( std::nullptr_t ) { + return "nullptr"; +} +#endif + +#ifdef __OBJC__ + std::string toString( NSString const * const& nsstring ) { + if( !nsstring ) + return "nil"; + return "@" + toString([nsstring UTF8String]); + } + std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ) { + if( !nsstring ) + return "nil"; + return "@" + toString([nsstring UTF8String]); + } + std::string toString( NSObject* const& nsObject ) { + return toString( [nsObject description] ); + } +#endif + +} // end namespace Catch + +// #included from: catch_result_builder.hpp +#define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED + +namespace Catch { + + std::string capturedExpressionWithSecondArgument( std::string const& capturedExpression, std::string const& secondArg ) { + return secondArg.empty() || secondArg == "\"\"" + ? capturedExpression + : capturedExpression + ", " + secondArg; + } + ResultBuilder::ResultBuilder( char const* macroName, + SourceLineInfo const& lineInfo, + char const* capturedExpression, + ResultDisposition::Flags resultDisposition, + char const* secondArg ) + : m_assertionInfo( macroName, lineInfo, capturedExpressionWithSecondArgument( capturedExpression, secondArg ), resultDisposition ), + m_shouldDebugBreak( false ), + m_shouldThrow( false ) + {} + + ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) { + m_data.resultType = result; + return *this; + } + ResultBuilder& ResultBuilder::setResultType( bool result ) { + m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed; + return *this; + } + ResultBuilder& ResultBuilder::setLhs( std::string const& lhs ) { + m_exprComponents.lhs = lhs; + return *this; + } + ResultBuilder& ResultBuilder::setRhs( std::string const& rhs ) { + m_exprComponents.rhs = rhs; + return *this; + } + ResultBuilder& ResultBuilder::setOp( std::string const& op ) { + m_exprComponents.op = op; + return *this; + } + + void ResultBuilder::endExpression() { + m_exprComponents.testFalse = isFalseTest( m_assertionInfo.resultDisposition ); + captureExpression(); + } + + void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) { + m_assertionInfo.resultDisposition = resultDisposition; + m_stream.oss << Catch::translateActiveException(); + captureResult( ResultWas::ThrewException ); + } + + void ResultBuilder::captureResult( ResultWas::OfType resultType ) { + setResultType( resultType ); + captureExpression(); + } + void ResultBuilder::captureExpectedException( std::string const& expectedMessage ) { + if( expectedMessage.empty() ) + captureExpectedException( Matchers::Impl::Generic::AllOf() ); + else + captureExpectedException( Matchers::Equals( expectedMessage ) ); + } + + void ResultBuilder::captureExpectedException( Matchers::Impl::Matcher const& matcher ) { + + assert( m_exprComponents.testFalse == false ); + AssertionResultData data = m_data; + data.resultType = ResultWas::Ok; + data.reconstructedExpression = m_assertionInfo.capturedExpression; + + std::string actualMessage = Catch::translateActiveException(); + if( !matcher.match( actualMessage ) ) { + data.resultType = ResultWas::ExpressionFailed; + data.reconstructedExpression = actualMessage; + } + AssertionResult result( m_assertionInfo, data ); + handleResult( result ); + } + + void ResultBuilder::captureExpression() { + AssertionResult result = build(); + handleResult( result ); + } + void ResultBuilder::handleResult( AssertionResult const& result ) + { + getResultCapture().assertionEnded( result ); + + if( !result.isOk() ) { + if( getCurrentContext().getConfig()->shouldDebugBreak() ) + m_shouldDebugBreak = true; + if( getCurrentContext().getRunner()->aborting() || (m_assertionInfo.resultDisposition & ResultDisposition::Normal) ) + m_shouldThrow = true; + } + } + void ResultBuilder::react() { + if( m_shouldThrow ) + throw Catch::TestFailureException(); + } + + bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; } + bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); } + + AssertionResult ResultBuilder::build() const + { + assert( m_data.resultType != ResultWas::Unknown ); + + AssertionResultData data = m_data; + + // Flip bool results if testFalse is set + if( m_exprComponents.testFalse ) { + if( data.resultType == ResultWas::Ok ) + data.resultType = ResultWas::ExpressionFailed; + else if( data.resultType == ResultWas::ExpressionFailed ) + data.resultType = ResultWas::Ok; + } + + data.message = m_stream.oss.str(); + data.reconstructedExpression = reconstructExpression(); + if( m_exprComponents.testFalse ) { + if( m_exprComponents.op == "" ) + data.reconstructedExpression = "!" + data.reconstructedExpression; + else + data.reconstructedExpression = "!(" + data.reconstructedExpression + ")"; + } + return AssertionResult( m_assertionInfo, data ); + } + std::string ResultBuilder::reconstructExpression() const { + if( m_exprComponents.op == "" ) + return m_exprComponents.lhs.empty() ? m_assertionInfo.capturedExpression : m_exprComponents.op + m_exprComponents.lhs; + else if( m_exprComponents.op == "matches" ) + return m_exprComponents.lhs + " " + m_exprComponents.rhs; + else if( m_exprComponents.op != "!" ) { + if( m_exprComponents.lhs.size() + m_exprComponents.rhs.size() < 40 && + m_exprComponents.lhs.find("\n") == std::string::npos && + m_exprComponents.rhs.find("\n") == std::string::npos ) + return m_exprComponents.lhs + " " + m_exprComponents.op + " " + m_exprComponents.rhs; + else + return m_exprComponents.lhs + "\n" + m_exprComponents.op + "\n" + m_exprComponents.rhs; + } + else + return "{can't expand - use " + m_assertionInfo.macroName + "_FALSE( " + m_assertionInfo.capturedExpression.substr(1) + " ) instead of " + m_assertionInfo.macroName + "( " + m_assertionInfo.capturedExpression + " ) for better diagnostics}"; + } + +} // end namespace Catch + +// #included from: catch_tag_alias_registry.hpp +#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED + +// #included from: catch_tag_alias_registry.h +#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED + +#include + +namespace Catch { + + class TagAliasRegistry : public ITagAliasRegistry { + public: + virtual ~TagAliasRegistry(); + virtual Option find( std::string const& alias ) const; + virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const; + void add( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); + static TagAliasRegistry& get(); + + private: + std::map m_registry; + }; + +} // end namespace Catch + +#include +#include + +namespace Catch { + + TagAliasRegistry::~TagAliasRegistry() {} + + Option TagAliasRegistry::find( std::string const& alias ) const { + std::map::const_iterator it = m_registry.find( alias ); + if( it != m_registry.end() ) + return it->second; + else + return Option(); + } + + std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const { + std::string expandedTestSpec = unexpandedTestSpec; + for( std::map::const_iterator it = m_registry.begin(), itEnd = m_registry.end(); + it != itEnd; + ++it ) { + std::size_t pos = expandedTestSpec.find( it->first ); + if( pos != std::string::npos ) { + expandedTestSpec = expandedTestSpec.substr( 0, pos ) + + it->second.tag + + expandedTestSpec.substr( pos + it->first.size() ); + } + } + return expandedTestSpec; + } + + void TagAliasRegistry::add( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) { + + if( !startsWith( alias, "[@" ) || !endsWith( alias, "]" ) ) { + std::ostringstream oss; + oss << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n" << lineInfo; + throw std::domain_error( oss.str().c_str() ); + } + if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) { + std::ostringstream oss; + oss << "error: tag alias, \"" << alias << "\" already registered.\n" + << "\tFirst seen at " << find(alias)->lineInfo << "\n" + << "\tRedefined at " << lineInfo; + throw std::domain_error( oss.str().c_str() ); + } + } + + TagAliasRegistry& TagAliasRegistry::get() { + static TagAliasRegistry instance; + return instance; + + } + + ITagAliasRegistry::~ITagAliasRegistry() {} + ITagAliasRegistry const& ITagAliasRegistry::get() { return TagAliasRegistry::get(); } + + RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) { + try { + TagAliasRegistry::get().add( alias, tag, lineInfo ); + } + catch( std::exception& ex ) { + Colour colourGuard( Colour::Red ); + Catch::cerr() << ex.what() << std::endl; + exit(1); + } + } + +} // end namespace Catch + +// #included from: ../reporters/catch_reporter_multi.hpp +#define TWOBLUECUBES_CATCH_REPORTER_MULTI_HPP_INCLUDED + +namespace Catch { + +class MultipleReporters : public SharedImpl { + typedef std::vector > Reporters; + Reporters m_reporters; + +public: + void add( Ptr const& reporter ) { + m_reporters.push_back( reporter ); + } + +public: // IStreamingReporter + + virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE { + return m_reporters[0]->getPreferences(); + } + + virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->noMatchingTestCases( spec ); + } + + virtual void testRunStarting( TestRunInfo const& testRunInfo ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->testRunStarting( testRunInfo ); + } + + virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->testGroupStarting( groupInfo ); + } + + virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->testCaseStarting( testInfo ); + } + + virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->sectionStarting( sectionInfo ); + } + + virtual void assertionStarting( AssertionInfo const& assertionInfo ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->assertionStarting( assertionInfo ); + } + + // The return value indicates if the messages buffer should be cleared: + virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE { + bool clearBuffer = false; + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + clearBuffer |= (*it)->assertionEnded( assertionStats ); + return clearBuffer; + } + + virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->sectionEnded( sectionStats ); + } + + virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->testCaseEnded( testCaseStats ); + } + + virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->testGroupEnded( testGroupStats ); + } + + virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->testRunEnded( testRunStats ); + } + + virtual void skipTest( TestCaseInfo const& testInfo ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->skipTest( testInfo ); + } +}; + +Ptr addReporter( Ptr const& existingReporter, Ptr const& additionalReporter ) { + Ptr resultingReporter; + + if( existingReporter ) { + MultipleReporters* multi = dynamic_cast( existingReporter.get() ); + if( !multi ) { + multi = new MultipleReporters; + resultingReporter = Ptr( multi ); + if( existingReporter ) + multi->add( existingReporter ); + } + else + resultingReporter = existingReporter; + multi->add( additionalReporter ); + } + else + resultingReporter = additionalReporter; + + return resultingReporter; +} + +} // end namespace Catch + +// #included from: ../reporters/catch_reporter_xml.hpp +#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED + +// #included from: catch_reporter_bases.hpp +#define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED + +#include + +namespace Catch { + + struct StreamingReporterBase : SharedImpl { + + StreamingReporterBase( ReporterConfig const& _config ) + : m_config( _config.fullConfig() ), + stream( _config.stream() ) + { + m_reporterPrefs.shouldRedirectStdOut = false; + } + + virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE { + return m_reporterPrefs; + } + + virtual ~StreamingReporterBase() CATCH_OVERRIDE; + + virtual void noMatchingTestCases( std::string const& ) CATCH_OVERRIDE {} + + virtual void testRunStarting( TestRunInfo const& _testRunInfo ) CATCH_OVERRIDE { + currentTestRunInfo = _testRunInfo; + } + virtual void testGroupStarting( GroupInfo const& _groupInfo ) CATCH_OVERRIDE { + currentGroupInfo = _groupInfo; + } + + virtual void testCaseStarting( TestCaseInfo const& _testInfo ) CATCH_OVERRIDE { + currentTestCaseInfo = _testInfo; + } + virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE { + m_sectionStack.push_back( _sectionInfo ); + } + + virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) CATCH_OVERRIDE { + m_sectionStack.pop_back(); + } + virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) CATCH_OVERRIDE { + currentTestCaseInfo.reset(); + } + virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) CATCH_OVERRIDE { + currentGroupInfo.reset(); + } + virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) CATCH_OVERRIDE { + currentTestCaseInfo.reset(); + currentGroupInfo.reset(); + currentTestRunInfo.reset(); + } + + virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE { + // Don't do anything with this by default. + // It can optionally be overridden in the derived class. + } + + Ptr m_config; + std::ostream& stream; + + LazyStat currentTestRunInfo; + LazyStat currentGroupInfo; + LazyStat currentTestCaseInfo; + + std::vector m_sectionStack; + ReporterPreferences m_reporterPrefs; + }; + + struct CumulativeReporterBase : SharedImpl { + template + struct Node : SharedImpl<> { + explicit Node( T const& _value ) : value( _value ) {} + virtual ~Node() {} + + typedef std::vector > ChildNodes; + T value; + ChildNodes children; + }; + struct SectionNode : SharedImpl<> { + explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {} + virtual ~SectionNode(); + + bool operator == ( SectionNode const& other ) const { + return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo; + } + bool operator == ( Ptr const& other ) const { + return operator==( *other ); + } + + SectionStats stats; + typedef std::vector > ChildSections; + typedef std::vector Assertions; + ChildSections childSections; + Assertions assertions; + std::string stdOut; + std::string stdErr; + }; + + struct BySectionInfo { + BySectionInfo( SectionInfo const& other ) : m_other( other ) {} + BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {} + bool operator() ( Ptr const& node ) const { + return node->stats.sectionInfo.lineInfo == m_other.lineInfo; + } + private: + void operator=( BySectionInfo const& ); + SectionInfo const& m_other; + }; + + typedef Node TestCaseNode; + typedef Node TestGroupNode; + typedef Node TestRunNode; + + CumulativeReporterBase( ReporterConfig const& _config ) + : m_config( _config.fullConfig() ), + stream( _config.stream() ) + { + m_reporterPrefs.shouldRedirectStdOut = false; + } + ~CumulativeReporterBase(); + + virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE { + return m_reporterPrefs; + } + + virtual void testRunStarting( TestRunInfo const& ) CATCH_OVERRIDE {} + virtual void testGroupStarting( GroupInfo const& ) CATCH_OVERRIDE {} + + virtual void testCaseStarting( TestCaseInfo const& ) CATCH_OVERRIDE {} + + virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE { + SectionStats incompleteStats( sectionInfo, Counts(), 0, false ); + Ptr node; + if( m_sectionStack.empty() ) { + if( !m_rootSection ) + m_rootSection = new SectionNode( incompleteStats ); + node = m_rootSection; + } + else { + SectionNode& parentNode = *m_sectionStack.back(); + SectionNode::ChildSections::const_iterator it = + std::find_if( parentNode.childSections.begin(), + parentNode.childSections.end(), + BySectionInfo( sectionInfo ) ); + if( it == parentNode.childSections.end() ) { + node = new SectionNode( incompleteStats ); + parentNode.childSections.push_back( node ); + } + else + node = *it; + } + m_sectionStack.push_back( node ); + m_deepestSection = node; + } + + virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {} + + virtual bool assertionEnded( AssertionStats const& assertionStats ) { + assert( !m_sectionStack.empty() ); + SectionNode& sectionNode = *m_sectionStack.back(); + sectionNode.assertions.push_back( assertionStats ); + return true; + } + virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE { + assert( !m_sectionStack.empty() ); + SectionNode& node = *m_sectionStack.back(); + node.stats = sectionStats; + m_sectionStack.pop_back(); + } + virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE { + Ptr node = new TestCaseNode( testCaseStats ); + assert( m_sectionStack.size() == 0 ); + node->children.push_back( m_rootSection ); + m_testCases.push_back( node ); + m_rootSection.reset(); + + assert( m_deepestSection ); + m_deepestSection->stdOut = testCaseStats.stdOut; + m_deepestSection->stdErr = testCaseStats.stdErr; + } + virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE { + Ptr node = new TestGroupNode( testGroupStats ); + node->children.swap( m_testCases ); + m_testGroups.push_back( node ); + } + virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE { + Ptr node = new TestRunNode( testRunStats ); + node->children.swap( m_testGroups ); + m_testRuns.push_back( node ); + testRunEndedCumulative(); + } + virtual void testRunEndedCumulative() = 0; + + virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE {} + + Ptr m_config; + std::ostream& stream; + std::vector m_assertions; + std::vector > > m_sections; + std::vector > m_testCases; + std::vector > m_testGroups; + + std::vector > m_testRuns; + + Ptr m_rootSection; + Ptr m_deepestSection; + std::vector > m_sectionStack; + ReporterPreferences m_reporterPrefs; + + }; + + template + char const* getLineOfChars() { + static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0}; + if( !*line ) { + memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 ); + line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0; + } + return line; + } + + struct TestEventListenerBase : StreamingReporterBase { + TestEventListenerBase( ReporterConfig const& _config ) + : StreamingReporterBase( _config ) + {} + + virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {} + virtual bool assertionEnded( AssertionStats const& ) CATCH_OVERRIDE { + return false; + } + }; + +} // end namespace Catch + +// #included from: ../internal/catch_reporter_registrars.hpp +#define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED + +namespace Catch { + + template + class LegacyReporterRegistrar { + + class ReporterFactory : public IReporterFactory { + virtual IStreamingReporter* create( ReporterConfig const& config ) const { + return new LegacyReporterAdapter( new T( config ) ); + } + + virtual std::string getDescription() const { + return T::getDescription(); + } + }; + + public: + + LegacyReporterRegistrar( std::string const& name ) { + getMutableRegistryHub().registerReporter( name, new ReporterFactory() ); + } + }; + + template + class ReporterRegistrar { + + class ReporterFactory : public SharedImpl { + + // *** Please Note ***: + // - If you end up here looking at a compiler error because it's trying to register + // your custom reporter class be aware that the native reporter interface has changed + // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via + // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter. + // However please consider updating to the new interface as the old one is now + // deprecated and will probably be removed quite soon! + // Please contact me via github if you have any questions at all about this. + // In fact, ideally, please contact me anyway to let me know you've hit this - as I have + // no idea who is actually using custom reporters at all (possibly no-one!). + // The new interface is designed to minimise exposure to interface changes in the future. + virtual IStreamingReporter* create( ReporterConfig const& config ) const { + return new T( config ); + } + + virtual std::string getDescription() const { + return T::getDescription(); + } + }; + + public: + + ReporterRegistrar( std::string const& name ) { + getMutableRegistryHub().registerReporter( name, new ReporterFactory() ); + } + }; + + template + class ListenerRegistrar { + + class ListenerFactory : public SharedImpl { + + virtual IStreamingReporter* create( ReporterConfig const& config ) const { + return new T( config ); + } + virtual std::string getDescription() const { + return ""; + } + }; + + public: + + ListenerRegistrar() { + getMutableRegistryHub().registerListener( new ListenerFactory() ); + } + }; +} + +#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \ + namespace{ Catch::LegacyReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); } + +#define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \ + namespace{ Catch::ReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); } + +#define INTERNAL_CATCH_REGISTER_LISTENER( listenerType ) \ + namespace{ Catch::ListenerRegistrar catch_internal_RegistrarFor##listenerType; } + +// #included from: ../internal/catch_xmlwriter.hpp +#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED + +#include +#include +#include +#include + +namespace Catch { + + class XmlEncode { + public: + enum ForWhat { ForTextNodes, ForAttributes }; + + XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes ) + : m_str( str ), + m_forWhat( forWhat ) + {} + + void encodeTo( std::ostream& os ) const { + + // Apostrophe escaping not necessary if we always use " to write attributes + // (see: http://www.w3.org/TR/xml/#syntax) + + for( std::size_t i = 0; i < m_str.size(); ++ i ) { + char c = m_str[i]; + switch( c ) { + case '<': os << "<"; break; + case '&': os << "&"; break; + + case '>': + // See: http://www.w3.org/TR/xml/#syntax + if( i > 2 && m_str[i-1] == ']' && m_str[i-2] == ']' ) + os << ">"; + else + os << c; + break; + + case '\"': + if( m_forWhat == ForAttributes ) + os << """; + else + os << c; + break; + + default: + // Escape control chars - based on contribution by @espenalb in PR #465 + if ( ( c < '\x09' ) || ( c > '\x0D' && c < '\x20') || c=='\x7F' ) + os << "&#x" << std::uppercase << std::hex << static_cast( c ); + else + os << c; + } + } + } + + friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) { + xmlEncode.encodeTo( os ); + return os; + } + + private: + std::string m_str; + ForWhat m_forWhat; + }; + + class XmlWriter { + public: + + class ScopedElement { + public: + ScopedElement( XmlWriter* writer ) + : m_writer( writer ) + {} + + ScopedElement( ScopedElement const& other ) + : m_writer( other.m_writer ){ + other.m_writer = CATCH_NULL; + } + + ~ScopedElement() { + if( m_writer ) + m_writer->endElement(); + } + + ScopedElement& writeText( std::string const& text, bool indent = true ) { + m_writer->writeText( text, indent ); + return *this; + } + + template + ScopedElement& writeAttribute( std::string const& name, T const& attribute ) { + m_writer->writeAttribute( name, attribute ); + return *this; + } + + private: + mutable XmlWriter* m_writer; + }; + + XmlWriter() + : m_tagIsOpen( false ), + m_needsNewline( false ), + m_os( &Catch::cout() ) + {} + + XmlWriter( std::ostream& os ) + : m_tagIsOpen( false ), + m_needsNewline( false ), + m_os( &os ) + {} + + ~XmlWriter() { + while( !m_tags.empty() ) + endElement(); + } + + XmlWriter& startElement( std::string const& name ) { + ensureTagClosed(); + newlineIfNecessary(); + stream() << m_indent << "<" << name; + m_tags.push_back( name ); + m_indent += " "; + m_tagIsOpen = true; + return *this; + } + + ScopedElement scopedElement( std::string const& name ) { + ScopedElement scoped( this ); + startElement( name ); + return scoped; + } + + XmlWriter& endElement() { + newlineIfNecessary(); + m_indent = m_indent.substr( 0, m_indent.size()-2 ); + if( m_tagIsOpen ) { + stream() << "/>\n"; + m_tagIsOpen = false; + } + else { + stream() << m_indent << "\n"; + } + m_tags.pop_back(); + return *this; + } + + XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) { + if( !name.empty() && !attribute.empty() ) + stream() << " " << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << "\""; + return *this; + } + + XmlWriter& writeAttribute( std::string const& name, bool attribute ) { + stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\""; + return *this; + } + + template + XmlWriter& writeAttribute( std::string const& name, T const& attribute ) { + std::ostringstream oss; + oss << attribute; + return writeAttribute( name, oss.str() ); + } + + XmlWriter& writeText( std::string const& text, bool indent = true ) { + if( !text.empty() ){ + bool tagWasOpen = m_tagIsOpen; + ensureTagClosed(); + if( tagWasOpen && indent ) + stream() << m_indent; + stream() << XmlEncode( text ); + m_needsNewline = true; + } + return *this; + } + + XmlWriter& writeComment( std::string const& text ) { + ensureTagClosed(); + stream() << m_indent << ""; + m_needsNewline = true; + return *this; + } + + XmlWriter& writeBlankLine() { + ensureTagClosed(); + stream() << "\n"; + return *this; + } + + void setStream( std::ostream& os ) { + m_os = &os; + } + + private: + XmlWriter( XmlWriter const& ); + void operator=( XmlWriter const& ); + + std::ostream& stream() { + return *m_os; + } + + void ensureTagClosed() { + if( m_tagIsOpen ) { + stream() << ">\n"; + m_tagIsOpen = false; + } + } + + void newlineIfNecessary() { + if( m_needsNewline ) { + stream() << "\n"; + m_needsNewline = false; + } + } + + bool m_tagIsOpen; + bool m_needsNewline; + std::vector m_tags; + std::string m_indent; + std::ostream* m_os; + }; + +} +// #included from: catch_reenable_warnings.h + +#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED + +#ifdef __clang__ +# ifdef __ICC // icpc defines the __clang__ macro +# pragma warning(pop) +# else +# pragma clang diagnostic pop +# endif +#elif defined __GNUC__ +# pragma GCC diagnostic pop +#endif + + +namespace Catch { + class XmlReporter : public StreamingReporterBase { + public: + XmlReporter( ReporterConfig const& _config ) + : StreamingReporterBase( _config ), + m_sectionDepth( 0 ) + { + m_reporterPrefs.shouldRedirectStdOut = true; + } + + virtual ~XmlReporter() CATCH_OVERRIDE; + + static std::string getDescription() { + return "Reports test results as an XML document"; + } + + public: // StreamingReporterBase + + virtual void noMatchingTestCases( std::string const& s ) CATCH_OVERRIDE { + StreamingReporterBase::noMatchingTestCases( s ); + } + + virtual void testRunStarting( TestRunInfo const& testInfo ) CATCH_OVERRIDE { + StreamingReporterBase::testRunStarting( testInfo ); + m_xml.setStream( stream ); + m_xml.startElement( "Catch" ); + if( !m_config->name().empty() ) + m_xml.writeAttribute( "name", m_config->name() ); + } + + virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE { + StreamingReporterBase::testGroupStarting( groupInfo ); + m_xml.startElement( "Group" ) + .writeAttribute( "name", groupInfo.name ); + } + + virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE { + StreamingReporterBase::testCaseStarting(testInfo); + m_xml.startElement( "TestCase" ).writeAttribute( "name", trim( testInfo.name ) ); + + if ( m_config->showDurations() == ShowDurations::Always ) + m_testCaseTimer.start(); + } + + virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE { + StreamingReporterBase::sectionStarting( sectionInfo ); + if( m_sectionDepth++ > 0 ) { + m_xml.startElement( "Section" ) + .writeAttribute( "name", trim( sectionInfo.name ) ) + .writeAttribute( "description", sectionInfo.description ); + } + } + + virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE { } + + virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE { + const AssertionResult& assertionResult = assertionStats.assertionResult; + + // Print any info messages in tags. + if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) { + for( std::vector::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end(); + it != itEnd; + ++it ) { + if( it->type == ResultWas::Info ) { + m_xml.scopedElement( "Info" ) + .writeText( it->message ); + } else if ( it->type == ResultWas::Warning ) { + m_xml.scopedElement( "Warning" ) + .writeText( it->message ); + } + } + } + + // Drop out if result was successful but we're not printing them. + if( !m_config->includeSuccessfulResults() && isOk(assertionResult.getResultType()) ) + return true; + + // Print the expression if there is one. + if( assertionResult.hasExpression() ) { + m_xml.startElement( "Expression" ) + .writeAttribute( "success", assertionResult.succeeded() ) + .writeAttribute( "type", assertionResult.getTestMacroName() ) + .writeAttribute( "filename", assertionResult.getSourceInfo().file ) + .writeAttribute( "line", assertionResult.getSourceInfo().line ); + + m_xml.scopedElement( "Original" ) + .writeText( assertionResult.getExpression() ); + m_xml.scopedElement( "Expanded" ) + .writeText( assertionResult.getExpandedExpression() ); + } + + // And... Print a result applicable to each result type. + switch( assertionResult.getResultType() ) { + case ResultWas::ThrewException: + m_xml.scopedElement( "Exception" ) + .writeAttribute( "filename", assertionResult.getSourceInfo().file ) + .writeAttribute( "line", assertionResult.getSourceInfo().line ) + .writeText( assertionResult.getMessage() ); + break; + case ResultWas::FatalErrorCondition: + m_xml.scopedElement( "Fatal Error Condition" ) + .writeAttribute( "filename", assertionResult.getSourceInfo().file ) + .writeAttribute( "line", assertionResult.getSourceInfo().line ) + .writeText( assertionResult.getMessage() ); + break; + case ResultWas::Info: + m_xml.scopedElement( "Info" ) + .writeText( assertionResult.getMessage() ); + break; + case ResultWas::Warning: + // Warning will already have been written + break; + case ResultWas::ExplicitFailure: + m_xml.scopedElement( "Failure" ) + .writeText( assertionResult.getMessage() ); + break; + default: + break; + } + + if( assertionResult.hasExpression() ) + m_xml.endElement(); + + return true; + } + + virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE { + StreamingReporterBase::sectionEnded( sectionStats ); + if( --m_sectionDepth > 0 ) { + XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" ); + e.writeAttribute( "successes", sectionStats.assertions.passed ); + e.writeAttribute( "failures", sectionStats.assertions.failed ); + e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk ); + + if ( m_config->showDurations() == ShowDurations::Always ) + e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds ); + + m_xml.endElement(); + } + } + + virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE { + StreamingReporterBase::testCaseEnded( testCaseStats ); + XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" ); + e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() ); + + if ( m_config->showDurations() == ShowDurations::Always ) + e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() ); + + m_xml.endElement(); + } + + virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE { + StreamingReporterBase::testGroupEnded( testGroupStats ); + // TODO: Check testGroupStats.aborting and act accordingly. + m_xml.scopedElement( "OverallResults" ) + .writeAttribute( "successes", testGroupStats.totals.assertions.passed ) + .writeAttribute( "failures", testGroupStats.totals.assertions.failed ) + .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk ); + m_xml.endElement(); + } + + virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE { + StreamingReporterBase::testRunEnded( testRunStats ); + m_xml.scopedElement( "OverallResults" ) + .writeAttribute( "successes", testRunStats.totals.assertions.passed ) + .writeAttribute( "failures", testRunStats.totals.assertions.failed ) + .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk ); + m_xml.endElement(); + } + + private: + Timer m_testCaseTimer; + XmlWriter m_xml; + int m_sectionDepth; + }; + + INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter ) + +} // end namespace Catch + +// #included from: ../reporters/catch_reporter_junit.hpp +#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED + +#include + +namespace Catch { + + class JunitReporter : public CumulativeReporterBase { + public: + JunitReporter( ReporterConfig const& _config ) + : CumulativeReporterBase( _config ), + xml( _config.stream() ) + { + m_reporterPrefs.shouldRedirectStdOut = true; + } + + virtual ~JunitReporter() CATCH_OVERRIDE; + + static std::string getDescription() { + return "Reports test results in an XML format that looks like Ant's junitreport target"; + } + + virtual void noMatchingTestCases( std::string const& /*spec*/ ) CATCH_OVERRIDE {} + + virtual void testRunStarting( TestRunInfo const& runInfo ) CATCH_OVERRIDE { + CumulativeReporterBase::testRunStarting( runInfo ); + xml.startElement( "testsuites" ); + } + + virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE { + suiteTimer.start(); + stdOutForSuite.str(""); + stdErrForSuite.str(""); + unexpectedExceptions = 0; + CumulativeReporterBase::testGroupStarting( groupInfo ); + } + + virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE { + if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException ) + unexpectedExceptions++; + return CumulativeReporterBase::assertionEnded( assertionStats ); + } + + virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE { + stdOutForSuite << testCaseStats.stdOut; + stdErrForSuite << testCaseStats.stdErr; + CumulativeReporterBase::testCaseEnded( testCaseStats ); + } + + virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE { + double suiteTime = suiteTimer.getElapsedSeconds(); + CumulativeReporterBase::testGroupEnded( testGroupStats ); + writeGroup( *m_testGroups.back(), suiteTime ); + } + + virtual void testRunEndedCumulative() CATCH_OVERRIDE { + xml.endElement(); + } + + void writeGroup( TestGroupNode const& groupNode, double suiteTime ) { + XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" ); + TestGroupStats const& stats = groupNode.value; + xml.writeAttribute( "name", stats.groupInfo.name ); + xml.writeAttribute( "errors", unexpectedExceptions ); + xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions ); + xml.writeAttribute( "tests", stats.totals.assertions.total() ); + xml.writeAttribute( "hostname", "tbd" ); // !TBD + if( m_config->showDurations() == ShowDurations::Never ) + xml.writeAttribute( "time", "" ); + else + xml.writeAttribute( "time", suiteTime ); + xml.writeAttribute( "timestamp", "tbd" ); // !TBD + + // Write test cases + for( TestGroupNode::ChildNodes::const_iterator + it = groupNode.children.begin(), itEnd = groupNode.children.end(); + it != itEnd; + ++it ) + writeTestCase( **it ); + + xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false ); + xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false ); + } + + void writeTestCase( TestCaseNode const& testCaseNode ) { + TestCaseStats const& stats = testCaseNode.value; + + // All test cases have exactly one section - which represents the + // test case itself. That section may have 0-n nested sections + assert( testCaseNode.children.size() == 1 ); + SectionNode const& rootSection = *testCaseNode.children.front(); + + std::string className = stats.testInfo.className; + + if( className.empty() ) { + if( rootSection.childSections.empty() ) + className = "global"; + } + writeSection( className, "", rootSection ); + } + + void writeSection( std::string const& className, + std::string const& rootName, + SectionNode const& sectionNode ) { + std::string name = trim( sectionNode.stats.sectionInfo.name ); + if( !rootName.empty() ) + name = rootName + "/" + name; + + if( !sectionNode.assertions.empty() || + !sectionNode.stdOut.empty() || + !sectionNode.stdErr.empty() ) { + XmlWriter::ScopedElement e = xml.scopedElement( "testcase" ); + if( className.empty() ) { + xml.writeAttribute( "classname", name ); + xml.writeAttribute( "name", "root" ); + } + else { + xml.writeAttribute( "classname", className ); + xml.writeAttribute( "name", name ); + } + xml.writeAttribute( "time", Catch::toString( sectionNode.stats.durationInSeconds ) ); + + writeAssertions( sectionNode ); + + if( !sectionNode.stdOut.empty() ) + xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false ); + if( !sectionNode.stdErr.empty() ) + xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false ); + } + for( SectionNode::ChildSections::const_iterator + it = sectionNode.childSections.begin(), + itEnd = sectionNode.childSections.end(); + it != itEnd; + ++it ) + if( className.empty() ) + writeSection( name, "", **it ); + else + writeSection( className, name, **it ); + } + + void writeAssertions( SectionNode const& sectionNode ) { + for( SectionNode::Assertions::const_iterator + it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end(); + it != itEnd; + ++it ) + writeAssertion( *it ); + } + void writeAssertion( AssertionStats const& stats ) { + AssertionResult const& result = stats.assertionResult; + if( !result.isOk() ) { + std::string elementName; + switch( result.getResultType() ) { + case ResultWas::ThrewException: + case ResultWas::FatalErrorCondition: + elementName = "error"; + break; + case ResultWas::ExplicitFailure: + elementName = "failure"; + break; + case ResultWas::ExpressionFailed: + elementName = "failure"; + break; + case ResultWas::DidntThrowException: + elementName = "failure"; + break; + + // We should never see these here: + case ResultWas::Info: + case ResultWas::Warning: + case ResultWas::Ok: + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + elementName = "internalError"; + break; + } + + XmlWriter::ScopedElement e = xml.scopedElement( elementName ); + + xml.writeAttribute( "message", result.getExpandedExpression() ); + xml.writeAttribute( "type", result.getTestMacroName() ); + + std::ostringstream oss; + if( !result.getMessage().empty() ) + oss << result.getMessage() << "\n"; + for( std::vector::const_iterator + it = stats.infoMessages.begin(), + itEnd = stats.infoMessages.end(); + it != itEnd; + ++it ) + if( it->type == ResultWas::Info ) + oss << it->message << "\n"; + + oss << "at " << result.getSourceInfo(); + xml.writeText( oss.str(), false ); + } + } + + XmlWriter xml; + Timer suiteTimer; + std::ostringstream stdOutForSuite; + std::ostringstream stdErrForSuite; + unsigned int unexpectedExceptions; + }; + + INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter ) + +} // end namespace Catch + +// #included from: ../reporters/catch_reporter_console.hpp +#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED + +namespace Catch { + + struct ConsoleReporter : StreamingReporterBase { + ConsoleReporter( ReporterConfig const& _config ) + : StreamingReporterBase( _config ), + m_headerPrinted( false ) + {} + + virtual ~ConsoleReporter() CATCH_OVERRIDE; + static std::string getDescription() { + return "Reports test results as plain lines of text"; + } + + virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE { + stream << "No test cases matched '" << spec << "'" << std::endl; + } + + virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE { + } + + virtual bool assertionEnded( AssertionStats const& _assertionStats ) CATCH_OVERRIDE { + AssertionResult const& result = _assertionStats.assertionResult; + + bool printInfoMessages = true; + + // Drop out if result was successful and we're not printing those + if( !m_config->includeSuccessfulResults() && result.isOk() ) { + if( result.getResultType() != ResultWas::Warning ) + return false; + printInfoMessages = false; + } + + lazyPrint(); + + AssertionPrinter printer( stream, _assertionStats, printInfoMessages ); + printer.print(); + stream << std::endl; + return true; + } + + virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE { + m_headerPrinted = false; + StreamingReporterBase::sectionStarting( _sectionInfo ); + } + virtual void sectionEnded( SectionStats const& _sectionStats ) CATCH_OVERRIDE { + if( _sectionStats.missingAssertions ) { + lazyPrint(); + Colour colour( Colour::ResultError ); + if( m_sectionStack.size() > 1 ) + stream << "\nNo assertions in section"; + else + stream << "\nNo assertions in test case"; + stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl; + } + if( m_headerPrinted ) { + if( m_config->showDurations() == ShowDurations::Always ) + stream << "Completed in " << _sectionStats.durationInSeconds << "s" << std::endl; + m_headerPrinted = false; + } + else { + if( m_config->showDurations() == ShowDurations::Always ) + stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << std::endl; + } + StreamingReporterBase::sectionEnded( _sectionStats ); + } + + virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) CATCH_OVERRIDE { + StreamingReporterBase::testCaseEnded( _testCaseStats ); + m_headerPrinted = false; + } + virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) CATCH_OVERRIDE { + if( currentGroupInfo.used ) { + printSummaryDivider(); + stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n"; + printTotals( _testGroupStats.totals ); + stream << "\n" << std::endl; + } + StreamingReporterBase::testGroupEnded( _testGroupStats ); + } + virtual void testRunEnded( TestRunStats const& _testRunStats ) CATCH_OVERRIDE { + printTotalsDivider( _testRunStats.totals ); + printTotals( _testRunStats.totals ); + stream << std::endl; + StreamingReporterBase::testRunEnded( _testRunStats ); + } + + private: + + class AssertionPrinter { + void operator= ( AssertionPrinter const& ); + public: + AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages ) + : stream( _stream ), + stats( _stats ), + result( _stats.assertionResult ), + colour( Colour::None ), + message( result.getMessage() ), + messages( _stats.infoMessages ), + printInfoMessages( _printInfoMessages ) + { + switch( result.getResultType() ) { + case ResultWas::Ok: + colour = Colour::Success; + passOrFail = "PASSED"; + //if( result.hasMessage() ) + if( _stats.infoMessages.size() == 1 ) + messageLabel = "with message"; + if( _stats.infoMessages.size() > 1 ) + messageLabel = "with messages"; + break; + case ResultWas::ExpressionFailed: + if( result.isOk() ) { + colour = Colour::Success; + passOrFail = "FAILED - but was ok"; + } + else { + colour = Colour::Error; + passOrFail = "FAILED"; + } + if( _stats.infoMessages.size() == 1 ) + messageLabel = "with message"; + if( _stats.infoMessages.size() > 1 ) + messageLabel = "with messages"; + break; + case ResultWas::ThrewException: + colour = Colour::Error; + passOrFail = "FAILED"; + messageLabel = "due to unexpected exception with message"; + break; + case ResultWas::FatalErrorCondition: + colour = Colour::Error; + passOrFail = "FAILED"; + messageLabel = "due to a fatal error condition"; + break; + case ResultWas::DidntThrowException: + colour = Colour::Error; + passOrFail = "FAILED"; + messageLabel = "because no exception was thrown where one was expected"; + break; + case ResultWas::Info: + messageLabel = "info"; + break; + case ResultWas::Warning: + messageLabel = "warning"; + break; + case ResultWas::ExplicitFailure: + passOrFail = "FAILED"; + colour = Colour::Error; + if( _stats.infoMessages.size() == 1 ) + messageLabel = "explicitly with message"; + if( _stats.infoMessages.size() > 1 ) + messageLabel = "explicitly with messages"; + break; + // These cases are here to prevent compiler warnings + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + passOrFail = "** internal error **"; + colour = Colour::Error; + break; + } + } + + void print() const { + printSourceInfo(); + if( stats.totals.assertions.total() > 0 ) { + if( result.isOk() ) + stream << "\n"; + printResultType(); + printOriginalExpression(); + printReconstructedExpression(); + } + else { + stream << "\n"; + } + printMessage(); + } + + private: + void printResultType() const { + if( !passOrFail.empty() ) { + Colour colourGuard( colour ); + stream << passOrFail << ":\n"; + } + } + void printOriginalExpression() const { + if( result.hasExpression() ) { + Colour colourGuard( Colour::OriginalExpression ); + stream << " "; + stream << result.getExpressionInMacro(); + stream << "\n"; + } + } + void printReconstructedExpression() const { + if( result.hasExpandedExpression() ) { + stream << "with expansion:\n"; + Colour colourGuard( Colour::ReconstructedExpression ); + stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n"; + } + } + void printMessage() const { + if( !messageLabel.empty() ) + stream << messageLabel << ":" << "\n"; + for( std::vector::const_iterator it = messages.begin(), itEnd = messages.end(); + it != itEnd; + ++it ) { + // If this assertion is a warning ignore any INFO messages + if( printInfoMessages || it->type != ResultWas::Info ) + stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n"; + } + } + void printSourceInfo() const { + Colour colourGuard( Colour::FileName ); + stream << result.getSourceInfo() << ": "; + } + + std::ostream& stream; + AssertionStats const& stats; + AssertionResult const& result; + Colour::Code colour; + std::string passOrFail; + std::string messageLabel; + std::string message; + std::vector messages; + bool printInfoMessages; + }; + + void lazyPrint() { + + if( !currentTestRunInfo.used ) + lazyPrintRunInfo(); + if( !currentGroupInfo.used ) + lazyPrintGroupInfo(); + + if( !m_headerPrinted ) { + printTestCaseAndSectionHeader(); + m_headerPrinted = true; + } + } + void lazyPrintRunInfo() { + stream << "\n" << getLineOfChars<'~'>() << "\n"; + Colour colour( Colour::SecondaryText ); + stream << currentTestRunInfo->name + << " is a Catch v" << libraryVersion << " host application.\n" + << "Run with -? for options\n\n"; + + if( m_config->rngSeed() != 0 ) + stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n"; + + currentTestRunInfo.used = true; + } + void lazyPrintGroupInfo() { + if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) { + printClosedHeader( "Group: " + currentGroupInfo->name ); + currentGroupInfo.used = true; + } + } + void printTestCaseAndSectionHeader() { + assert( !m_sectionStack.empty() ); + printOpenHeader( currentTestCaseInfo->name ); + + if( m_sectionStack.size() > 1 ) { + Colour colourGuard( Colour::Headers ); + + std::vector::const_iterator + it = m_sectionStack.begin()+1, // Skip first section (test case) + itEnd = m_sectionStack.end(); + for( ; it != itEnd; ++it ) + printHeaderString( it->name, 2 ); + } + + SourceLineInfo lineInfo = m_sectionStack.front().lineInfo; + + if( !lineInfo.empty() ){ + stream << getLineOfChars<'-'>() << "\n"; + Colour colourGuard( Colour::FileName ); + stream << lineInfo << "\n"; + } + stream << getLineOfChars<'.'>() << "\n" << std::endl; + } + + void printClosedHeader( std::string const& _name ) { + printOpenHeader( _name ); + stream << getLineOfChars<'.'>() << "\n"; + } + void printOpenHeader( std::string const& _name ) { + stream << getLineOfChars<'-'>() << "\n"; + { + Colour colourGuard( Colour::Headers ); + printHeaderString( _name ); + } + } + + // if string has a : in first line will set indent to follow it on + // subsequent lines + void printHeaderString( std::string const& _string, std::size_t indent = 0 ) { + std::size_t i = _string.find( ": " ); + if( i != std::string::npos ) + i+=2; + else + i = 0; + stream << Text( _string, TextAttributes() + .setIndent( indent+i) + .setInitialIndent( indent ) ) << "\n"; + } + + struct SummaryColumn { + + SummaryColumn( std::string const& _label, Colour::Code _colour ) + : label( _label ), + colour( _colour ) + {} + SummaryColumn addRow( std::size_t count ) { + std::ostringstream oss; + oss << count; + std::string row = oss.str(); + for( std::vector::iterator it = rows.begin(); it != rows.end(); ++it ) { + while( it->size() < row.size() ) + *it = " " + *it; + while( it->size() > row.size() ) + row = " " + row; + } + rows.push_back( row ); + return *this; + } + + std::string label; + Colour::Code colour; + std::vector rows; + + }; + + void printTotals( Totals const& totals ) { + if( totals.testCases.total() == 0 ) { + stream << Colour( Colour::Warning ) << "No tests ran\n"; + } + else if( totals.assertions.total() > 0 && totals.testCases.allPassed() ) { + stream << Colour( Colour::ResultSuccess ) << "All tests passed"; + stream << " (" + << pluralise( totals.assertions.passed, "assertion" ) << " in " + << pluralise( totals.testCases.passed, "test case" ) << ")" + << "\n"; + } + else { + + std::vector columns; + columns.push_back( SummaryColumn( "", Colour::None ) + .addRow( totals.testCases.total() ) + .addRow( totals.assertions.total() ) ); + columns.push_back( SummaryColumn( "passed", Colour::Success ) + .addRow( totals.testCases.passed ) + .addRow( totals.assertions.passed ) ); + columns.push_back( SummaryColumn( "failed", Colour::ResultError ) + .addRow( totals.testCases.failed ) + .addRow( totals.assertions.failed ) ); + columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure ) + .addRow( totals.testCases.failedButOk ) + .addRow( totals.assertions.failedButOk ) ); + + printSummaryRow( "test cases", columns, 0 ); + printSummaryRow( "assertions", columns, 1 ); + } + } + void printSummaryRow( std::string const& label, std::vector const& cols, std::size_t row ) { + for( std::vector::const_iterator it = cols.begin(); it != cols.end(); ++it ) { + std::string value = it->rows[row]; + if( it->label.empty() ) { + stream << label << ": "; + if( value != "0" ) + stream << value; + else + stream << Colour( Colour::Warning ) << "- none -"; + } + else if( value != "0" ) { + stream << Colour( Colour::LightGrey ) << " | "; + stream << Colour( it->colour ) + << value << " " << it->label; + } + } + stream << "\n"; + } + + static std::size_t makeRatio( std::size_t number, std::size_t total ) { + std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0; + return ( ratio == 0 && number > 0 ) ? 1 : ratio; + } + static std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) { + if( i > j && i > k ) + return i; + else if( j > k ) + return j; + else + return k; + } + + void printTotalsDivider( Totals const& totals ) { + if( totals.testCases.total() > 0 ) { + std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() ); + std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() ); + std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() ); + while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 ) + findMax( failedRatio, failedButOkRatio, passedRatio )++; + while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 ) + findMax( failedRatio, failedButOkRatio, passedRatio )--; + + stream << Colour( Colour::Error ) << std::string( failedRatio, '=' ); + stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' ); + if( totals.testCases.allPassed() ) + stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' ); + else + stream << Colour( Colour::Success ) << std::string( passedRatio, '=' ); + } + else { + stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' ); + } + stream << "\n"; + } + void printSummaryDivider() { + stream << getLineOfChars<'-'>() << "\n"; + } + + private: + bool m_headerPrinted; + }; + + INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter ) + +} // end namespace Catch + +// #included from: ../reporters/catch_reporter_compact.hpp +#define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED + +namespace Catch { + + struct CompactReporter : StreamingReporterBase { + + CompactReporter( ReporterConfig const& _config ) + : StreamingReporterBase( _config ) + {} + + virtual ~CompactReporter(); + + static std::string getDescription() { + return "Reports test results on a single line, suitable for IDEs"; + } + + virtual ReporterPreferences getPreferences() const { + ReporterPreferences prefs; + prefs.shouldRedirectStdOut = false; + return prefs; + } + + virtual void noMatchingTestCases( std::string const& spec ) { + stream << "No test cases matched '" << spec << "'" << std::endl; + } + + virtual void assertionStarting( AssertionInfo const& ) { + } + + virtual bool assertionEnded( AssertionStats const& _assertionStats ) { + AssertionResult const& result = _assertionStats.assertionResult; + + bool printInfoMessages = true; + + // Drop out if result was successful and we're not printing those + if( !m_config->includeSuccessfulResults() && result.isOk() ) { + if( result.getResultType() != ResultWas::Warning ) + return false; + printInfoMessages = false; + } + + AssertionPrinter printer( stream, _assertionStats, printInfoMessages ); + printer.print(); + + stream << std::endl; + return true; + } + + virtual void testRunEnded( TestRunStats const& _testRunStats ) { + printTotals( _testRunStats.totals ); + stream << "\n" << std::endl; + StreamingReporterBase::testRunEnded( _testRunStats ); + } + + private: + class AssertionPrinter { + void operator= ( AssertionPrinter const& ); + public: + AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages ) + : stream( _stream ) + , stats( _stats ) + , result( _stats.assertionResult ) + , messages( _stats.infoMessages ) + , itMessage( _stats.infoMessages.begin() ) + , printInfoMessages( _printInfoMessages ) + {} + + void print() { + printSourceInfo(); + + itMessage = messages.begin(); + + switch( result.getResultType() ) { + case ResultWas::Ok: + printResultType( Colour::ResultSuccess, passedString() ); + printOriginalExpression(); + printReconstructedExpression(); + if ( ! result.hasExpression() ) + printRemainingMessages( Colour::None ); + else + printRemainingMessages(); + break; + case ResultWas::ExpressionFailed: + if( result.isOk() ) + printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) ); + else + printResultType( Colour::Error, failedString() ); + printOriginalExpression(); + printReconstructedExpression(); + printRemainingMessages(); + break; + case ResultWas::ThrewException: + printResultType( Colour::Error, failedString() ); + printIssue( "unexpected exception with message:" ); + printMessage(); + printExpressionWas(); + printRemainingMessages(); + break; + case ResultWas::FatalErrorCondition: + printResultType( Colour::Error, failedString() ); + printIssue( "fatal error condition with message:" ); + printMessage(); + printExpressionWas(); + printRemainingMessages(); + break; + case ResultWas::DidntThrowException: + printResultType( Colour::Error, failedString() ); + printIssue( "expected exception, got none" ); + printExpressionWas(); + printRemainingMessages(); + break; + case ResultWas::Info: + printResultType( Colour::None, "info" ); + printMessage(); + printRemainingMessages(); + break; + case ResultWas::Warning: + printResultType( Colour::None, "warning" ); + printMessage(); + printRemainingMessages(); + break; + case ResultWas::ExplicitFailure: + printResultType( Colour::Error, failedString() ); + printIssue( "explicitly" ); + printRemainingMessages( Colour::None ); + break; + // These cases are here to prevent compiler warnings + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + printResultType( Colour::Error, "** internal error **" ); + break; + } + } + + private: + // Colour::LightGrey + + static Colour::Code dimColour() { return Colour::FileName; } + +#ifdef CATCH_PLATFORM_MAC + static const char* failedString() { return "FAILED"; } + static const char* passedString() { return "PASSED"; } +#else + static const char* failedString() { return "failed"; } + static const char* passedString() { return "passed"; } +#endif + + void printSourceInfo() const { + Colour colourGuard( Colour::FileName ); + stream << result.getSourceInfo() << ":"; + } + + void printResultType( Colour::Code colour, std::string passOrFail ) const { + if( !passOrFail.empty() ) { + { + Colour colourGuard( colour ); + stream << " " << passOrFail; + } + stream << ":"; + } + } + + void printIssue( std::string issue ) const { + stream << " " << issue; + } + + void printExpressionWas() { + if( result.hasExpression() ) { + stream << ";"; + { + Colour colour( dimColour() ); + stream << " expression was:"; + } + printOriginalExpression(); + } + } + + void printOriginalExpression() const { + if( result.hasExpression() ) { + stream << " " << result.getExpression(); + } + } + + void printReconstructedExpression() const { + if( result.hasExpandedExpression() ) { + { + Colour colour( dimColour() ); + stream << " for: "; + } + stream << result.getExpandedExpression(); + } + } + + void printMessage() { + if ( itMessage != messages.end() ) { + stream << " '" << itMessage->message << "'"; + ++itMessage; + } + } + + void printRemainingMessages( Colour::Code colour = dimColour() ) { + if ( itMessage == messages.end() ) + return; + + // using messages.end() directly yields compilation error: + std::vector::const_iterator itEnd = messages.end(); + const std::size_t N = static_cast( std::distance( itMessage, itEnd ) ); + + { + Colour colourGuard( colour ); + stream << " with " << pluralise( N, "message" ) << ":"; + } + + for(; itMessage != itEnd; ) { + // If this assertion is a warning ignore any INFO messages + if( printInfoMessages || itMessage->type != ResultWas::Info ) { + stream << " '" << itMessage->message << "'"; + if ( ++itMessage != itEnd ) { + Colour colourGuard( dimColour() ); + stream << " and"; + } + } + } + } + + private: + std::ostream& stream; + AssertionStats const& stats; + AssertionResult const& result; + std::vector messages; + std::vector::const_iterator itMessage; + bool printInfoMessages; + }; + + // Colour, message variants: + // - white: No tests ran. + // - red: Failed [both/all] N test cases, failed [both/all] M assertions. + // - white: Passed [both/all] N test cases (no assertions). + // - red: Failed N tests cases, failed M assertions. + // - green: Passed [both/all] N tests cases with M assertions. + + std::string bothOrAll( std::size_t count ) const { + return count == 1 ? "" : count == 2 ? "both " : "all " ; + } + + void printTotals( const Totals& totals ) const { + if( totals.testCases.total() == 0 ) { + stream << "No tests ran."; + } + else if( totals.testCases.failed == totals.testCases.total() ) { + Colour colour( Colour::ResultError ); + const std::string qualify_assertions_failed = + totals.assertions.failed == totals.assertions.total() ? + bothOrAll( totals.assertions.failed ) : ""; + stream << + "Failed " << bothOrAll( totals.testCases.failed ) + << pluralise( totals.testCases.failed, "test case" ) << ", " + "failed " << qualify_assertions_failed << + pluralise( totals.assertions.failed, "assertion" ) << "."; + } + else if( totals.assertions.total() == 0 ) { + stream << + "Passed " << bothOrAll( totals.testCases.total() ) + << pluralise( totals.testCases.total(), "test case" ) + << " (no assertions)."; + } + else if( totals.assertions.failed ) { + Colour colour( Colour::ResultError ); + stream << + "Failed " << pluralise( totals.testCases.failed, "test case" ) << ", " + "failed " << pluralise( totals.assertions.failed, "assertion" ) << "."; + } + else { + Colour colour( Colour::ResultSuccess ); + stream << + "Passed " << bothOrAll( totals.testCases.passed ) + << pluralise( totals.testCases.passed, "test case" ) << + " with " << pluralise( totals.assertions.passed, "assertion" ) << "."; + } + } + }; + + INTERNAL_CATCH_REGISTER_REPORTER( "compact", CompactReporter ) + +} // end namespace Catch + +namespace Catch { + // These are all here to avoid warnings about not having any out of line + // virtual methods + NonCopyable::~NonCopyable() {} + IShared::~IShared() {} + IStream::~IStream() CATCH_NOEXCEPT {} + FileStream::~FileStream() CATCH_NOEXCEPT {} + CoutStream::~CoutStream() CATCH_NOEXCEPT {} + DebugOutStream::~DebugOutStream() CATCH_NOEXCEPT {} + StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {} + IContext::~IContext() {} + IResultCapture::~IResultCapture() {} + ITestCase::~ITestCase() {} + ITestCaseRegistry::~ITestCaseRegistry() {} + IRegistryHub::~IRegistryHub() {} + IMutableRegistryHub::~IMutableRegistryHub() {} + IExceptionTranslator::~IExceptionTranslator() {} + IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {} + IReporter::~IReporter() {} + IReporterFactory::~IReporterFactory() {} + IReporterRegistry::~IReporterRegistry() {} + IStreamingReporter::~IStreamingReporter() {} + AssertionStats::~AssertionStats() {} + SectionStats::~SectionStats() {} + TestCaseStats::~TestCaseStats() {} + TestGroupStats::~TestGroupStats() {} + TestRunStats::~TestRunStats() {} + CumulativeReporterBase::SectionNode::~SectionNode() {} + CumulativeReporterBase::~CumulativeReporterBase() {} + + StreamingReporterBase::~StreamingReporterBase() {} + ConsoleReporter::~ConsoleReporter() {} + CompactReporter::~CompactReporter() {} + IRunner::~IRunner() {} + IMutableContext::~IMutableContext() {} + IConfig::~IConfig() {} + XmlReporter::~XmlReporter() {} + JunitReporter::~JunitReporter() {} + TestRegistry::~TestRegistry() {} + FreeFunctionTestCase::~FreeFunctionTestCase() {} + IGeneratorInfo::~IGeneratorInfo() {} + IGeneratorsForTest::~IGeneratorsForTest() {} + WildcardPattern::~WildcardPattern() {} + TestSpec::Pattern::~Pattern() {} + TestSpec::NamePattern::~NamePattern() {} + TestSpec::TagPattern::~TagPattern() {} + TestSpec::ExcludedPattern::~ExcludedPattern() {} + + Matchers::Impl::StdString::Equals::~Equals() {} + Matchers::Impl::StdString::Contains::~Contains() {} + Matchers::Impl::StdString::StartsWith::~StartsWith() {} + Matchers::Impl::StdString::EndsWith::~EndsWith() {} + + void Config::dummy() {} + + namespace TestCaseTracking { + ITracker::~ITracker() {} + TrackerBase::~TrackerBase() {} + SectionTracker::~SectionTracker() {} + IndexTracker::~IndexTracker() {} + } +} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#endif + +#ifdef CATCH_CONFIG_MAIN +// #included from: internal/catch_default_main.hpp +#define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED + +#ifndef __OBJC__ + +// Standard C/C++ main entry point +int main (int argc, char * argv[]) { + return Catch::Session().run( argc, argv ); +} + +#else // __OBJC__ + +// Objective-C entry point +int main (int argc, char * const argv[]) { +#if !CATCH_ARC_ENABLED + NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; +#endif + + Catch::registerTestMethods(); + int result = Catch::Session().run( argc, (char* const*)argv ); + +#if !CATCH_ARC_ENABLED + [pool drain]; +#endif + + return result; +} + +#endif // __OBJC__ + +#endif + +#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED +# undef CLARA_CONFIG_MAIN +#endif + +////// + +// If this config identifier is defined then all CATCH macros are prefixed with CATCH_ +#ifdef CATCH_CONFIG_PREFIX_ALL + +#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE" ) +#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "CATCH_REQUIRE_FALSE" ) + +#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "", "CATCH_REQUIRE_THROWS" ) +#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS_AS" ) +#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, matcher, "CATCH_REQUIRE_THROWS_WITH" ) +#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_NOTHROW" ) + +#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK" ) +#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CATCH_CHECK_FALSE" ) +#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_IF" ) +#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_ELSE" ) +#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CATCH_CHECK_NOFAIL" ) + +#define CATCH_CHECK_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS" ) +#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS_AS" ) +#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, matcher, "CATCH_CHECK_THROWS_WITH" ) +#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_NOTHROW" ) + +#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THAT" ) +#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THAT" ) + +#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" ) +#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "CATCH_WARN", msg ) +#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" ) +#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" ) +#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" ) + +#ifdef CATCH_CONFIG_VARIADIC_MACROS + #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) + #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) + #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) + #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ ) + #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) + #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", __VA_ARGS__ ) + #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", __VA_ARGS__ ) +#else + #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description ) + #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description ) + #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description ) + #define CATCH_REGISTER_TEST_CASE( function, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( function, name, description ) + #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description ) + #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", msg ) + #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", msg ) +#endif +#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" ) + +#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) +#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) + +#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr ) + +// "BDD-style" convenience wrappers +#ifdef CATCH_CONFIG_VARIADIC_MACROS +#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ ) +#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ ) +#else +#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags ) +#define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags ) +#endif +#define CATCH_GIVEN( desc ) CATCH_SECTION( std::string( "Given: ") + desc, "" ) +#define CATCH_WHEN( desc ) CATCH_SECTION( std::string( " When: ") + desc, "" ) +#define CATCH_AND_WHEN( desc ) CATCH_SECTION( std::string( " And: ") + desc, "" ) +#define CATCH_THEN( desc ) CATCH_SECTION( std::string( " Then: ") + desc, "" ) +#define CATCH_AND_THEN( desc ) CATCH_SECTION( std::string( " And: ") + desc, "" ) + +// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required +#else + +#define REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "REQUIRE" ) +#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "REQUIRE_FALSE" ) + +#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "", "REQUIRE_THROWS" ) +#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "REQUIRE_THROWS_AS" ) +#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, matcher, "REQUIRE_THROWS_WITH" ) +#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "REQUIRE_NOTHROW" ) + +#define CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK" ) +#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CHECK_FALSE" ) +#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_IF" ) +#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_ELSE" ) +#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CHECK_NOFAIL" ) + +#define CHECK_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "", "CHECK_THROWS" ) +#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS_AS" ) +#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, matcher, "CHECK_THROWS_WITH" ) +#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_NOTHROW" ) + +#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THAT" ) +#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "REQUIRE_THAT" ) + +#define INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" ) +#define WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "WARN", msg ) +#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" ) +#define CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" ) +#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" ) + +#ifdef CATCH_CONFIG_VARIADIC_MACROS + #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) + #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) + #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) + #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ ) + #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) + #define FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", __VA_ARGS__ ) + #define SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", __VA_ARGS__ ) +#else + #define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description ) + #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description ) + #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description ) + #define REGISTER_TEST_CASE( method, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( method, name, description ) + #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description ) + #define FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", msg ) + #define SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", msg ) +#endif +#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" ) + +#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) +#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) + +#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr ) + +#endif + +#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) + +// "BDD-style" convenience wrappers +#ifdef CATCH_CONFIG_VARIADIC_MACROS +#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ ) +#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ ) +#else +#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags ) +#define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags ) +#endif +#define GIVEN( desc ) SECTION( std::string(" Given: ") + desc, "" ) +#define WHEN( desc ) SECTION( std::string(" When: ") + desc, "" ) +#define AND_WHEN( desc ) SECTION( std::string("And when: ") + desc, "" ) +#define THEN( desc ) SECTION( std::string(" Then: ") + desc, "" ) +#define AND_THEN( desc ) SECTION( std::string(" And: ") + desc, "" ) + +using Catch::Detail::Approx; + +#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED + diff --git a/3rdparty/tinygltf/tests/tester.cc b/3rdparty/tinygltf/tests/tester.cc new file mode 100644 index 0000000..1cee2b4 --- /dev/null +++ b/3rdparty/tinygltf/tests/tester.cc @@ -0,0 +1,26 @@ +#define TINYGLTF_IMPLEMENTATION +#define STB_IMAGE_IMPLEMENTATION +#include "tiny_gltf.h" + +#define CATCH_CONFIG_MAIN // This tells Catch to provide a main() - only do this in one cpp file +#include "catch.hpp" + +#include +#include +#include +#include +#include +#include + +TEST_CASE("parse-error", "[parse]") { + + tinygltf::Model model; + tinygltf::TinyGLTF ctx; + std::string err; + + bool ret = ctx.LoadASCIIFromString(&model, &err, "bora", strlen("bora"), /* basedir*/ ""); + + REQUIRE(false == ret); + +} + diff --git a/3rdparty/tinygltf/tiny_gltf.h b/3rdparty/tinygltf/tiny_gltf.h new file mode 100644 index 0000000..23c1ebb --- /dev/null +++ b/3rdparty/tinygltf/tiny_gltf.h @@ -0,0 +1,3883 @@ +// +// Header-only tiny glTF 2.0 loader and serializer. +// +// +// The MIT License (MIT) +// +// Copyright (c) 2015 - 2017 Syoyo Fujita, AurĂ©lien Chatelain and many +// contributors. +// +// 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. + +// Version: +// - v2.0.0 glTF 2.0!. +// +// Tiny glTF loader is using following third party libraries: +// +// - jsonhpp: C++ JSON library. +// - base64: base64 decode/encode library. +// - stb_image: Image loading library. +// +#ifndef TINY_GLTF_H_ +#define TINY_GLTF_H_ + +#include +#include +#include +#include +#include +#include +#include + +namespace tinygltf { + +#define TINYGLTF_MODE_POINTS (0) +#define TINYGLTF_MODE_LINE (1) +#define TINYGLTF_MODE_LINE_LOOP (2) +#define TINYGLTF_MODE_TRIANGLES (4) +#define TINYGLTF_MODE_TRIANGLE_STRIP (5) +#define TINYGLTF_MODE_TRIANGLE_FAN (6) + +#define TINYGLTF_COMPONENT_TYPE_BYTE (5120) +#define TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE (5121) +#define TINYGLTF_COMPONENT_TYPE_SHORT (5122) +#define TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT (5123) +#define TINYGLTF_COMPONENT_TYPE_INT (5124) +#define TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT (5125) +#define TINYGLTF_COMPONENT_TYPE_FLOAT (5126) +#define TINYGLTF_COMPONENT_TYPE_DOUBLE (5130) + +#define TINYGLTF_TEXTURE_FILTER_NEAREST (9728) +#define TINYGLTF_TEXTURE_FILTER_LINEAR (9729) +#define TINYGLTF_TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST (9984) +#define TINYGLTF_TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST (9985) +#define TINYGLTF_TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR (9986) +#define TINYGLTF_TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR (9987) + +#define TINYGLTF_TEXTURE_WRAP_REPEAT (10497) +#define TINYGLTF_TEXTURE_WRAP_CLAMP_TO_EDGE (33071) +#define TINYGLTF_TEXTURE_WRAP_MIRRORED_REPEAT (33648) + +// Redeclarations of the above for technique.parameters. +#define TINYGLTF_PARAMETER_TYPE_BYTE (5120) +#define TINYGLTF_PARAMETER_TYPE_UNSIGNED_BYTE (5121) +#define TINYGLTF_PARAMETER_TYPE_SHORT (5122) +#define TINYGLTF_PARAMETER_TYPE_UNSIGNED_SHORT (5123) +#define TINYGLTF_PARAMETER_TYPE_INT (5124) +#define TINYGLTF_PARAMETER_TYPE_UNSIGNED_INT (5125) +#define TINYGLTF_PARAMETER_TYPE_FLOAT (5126) + +#define TINYGLTF_PARAMETER_TYPE_FLOAT_VEC2 (35664) +#define TINYGLTF_PARAMETER_TYPE_FLOAT_VEC3 (35665) +#define TINYGLTF_PARAMETER_TYPE_FLOAT_VEC4 (35666) + +#define TINYGLTF_PARAMETER_TYPE_INT_VEC2 (35667) +#define TINYGLTF_PARAMETER_TYPE_INT_VEC3 (35668) +#define TINYGLTF_PARAMETER_TYPE_INT_VEC4 (35669) + +#define TINYGLTF_PARAMETER_TYPE_BOOL (35670) +#define TINYGLTF_PARAMETER_TYPE_BOOL_VEC2 (35671) +#define TINYGLTF_PARAMETER_TYPE_BOOL_VEC3 (35672) +#define TINYGLTF_PARAMETER_TYPE_BOOL_VEC4 (35673) + +#define TINYGLTF_PARAMETER_TYPE_FLOAT_MAT2 (35674) +#define TINYGLTF_PARAMETER_TYPE_FLOAT_MAT3 (35675) +#define TINYGLTF_PARAMETER_TYPE_FLOAT_MAT4 (35676) + +#define TINYGLTF_PARAMETER_TYPE_SAMPLER_2D (35678) + +// End parameter types + +#define TINYGLTF_TYPE_VEC2 (2) +#define TINYGLTF_TYPE_VEC3 (3) +#define TINYGLTF_TYPE_VEC4 (4) +#define TINYGLTF_TYPE_MAT2 (32 + 2) +#define TINYGLTF_TYPE_MAT3 (32 + 3) +#define TINYGLTF_TYPE_MAT4 (32 + 4) +#define TINYGLTF_TYPE_SCALAR (64 + 1) +#define TINYGLTF_TYPE_VECTOR (64 + 4) +#define TINYGLTF_TYPE_MATRIX (64 + 16) + +#define TINYGLTF_IMAGE_FORMAT_JPEG (0) +#define TINYGLTF_IMAGE_FORMAT_PNG (1) +#define TINYGLTF_IMAGE_FORMAT_BMP (2) +#define TINYGLTF_IMAGE_FORMAT_GIF (3) + +#define TINYGLTF_TEXTURE_FORMAT_ALPHA (6406) +#define TINYGLTF_TEXTURE_FORMAT_RGB (6407) +#define TINYGLTF_TEXTURE_FORMAT_RGBA (6408) +#define TINYGLTF_TEXTURE_FORMAT_LUMINANCE (6409) +#define TINYGLTF_TEXTURE_FORMAT_LUMINANCE_ALPHA (6410) + +#define TINYGLTF_TEXTURE_TARGET_TEXTURE2D (3553) +#define TINYGLTF_TEXTURE_TYPE_UNSIGNED_BYTE (5121) + +#define TINYGLTF_TARGET_ARRAY_BUFFER (34962) +#define TINYGLTF_TARGET_ELEMENT_ARRAY_BUFFER (34963) + +#define TINYGLTF_SHADER_TYPE_VERTEX_SHADER (35633) +#define TINYGLTF_SHADER_TYPE_FRAGMENT_SHADER (35632) + +typedef enum { + NULL_TYPE = 0, + NUMBER_TYPE = 1, + INT_TYPE = 2, + BOOL_TYPE = 3, + STRING_TYPE = 4, + ARRAY_TYPE = 5, + BINARY_TYPE = 6, + OBJECT_TYPE = 7 +} Type; + +static inline int32_t GetComponentSizeInBytes(uint32_t componentType) { + if (componentType == TINYGLTF_COMPONENT_TYPE_BYTE) { + return 1; + } else if (componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) { + return 1; + } else if (componentType == TINYGLTF_COMPONENT_TYPE_SHORT) { + return 2; + } else if (componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) { + return 2; + } else if (componentType == TINYGLTF_COMPONENT_TYPE_INT) { + return 4; + } else if (componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT) { + return 4; + } else if (componentType == TINYGLTF_COMPONENT_TYPE_FLOAT) { + return 4; + } else if (componentType == TINYGLTF_COMPONENT_TYPE_DOUBLE) { + return 8; + } else { + // Unknown componenty type + return -1; + } +} + +static inline int32_t GetTypeSizeInBytes(uint32_t ty) { + if (ty == TINYGLTF_TYPE_SCALAR) { + return 1; + } else if (ty == TINYGLTF_TYPE_VEC2) { + return 2; + } else if (ty == TINYGLTF_TYPE_VEC3) { + return 3; + } else if (ty == TINYGLTF_TYPE_VEC4) { + return 4; + } else if (ty == TINYGLTF_TYPE_MAT2) { + return 4; + } else if (ty == TINYGLTF_TYPE_MAT3) { + return 9; + } else if (ty == TINYGLTF_TYPE_MAT4) { + return 16; + } else { + // Unknown componenty type + return -1; + } +} + +#ifdef __clang__ +#pragma clang diagnostic push +// Suppress warning for : static Value null_value +// https://stackoverflow.com/questions/15708411/how-to-deal-with-global-constructor-warning-in-clang +#pragma clang diagnostic ignored "-Wexit-time-destructors" +#pragma clang diagnostic ignored "-Wpadded" +#endif + +// Simple class to represent JSON object +class Value { + public: + typedef std::vector Array; + typedef std::map Object; + + Value() : type_(NULL_TYPE) {} + + explicit Value(bool b) : type_(BOOL_TYPE) { boolean_value_ = b; } + explicit Value(int i) : type_(INT_TYPE) { int_value_ = i; } + explicit Value(double n) : type_(NUMBER_TYPE) { number_value_ = n; } + explicit Value(const std::string &s) : type_(STRING_TYPE) { + string_value_ = s; + } + explicit Value(const unsigned char *p, size_t n) : type_(BINARY_TYPE) { + binary_value_.resize(n); + memcpy(binary_value_.data(), p, n); + } + explicit Value(const Array &a) : type_(ARRAY_TYPE) { + array_value_ = Array(a); + } + explicit Value(const Object &o) : type_(OBJECT_TYPE) { + object_value_ = Object(o); + } + + char Type() const { return static_cast(type_); } + + bool IsBool() const { return (type_ == BOOL_TYPE); } + + bool IsInt() const { return (type_ == INT_TYPE); } + + bool IsNumber() const { return (type_ == NUMBER_TYPE); } + + bool IsString() const { return (type_ == STRING_TYPE); } + + bool IsBinary() const { return (type_ == BINARY_TYPE); } + + bool IsArray() const { return (type_ == ARRAY_TYPE); } + + bool IsObject() const { return (type_ == OBJECT_TYPE); } + + // Accessor + template + const T &Get() const; + template + T &Get(); + + // Lookup value from an array + const Value &Get(int idx) const { + static Value null_value; + assert(IsArray()); + assert(idx >= 0); + return (static_cast(idx) < array_value_.size()) + ? array_value_[static_cast(idx)] + : null_value; + } + + // Lookup value from a key-value pair + const Value &Get(const std::string &key) const { + static Value null_value; + assert(IsObject()); + Object::const_iterator it = object_value_.find(key); + return (it != object_value_.end()) ? it->second : null_value; + } + + size_t ArrayLen() const { + if (!IsArray()) return 0; + return array_value_.size(); + } + + // Valid only for object type. + bool Has(const std::string &key) const { + if (!IsObject()) return false; + Object::const_iterator it = object_value_.find(key); + return (it != object_value_.end()) ? true : false; + } + + // List keys + std::vector Keys() const { + std::vector keys; + if (!IsObject()) return keys; // empty + + for (Object::const_iterator it = object_value_.begin(); + it != object_value_.end(); ++it) { + keys.push_back(it->first); + } + + return keys; + } + + size_t Size() const { return (IsArray() ? ArrayLen() : Keys().size()); } + + protected: + int type_; + + int int_value_; + double number_value_; + std::string string_value_; + std::vector binary_value_; + Array array_value_; + Object object_value_; + bool boolean_value_; +}; + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#define TINYGLTF_VALUE_GET(ctype, var) \ + template <> \ + inline const ctype &Value::Get() const { \ + return var; \ + } \ + template <> \ + inline ctype &Value::Get() { \ + return var; \ + } +TINYGLTF_VALUE_GET(bool, boolean_value_) +TINYGLTF_VALUE_GET(double, number_value_) +TINYGLTF_VALUE_GET(int, int_value_) +TINYGLTF_VALUE_GET(std::string, string_value_) +TINYGLTF_VALUE_GET(std::vector, binary_value_) +TINYGLTF_VALUE_GET(Value::Array, array_value_) +TINYGLTF_VALUE_GET(Value::Object, object_value_) +#undef TINYGLTF_VALUE_GET + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wc++98-compat" +#pragma clang diagnostic ignored "-Wpadded" +#endif + +/// Agregate object for representing a color +using ColorValue = std::array; + +struct Parameter { + bool bool_value; + std::string string_value; + std::vector number_array; + std::map json_double_value; + + // context sensitive methods. depending the type of the Parameter you are + // accessing, these are either valid or not + // If this parameter represent a texture map in a material, will return the + // texture index + + /// Return the index of a texture if this Parameter is a texture map. + /// Returned value is only valid if the parameter represent a texture from a + /// material + int TextureIndex() const { + const auto it = json_double_value.find("index"); + if (it != std::end(json_double_value)) { + return int(it->second); + } + return -1; + } + + /// Material factor, like the roughness or metalness of a material + /// Returned value is only valid if the parameter represent a texture from a + /// material + double Factor() const { return number_array[0]; } + + /// Return the color of a material + /// Returned value is only valid if the parameter represent a texture from a + /// material + ColorValue ColorFactor() const { + return { + {// this agregate intialize the std::array object, and uses C++11 RVO. + number_array[0], number_array[1], number_array[2], + (number_array.size() > 3 ? number_array[3] : 1.0)}}; + } +}; + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wpadded" +#endif + +typedef std::map ParameterMap; + +struct AnimationChannel { + int sampler; // required + int target_node; // required (index of the node to target) + std::string target_path; // required in ["translation", "rotation", "scale", + // "weights"] + Value extras; + + AnimationChannel() : sampler(-1), target_node(-1) {} +}; + +struct AnimationSampler { + int input; // required + int output; // required + std::string interpolation; // in ["LINEAR", "STEP", "CATMULLROMSPLINE", + // "CUBICSPLINE"], default "LINEAR" + + AnimationSampler() : input(-1), output(-1), interpolation("LINEAR") {} +}; + +typedef struct { + std::string name; + std::vector channels; + std::vector samplers; + Value extras; +} Animation; + +struct Skin { + std::string name; + int inverseBindMatrices; // required here but not in the spec + int skeleton; // The index of the node used as a skeleton root + std::vector joints; // Indices of skeleton nodes + + Skin() { + inverseBindMatrices = -1; + skeleton = -1; + } +}; + +struct Sampler { + std::string name; + int minFilter; // ["NEAREST", "LINEAR", "NEAREST_MIPMAP_LINEAR", + // "LINEAR_MIPMAP_NEAREST", "NEAREST_MIPMAP_LINEAR", + // "LINEAR_MIPMAP_LINEAR"] + int magFilter; // ["NEAREST", "LINEAR"] + int wrapS; // ["CLAMP_TO_EDGE", "MIRRORED_REPEAT", "REPEAT"], default + // "REPEAT" + int wrapT; // ["CLAMP_TO_EDGE", "MIRRORED_REPEAT", "REPEAT"], default + // "REPEAT" + int wrapR; // TinyGLTF extension + Value extras; + + Sampler() + : wrapS(TINYGLTF_TEXTURE_WRAP_REPEAT), + wrapT(TINYGLTF_TEXTURE_WRAP_REPEAT) {} +}; + +struct Image { + std::string name; + int width; + int height; + int component; + std::vector image; + int bufferView; // (required if no uri) + std::string mimeType; // (required if no uri) ["image/jpeg", "image/png", + // "image/bmp", "image/gif"] + std::string uri; // (required if no mimeType) + Value extras; + + Image() { bufferView = -1; } +}; + +struct Texture { + int sampler; + int source; // Required (not specified in the spec ?) + Value extras; + + Texture() : sampler(-1), source(-1) {} +}; + +// Each extension should be stored in a ParameterMap. +// members not in the values could be included in the ParameterMap +// to keep a single material model +struct Material { + std::string name; + + ParameterMap values; // PBR metal/roughness workflow + ParameterMap additionalValues; // normal/occlusion/emissive values + ParameterMap extCommonValues; // KHR_common_material extension + ParameterMap extPBRValues; + Value extras; +}; + +struct BufferView { + std::string name; + int buffer; // Required + size_t byteOffset; // minimum 0, default 0 + size_t byteLength; // required, minimum 1 + size_t byteStride; // minimum 4, maximum 252 (multiple of 4), default 0 = + // understood to be tightly packed + int target; // ["ARRAY_BUFFER", "ELEMENT_ARRAY_BUFFER"] + Value extras; + + BufferView() : byteOffset(0), byteStride(0) {} +}; + +struct Accessor { + int bufferView; // optional in spec but required here since sparse accessor + // are not supported + std::string name; + size_t byteOffset; + bool normalized; // optinal. + int componentType; // (required) One of TINYGLTF_COMPONENT_TYPE_*** + size_t count; // required + int type; // (required) One of TINYGLTF_TYPE_*** .. + Value extras; + + std::vector minValues; // optional + std::vector maxValues; // optional + + // TODO(syoyo): "sparse" + + /// + /// Utility function to compute byteStride for a given bufferView object. + /// Returns -1 upon invalid glTF value or parameter configuration. + /// + int ByteStride(const BufferView &bufferViewObject) const { + if (bufferViewObject.byteStride == 0) { + // Assume data is tightly packed. + int componentSizeInBytes = + GetComponentSizeInBytes(static_cast(componentType)); + if (componentSizeInBytes <= 0) { + return -1; + } + + int typeSizeInBytes = GetTypeSizeInBytes(static_cast(type)); + if (typeSizeInBytes <= 0) { + return -1; + } + + return componentSizeInBytes * typeSizeInBytes; + } else { + // Check if byteStride is a mulple of the size of the accessor's component + // type. + int componentSizeInBytes = + GetComponentSizeInBytes(static_cast(componentType)); + if (componentSizeInBytes <= 0) { + return -1; + } + + if ((bufferViewObject.byteStride % uint32_t(componentSizeInBytes)) != 0) { + return -1; + } + return static_cast(bufferViewObject.byteStride); + } + + return 0; + } + + Accessor() { bufferView = -1; } +}; + +struct PerspectiveCamera { + float aspectRatio; // min > 0 + float yfov; // required. min > 0 + float zfar; // min > 0 + float znear; // required. min > 0 + + PerspectiveCamera() + : aspectRatio(0.0f), + yfov(0.0f), + zfar(0.0f) // 0 = use infinite projecton matrix + , + znear(0.0f) {} + + ParameterMap extensions; + Value extras; +}; + +struct OrthographicCamera { + float xmag; // required. must not be zero. + float ymag; // required. must not be zero. + float zfar; // required. `zfar` must be greater than `znear`. + float znear; // required + + OrthographicCamera() : xmag(0.0f), ymag(0.0f), zfar(0.0f), znear(0.0f) {} + + ParameterMap extensions; + Value extras; +}; + +struct Camera { + std::string type; // required. "perspective" or "orthographic" + std::string name; + + PerspectiveCamera perspective; + OrthographicCamera orthographic; + + Camera() {} + + ParameterMap extensions; + Value extras; +}; + +struct Primitive { + std::map attributes; // (required) A dictionary object of + // integer, where each integer + // is the index of the accessor + // containing an attribute. + int material; // The index of the material to apply to this primitive + // when rendering. + int indices; // The index of the accessor that contains the indices. + int mode; // one of TINYGLTF_MODE_*** + std::vector > targets; // array of morph targets, + // where each target is a dict with attribues in ["POSITION, "NORMAL", + // "TANGENT"] pointing + // to their corresponding accessors + Value extras; + + Primitive() { + material = -1; + indices = -1; + } +}; + +typedef struct { + std::string name; + std::vector primitives; + std::vector weights; // weights to be applied to the Morph Targets + std::vector > targets; + ParameterMap extensions; + Value extras; +} Mesh; + +class Node { + public: + Node() : camera(-1), skin(-1), mesh(-1) {} + + Node(const Node &rhs) { + camera = rhs.camera; + + name = rhs.name; + skin = rhs.skin; + mesh = rhs.mesh; + children = rhs.children; + rotation = rhs.rotation; + scale = rhs.scale; + translation = rhs.translation; + matrix = rhs.matrix; + weights = rhs.weights; + + extras = rhs.extras; + extLightsValues = rhs.extLightsValues; + } + + ~Node() {} + + int camera; // the index of the camera referenced by this node + + std::string name; + int skin; + int mesh; + std::vector children; + std::vector rotation; // length must be 0 or 4 + std::vector scale; // length must be 0 or 3 + std::vector translation; // length must be 0 or 3 + std::vector matrix; // length must be 0 or 16 + std::vector weights; // The weights of the instantiated Morph Target + + Value extras; + ParameterMap extLightsValues; // KHR_lights_cmn extension +}; + +typedef struct { + std::string name; + std::vector data; + std::string + uri; // considered as required here but not in the spec (need to clarify) + Value extras; +} Buffer; + +typedef struct { + std::string version; // required + std::string generator; + std::string minVersion; + std::string copyright; + ParameterMap extensions; + Value extras; +} Asset; + +struct Scene { + std::string name; + std::vector nodes; + + ParameterMap extensions; + ParameterMap extras; +}; + +struct Light { + std::string name; + std::vector color; + std::string type; +}; + +class Model { + public: + Model() {} + ~Model() {} + + std::vector accessors; + std::vector animations; + std::vector buffers; + std::vector bufferViews; + std::vector materials; + std::vector meshes; + std::vector nodes; + std::vector textures; + std::vector images; + std::vector skins; + std::vector samplers; + std::vector cameras; + std::vector scenes; + std::vector lights; + + int defaultScene; + std::vector extensionsUsed; + std::vector extensionsRequired; + + Asset asset; + + Value extras; +}; + +enum SectionCheck { + NO_REQUIRE = 0x00, + REQUIRE_SCENE = 0x01, + REQUIRE_SCENES = 0x02, + REQUIRE_NODES = 0x04, + REQUIRE_ACCESSORS = 0x08, + REQUIRE_BUFFERS = 0x10, + REQUIRE_BUFFER_VIEWS = 0x20, + REQUIRE_ALL = 0x3f +}; + +/// +/// LoadImageDataFunction type. Signature for custom image loading callbacks. +/// +typedef bool (*LoadImageDataFunction)(Image *, std::string *, int, int, + const unsigned char *, int, void *); + +#ifndef TINYGLTF_NO_STB_IMAGE +// Declaration of default image loader callback +static bool LoadImageData(Image *image, std::string *err, int req_width, + int req_height, const unsigned char *bytes, int size, + void *); +#endif + +class TinyGLTF { + public: +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wc++98-compat" +#endif + + TinyGLTF() : bin_data_(nullptr), bin_size_(0), is_binary_(false) {} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + + ~TinyGLTF() {} + + /// + /// Loads glTF ASCII asset from a file. + /// Returns false and set error string to `err` if there's an error. + /// + bool LoadASCIIFromFile(Model *model, std::string *err, + const std::string &filename, + unsigned int check_sections = REQUIRE_ALL); + + /// + /// Loads glTF ASCII asset from string(memory). + /// `length` = strlen(str); + /// Returns false and set error string to `err` if there's an error. + /// + bool LoadASCIIFromString(Model *model, std::string *err, const char *str, + const unsigned int length, + const std::string &base_dir, + unsigned int check_sections = REQUIRE_ALL); + + /// + /// Loads glTF binary asset from a file. + /// Returns false and set error string to `err` if there's an error. + /// + bool LoadBinaryFromFile(Model *model, std::string *err, + const std::string &filename, + unsigned int check_sections = REQUIRE_ALL); + + /// + /// Loads glTF binary asset from memory. + /// `length` = strlen(str); + /// Returns false and set error string to `err` if there's an error. + /// + bool LoadBinaryFromMemory(Model *model, std::string *err, + const unsigned char *bytes, + const unsigned int length, + const std::string &base_dir = "", + unsigned int check_sections = REQUIRE_ALL); + + /// + /// Write glTF to file. + /// + bool WriteGltfSceneToFile( + Model *model, + const std::string & + filename /*, bool embedImages, bool embedBuffers, bool writeBinary*/); + + /// + /// Set callback to use for loading image data + /// + void SetImageLoader(LoadImageDataFunction LoadImageData, void *user_data); + + private: + /// + /// Loads glTF asset from string(memory). + /// `length` = strlen(str); + /// Returns false and set error string to `err` if there's an error. + /// + bool LoadFromString(Model *model, std::string *err, const char *str, + const unsigned int length, const std::string &base_dir, + unsigned int check_sections); + + const unsigned char *bin_data_; + size_t bin_size_; + bool is_binary_; + + LoadImageDataFunction LoadImageData = +#ifndef TINYGLTF_NO_STB_IMAGE + &tinygltf::LoadImageData; +#else + nullptr; +#endif + void *load_image_user_data_ = nullptr; +}; + +#ifdef __clang__ +#pragma clang diagnostic pop // -Wpadded +#endif + +} // namespace tinygltf + +#endif // TINY_GLTF_H_ + +#ifdef TINYGLTF_IMPLEMENTATION +#include +//#include +#include +#include + +#ifdef __clang__ +// Disable some warnings for external files. +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wfloat-equal" +#pragma clang diagnostic ignored "-Wexit-time-destructors" +#pragma clang diagnostic ignored "-Wconversion" +#pragma clang diagnostic ignored "-Wold-style-cast" +#pragma clang diagnostic ignored "-Wdouble-promotion" +#pragma clang diagnostic ignored "-Wglobal-constructors" +#pragma clang diagnostic ignored "-Wreserved-id-macro" +#pragma clang diagnostic ignored "-Wdisabled-macro-expansion" +#pragma clang diagnostic ignored "-Wpadded" +#pragma clang diagnostic ignored "-Wc++98-compat" +#pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +#pragma clang diagnostic ignored "-Wswitch-enum" +#pragma clang diagnostic ignored "-Wimplicit-fallthrough" +#pragma clang diagnostic ignored "-Wweak-vtables" +#pragma clang diagnostic ignored "-Wcovered-switch-default" +#if __has_warning("-Wcomma") +#pragma clang diagnostic ignored "-Wcomma" +#endif +#if __has_warning("-Wzero-as-null-pointer-constant") +#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" +#endif +#if __has_warning("-Wcast-qual") +#pragma clang diagnostic ignored "-Wcast-qual" +#endif +#endif + +#include "./json.hpp" + +#ifndef TINYGLTF_NO_STB_IMAGE +#include "./stb_image.h" +#endif + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#ifdef _WIN32 +#include +#elif !defined(__ANDROID__) +#include +#endif + +#if defined(__sparcv9) +// Big endian +#else +#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || MINIZ_X86_OR_X64_CPU +#define TINYGLTF_LITTLE_ENDIAN 1 +#endif +#endif + +using nlohmann::json; + +#ifdef __APPLE__ +#include "TargetConditionals.h" +#endif + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wc++98-compat" +#endif + +namespace tinygltf { + +static void swap4(unsigned int *val) { +#ifdef TINYGLTF_LITTLE_ENDIAN + (void)val; +#else + unsigned int tmp = *val; + unsigned char *dst = reinterpret_cast(val); + unsigned char *src = reinterpret_cast(&tmp); + + dst[0] = src[3]; + dst[1] = src[2]; + dst[2] = src[1]; + dst[3] = src[0]; +#endif +} + +static bool FileExists(const std::string &abs_filename) { + bool ret; +#ifdef _WIN32 + FILE *fp; + errno_t err = fopen_s(&fp, abs_filename.c_str(), "rb"); + if (err != 0) { + return false; + } +#else + FILE *fp = fopen(abs_filename.c_str(), "rb"); +#endif + if (fp) { + ret = true; + fclose(fp); + } else { + ret = false; + } + + return ret; +} + +static std::string ExpandFilePath(const std::string &filepath) { +#ifdef _WIN32 + DWORD len = ExpandEnvironmentStringsA(filepath.c_str(), NULL, 0); + char *str = new char[len]; + ExpandEnvironmentStringsA(filepath.c_str(), str, len); + + std::string s(str); + + delete[] str; + + return s; +#else + +#if defined(TARGET_OS_IPHONE) || defined(TARGET_IPHONE_SIMULATOR) || \ + defined(__ANDROID__) + // no expansion + std::string s = filepath; +#else + std::string s; + wordexp_t p; + + if (filepath.empty()) { + return ""; + } + + // char** w; + int ret = wordexp(filepath.c_str(), &p, 0); + if (ret) { + // err + s = filepath; + return s; + } + + // Use first element only. + if (p.we_wordv) { + s = std::string(p.we_wordv[0]); + wordfree(&p); + } else { + s = filepath; + } + +#endif + + return s; +#endif +} + +static std::string JoinPath(const std::string &path0, + const std::string &path1) { + if (path0.empty()) { + return path1; + } else { + // check '/' + char lastChar = *path0.rbegin(); + if (lastChar != '/') { + return path0 + std::string("/") + path1; + } else { + return path0 + path1; + } + } +} + +static std::string FindFile(const std::vector &paths, + const std::string &filepath) { + for (size_t i = 0; i < paths.size(); i++) { + std::string absPath = ExpandFilePath(JoinPath(paths[i], filepath)); + if (FileExists(absPath)) { + return absPath; + } + } + + return std::string(); +} + +// std::string GetFilePathExtension(const std::string& FileName) +//{ +// if(FileName.find_last_of(".") != std::string::npos) +// return FileName.substr(FileName.find_last_of(".")+1); +// return ""; +//} + +static std::string GetBaseDir(const std::string &filepath) { + if (filepath.find_last_of("/\\") != std::string::npos) + return filepath.substr(0, filepath.find_last_of("/\\")); + return ""; +} + +// https://stackoverflow.com/questions/8520560/get-a-file-name-from-a-path +std::string GetBaseFilename(const std::string &filepath) { + return filepath.substr(filepath.find_last_of("/\\") + 1); +} + +// std::string base64_encode(unsigned char const* , unsigned int len); +std::string base64_decode(std::string const &s); + +/* + base64.cpp and base64.h + + Copyright (C) 2004-2008 RenĂ© Nyffenegger + + This source code is provided 'as-is', without any express or implied + warranty. In no event will the author be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this source code must not be misrepresented; you must not + claim that you wrote the original source code. If you use this source code + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original source code. + + 3. This notice may not be removed or altered from any source distribution. + + RenĂ© Nyffenegger rene.nyffenegger@adp-gmbh.ch + +*/ + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wexit-time-destructors" +#pragma clang diagnostic ignored "-Wglobal-constructors" +#pragma clang diagnostic ignored "-Wsign-conversion" +#pragma clang diagnostic ignored "-Wconversion" +#endif +static const std::string base64_chars = + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "0123456789+/"; + +static inline bool is_base64(unsigned char c) { + return (isalnum(c) || (c == '+') || (c == '/')); +} + +std::string base64_decode(std::string const &encoded_string) { + int in_len = static_cast(encoded_string.size()); + int i = 0; + int j = 0; + int in_ = 0; + unsigned char char_array_4[4], char_array_3[3]; + std::string ret; + + while (in_len-- && (encoded_string[in_] != '=') && + is_base64(encoded_string[in_])) { + char_array_4[i++] = encoded_string[in_]; + in_++; + if (i == 4) { + for (i = 0; i < 4; i++) + char_array_4[i] = + static_cast(base64_chars.find(char_array_4[i])); + + char_array_3[0] = + (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4); + char_array_3[1] = + ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); + char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; + + for (i = 0; (i < 3); i++) ret += char_array_3[i]; + i = 0; + } + } + + if (i) { + for (j = i; j < 4; j++) char_array_4[j] = 0; + + for (j = 0; j < 4; j++) + char_array_4[j] = + static_cast(base64_chars.find(char_array_4[j])); + + char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4); + char_array_3[1] = + ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); + char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; + + for (j = 0; (j < i - 1); j++) ret += char_array_3[j]; + } + + return ret; +} +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +static bool LoadExternalFile(std::vector *out, std::string *err, + const std::string &filename, + const std::string &basedir, size_t reqBytes, + bool checkSize) { + out->clear(); + + std::vector paths; + paths.push_back(basedir); + paths.push_back("."); + + std::string filepath = FindFile(paths, filename); + if (filepath.empty() || filename.empty()) { + if (err) { + (*err) += "File not found : " + filename + "\n"; + } + return false; + } + + std::ifstream f(filepath.c_str(), std::ifstream::binary); + if (!f) { + if (err) { + (*err) += "File open error : " + filepath + "\n"; + } + return false; + } + + f.seekg(0, f.end); + size_t sz = static_cast(f.tellg()); + if (int(sz) < 0) { + // Looks reading directory, not a file. + return false; + } + + if (sz == 0) { + // Invalid file size. + return false; + } + std::vector buf(sz); + + f.seekg(0, f.beg); + f.read(reinterpret_cast(&buf.at(0)), + static_cast(sz)); + f.close(); + + if (checkSize) { + if (reqBytes == sz) { + out->swap(buf); + return true; + } else { + std::stringstream ss; + ss << "File size mismatch : " << filepath << ", requestedBytes " + << reqBytes << ", but got " << sz << std::endl; + if (err) { + (*err) += ss.str(); + } + return false; + } + } + + out->swap(buf); + return true; +} + +void TinyGLTF::SetImageLoader(LoadImageDataFunction func, void *user_data) { + LoadImageData = func; + load_image_user_data_ = user_data; +} + +#ifndef TINYGLTF_NO_STB_IMAGE +static bool LoadImageData(Image *image, std::string *err, int req_width, + int req_height, const unsigned char *bytes, int size, + void *) { + int w, h, comp; + // if image cannot be decoded, ignore parsing and keep it by its path + // don't break in this case + // FIXME we should only enter this function if the image is embedded. If + // image->uri references + // an image file, it should be left as it is. Image loading should not be + // mandatory (to support other formats) + unsigned char *data = stbi_load_from_memory(bytes, size, &w, &h, &comp, 0); + if (!data) { + if (err) { + (*err) += "Unknown image format.\n"; + } + return false; + } + + if (w < 1 || h < 1) { + free(data); + if (err) { + (*err) += "Invalid image data.\n"; + } + return false; + } + + if (req_width > 0) { + if (req_width != w) { + free(data); + if (err) { + (*err) += "Image width mismatch.\n"; + } + return false; + } + } + + if (req_height > 0) { + if (req_height != h) { + free(data); + if (err) { + (*err) += "Image height mismatch.\n"; + } + return false; + } + } + + image->width = w; + image->height = h; + image->component = comp; + image->image.resize(static_cast(w * h * comp)); + std::copy(data, data + w * h * comp, image->image.begin()); + + free(data); + + return true; +} +#endif + +static bool IsDataURI(const std::string &in) { + std::string header = "data:application/octet-stream;base64,"; + if (in.find(header) == 0) { + return true; + } + + header = "data:image/jpeg;base64,"; + if (in.find(header) == 0) { + return true; + } + + header = "data:image/png;base64,"; + if (in.find(header) == 0) { + return true; + } + + header = "data:image/bmp;base64,"; + if (in.find(header) == 0) { + return true; + } + + header = "data:image/gif;base64,"; + if (in.find(header) == 0) { + return true; + } + + header = "data:text/plain;base64,"; + if (in.find(header) == 0) { + return true; + } + + header = "data:application/gltf-buffer;base64,"; + if (in.find(header) == 0) { + return true; + } + + return false; +} + +static bool DecodeDataURI(std::vector *out, + const std::string &in, size_t reqBytes, + bool checkSize) { + std::string header = "data:application/octet-stream;base64,"; + std::string data; + if (in.find(header) == 0) { + data = base64_decode(in.substr(header.size())); // cut mime string. + } + + if (data.empty()) { + header = "data:image/jpeg;base64,"; + if (in.find(header) == 0) { + data = base64_decode(in.substr(header.size())); // cut mime string. + } + } + + if (data.empty()) { + header = "data:image/png;base64,"; + if (in.find(header) == 0) { + data = base64_decode(in.substr(header.size())); // cut mime string. + } + } + + if (data.empty()) { + header = "data:image/bmp;base64,"; + if (in.find(header) == 0) { + data = base64_decode(in.substr(header.size())); // cut mime string. + } + } + + if (data.empty()) { + header = "data:image/gif;base64,"; + if (in.find(header) == 0) { + data = base64_decode(in.substr(header.size())); // cut mime string. + } + } + + if (data.empty()) { + header = "data:text/plain;base64,"; + if (in.find(header) == 0) { + data = base64_decode(in.substr(header.size())); + } + } + + if (data.empty()) { + header = "data:application/gltf-buffer;base64,"; + if (in.find(header) == 0) { + data = base64_decode(in.substr(header.size())); + } + } + + if (data.empty()) { + return false; + } + + if (checkSize) { + if (data.size() != reqBytes) { + return false; + } + out->resize(reqBytes); + } else { + out->resize(data.size()); + } + std::copy(data.begin(), data.end(), out->begin()); + return true; +} + +static void ParseObjectProperty(Value *ret, const json &o) { + tinygltf::Value::Object vo; + json::const_iterator it(o.begin()); + json::const_iterator itEnd(o.end()); + + for (; it != itEnd; it++) { + json v = it.value(); + + if (v.is_boolean()) { + vo[it.key()] = tinygltf::Value(v.get()); + } else if (v.is_number()) { + vo[it.key()] = tinygltf::Value(v.get()); + } else if (v.is_number_integer()) { + vo[it.key()] = + tinygltf::Value(static_cast(v.get())); // truncate + } else if (v.is_string()) { + vo[it.key()] = tinygltf::Value(v.get()); + } else if (v.is_object()) { + tinygltf::Value child_value; + ParseObjectProperty(&child_value, v); + vo[it.key()] = child_value; + } + // TODO(syoyo) binary, array + } + + (*ret) = tinygltf::Value(vo); +} + +static bool ParseExtrasProperty(Value *ret, const json &o) { + json::const_iterator it = o.find("extras"); + if (it == o.end()) { + return false; + } + + // FIXME(syoyo) Currently we only support `object` type for extras property. + if (!it.value().is_object()) { + return false; + } + + ParseObjectProperty(ret, it.value()); + + return true; +} + +static bool ParseBooleanProperty(bool *ret, std::string *err, const json &o, + const std::string &property, + const bool required, + const std::string &parent_node = "") { + json::const_iterator it = o.find(property); + if (it == o.end()) { + if (required) { + if (err) { + (*err) += "'" + property + "' property is missing"; + if (!parent_node.empty()) { + (*err) += " in " + parent_node; + } + (*err) += ".\n"; + } + } + return false; + } + + if (!it.value().is_boolean()) { + if (required) { + if (err) { + (*err) += "'" + property + "' property is not a bool type.\n"; + } + } + return false; + } + + if (ret) { + (*ret) = it.value().get(); + } + + return true; +} + +static bool ParseNumberProperty(double *ret, std::string *err, const json &o, + const std::string &property, + const bool required, + const std::string &parent_node = "") { + json::const_iterator it = o.find(property); + if (it == o.end()) { + if (required) { + if (err) { + (*err) += "'" + property + "' property is missing"; + if (!parent_node.empty()) { + (*err) += " in " + parent_node; + } + (*err) += ".\n"; + } + } + return false; + } + + if (!it.value().is_number()) { + if (required) { + if (err) { + (*err) += "'" + property + "' property is not a number type.\n"; + } + } + return false; + } + + if (ret) { + (*ret) = it.value().get(); + } + + return true; +} + +static bool ParseNumberArrayProperty(std::vector *ret, std::string *err, + const json &o, const std::string &property, + bool required, + const std::string &parent_node = "") { + json::const_iterator it = o.find(property); + if (it == o.end()) { + if (required) { + if (err) { + (*err) += "'" + property + "' property is missing"; + if (!parent_node.empty()) { + (*err) += " in " + parent_node; + } + (*err) += ".\n"; + } + } + return false; + } + + if (!it.value().is_array()) { + if (required) { + if (err) { + (*err) += "'" + property + "' property is not an array"; + if (!parent_node.empty()) { + (*err) += " in " + parent_node; + } + (*err) += ".\n"; + } + } + return false; + } + + ret->clear(); + for (json::const_iterator i = it.value().begin(); i != it.value().end(); + i++) { + if (!i.value().is_number()) { + if (required) { + if (err) { + (*err) += "'" + property + "' property is not a number.\n"; + if (!parent_node.empty()) { + (*err) += " in " + parent_node; + } + (*err) += ".\n"; + } + } + return false; + } + ret->push_back(i.value()); + } + + return true; +} + +static bool ParseStringProperty( + std::string *ret, std::string *err, const json &o, + const std::string &property, bool required, + const std::string &parent_node = std::string()) { + json::const_iterator it = o.find(property); + if (it == o.end()) { + if (required) { + if (err) { + (*err) += "'" + property + "' property is missing"; + if (parent_node.empty()) { + (*err) += ".\n"; + } else { + (*err) += " in `" + parent_node + "'.\n"; + } + } + } + return false; + } + + if (!it.value().is_string()) { + if (required) { + if (err) { + (*err) += "'" + property + "' property is not a string type.\n"; + } + } + return false; + } + + if (ret) { + (*ret) = it.value(); + } + + return true; +} + +static bool ParseStringIntProperty(std::map *ret, + std::string *err, const json &o, + const std::string &property, bool required, + const std::string &parent = "") { + json::const_iterator it = o.find(property); + if (it == o.end()) { + if (required) { + if (err) { + if (!parent.empty()) { + (*err) += + "'" + property + "' property is missing in " + parent + ".\n"; + } else { + (*err) += "'" + property + "' property is missing.\n"; + } + } + } + return false; + } + + // Make sure we are dealing with an object / dictionary. + if (!it.value().is_object()) { + if (required) { + if (err) { + (*err) += "'" + property + "' property is not an object.\n"; + } + } + return false; + } + + ret->clear(); + const json &dict = it.value(); + + json::const_iterator dictIt(dict.begin()); + json::const_iterator dictItEnd(dict.end()); + + for (; dictIt != dictItEnd; ++dictIt) { + if (!dictIt.value().is_number()) { + if (required) { + if (err) { + (*err) += "'" + property + "' value is not an int.\n"; + } + } + return false; + } + + // Insert into the list. + (*ret)[dictIt.key()] = static_cast(dictIt.value()); + } + return true; +} + +static bool ParseJSONProperty(std::map *ret, + std::string *err, const json &o, + const std::string &property, bool required) { + json::const_iterator it = o.find(property); + if (it == o.end()) { + if (required) { + if (err) { + (*err) += "'" + property + "' property is missing. \n'"; + } + } + return false; + } + + if (!it.value().is_object()) { + if (required) { + if (err) { + (*err) += "'" + property + "' property is not a JSON object.\n"; + } + } + return false; + } + + ret->clear(); + const json &obj = it.value(); + json::const_iterator it2(obj.begin()); + json::const_iterator itEnd(obj.end()); + for (; it2 != itEnd; it2++) { + if (it2.value().is_number()) + ret->insert(std::pair(it2.key(), it2.value())); + } + + return true; +} + +static bool ParseAsset(Asset *asset, std::string *err, const json &o) { + ParseStringProperty(&asset->version, err, o, "version", true, "Asset"); + ParseStringProperty(&asset->generator, err, o, "generator", false, "Asset"); + ParseStringProperty(&asset->minVersion, err, o, "minVersion", false, "Asset"); + + // Unity exporter version is added as extra here + ParseExtrasProperty(&(asset->extras), o); + + return true; +} + +static bool ParseImage(Image *image, std::string *err, const json &o, + const std::string &basedir, bool is_binary, + const unsigned char *bin_data, size_t bin_size, + LoadImageDataFunction *LoadImageData = nullptr, + void *user_data = nullptr) { + // A glTF image must either reference a bufferView or an image uri + double bufferView = -1; + bool isEmbedded = + ParseNumberProperty(&bufferView, err, o, "bufferView", false); + + std::string uri; + std::string tmp_err; + if (!ParseStringProperty(&uri, &tmp_err, o, "uri", false) && !isEmbedded) { + if (err) { + (*err) += "`bufferView` or `uri` required for Image.\n"; + } + return false; + } + + ParseStringProperty(&image->name, err, o, "name", false); + + std::vector img; + + if (is_binary) { + // Still binary glTF accepts external dataURI. First try external resources. + bool loaded = false; + if (IsDataURI(uri)) { + loaded = DecodeDataURI(&img, uri, 0, false); + } else { + // Assume external file + // Keep texture path (for textures that cannot be decoded) + image->uri = uri; +#ifdef TINYGLTF_NO_EXTERNAL_IMAGE + return true; +#endif + loaded = LoadExternalFile(&img, err, uri, basedir, 0, false); + } + + if (!loaded) { + // load data from (embedded) binary data + + if ((bin_size == 0) || (bin_data == nullptr)) { + if (err) { + (*err) += "Invalid binary data.\n"; + } + return false; + } + + double buffer_view = -1.0; + if (!ParseNumberProperty(&buffer_view, err, o, "bufferView", true, + "Image")) { + return false; + } + + std::string mime_type; + ParseStringProperty(&mime_type, err, o, "mimeType", false); + + double width = 0.0; + ParseNumberProperty(&width, err, o, "width", false); + + double height = 0.0; + ParseNumberProperty(&height, err, o, "height", false); + + // Just only save some information here. Loading actual image data from + // bufferView is done in other place. + image->bufferView = static_cast(buffer_view); + image->mimeType = mime_type; + image->width = static_cast(width); + image->height = static_cast(height); + + return true; + } + } else { + if (IsDataURI(uri)) { + if (!DecodeDataURI(&img, uri, 0, false)) { + if (err) { + (*err) += "Failed to decode 'uri' for image parameter.\n"; + } + return false; + } + } else { + // Assume external file + // Keep texture path (for textures that cannot be decoded) + image->uri = uri; +#ifdef TINYGLTF_NO_EXTERNAL_IMAGE + return true; +#endif + if (!LoadExternalFile(&img, err, uri, basedir, 0, false)) { + if (err) { + (*err) += "Failed to load external 'uri' for image parameter\n"; + } + // If the image cannot be loaded, keep uri as image->uri. + return true; + } + if (img.empty()) { + if (err) { + (*err) += "Image is empty.\n"; + } + return false; + } + } + } + + if (*LoadImageData == nullptr) { + if (err) { + (*err) += "No LoadImageData callback specified.\n"; + } + return false; + } + return (*LoadImageData)(image, err, 0, 0, &img.at(0), + static_cast(img.size()), user_data); +} + +static bool ParseTexture(Texture *texture, std::string *err, const json &o, + const std::string &basedir) { + (void)basedir; + double sampler = -1.0; + double source = -1.0; + ParseNumberProperty(&sampler, err, o, "sampler", false); + + ParseNumberProperty(&source, err, o, "source", false); + + texture->sampler = static_cast(sampler); + texture->source = static_cast(source); + + return true; +} + +static bool ParseBuffer(Buffer *buffer, std::string *err, const json &o, + const std::string &basedir, bool is_binary = false, + const unsigned char *bin_data = nullptr, + size_t bin_size = 0) { + double byteLength; + if (!ParseNumberProperty(&byteLength, err, o, "byteLength", true, "Buffer")) { + return false; + } + + // In glTF 2.0, uri is not mandatory anymore + buffer->uri.clear(); + ParseStringProperty(&buffer->uri, err, o, "uri", false, "Buffer"); + + // having an empty uri for a non embedded image should not be valid + if (!is_binary && buffer->uri.empty()) { + if (err) { + (*err) += "'uri' is missing from non binary glTF file buffer.\n"; + } + } + + json::const_iterator type = o.find("type"); + if (type != o.end()) { + if (type.value().is_string()) { + const std::string &ty = type.value(); + if (ty.compare("arraybuffer") == 0) { + // buffer.type = "arraybuffer"; + } + } + } + + size_t bytes = static_cast(byteLength); + if (is_binary) { + // Still binary glTF accepts external dataURI. First try external resources. + + if (!buffer->uri.empty()) { + // External .bin file. + LoadExternalFile(&buffer->data, err, buffer->uri, basedir, bytes, true); + } else { + // load data from (embedded) binary data + + if ((bin_size == 0) || (bin_data == nullptr)) { + if (err) { + (*err) += "Invalid binary data in `Buffer'.\n"; + } + return false; + } + + if (byteLength > bin_size) { + if (err) { + std::stringstream ss; + ss << "Invalid `byteLength'. Must be equal or less than binary size: " + "`byteLength' = " + << byteLength << ", binary size = " << bin_size << std::endl; + (*err) += ss.str(); + } + return false; + } + + // Read buffer data + buffer->data.resize(static_cast(byteLength)); + memcpy(&(buffer->data.at(0)), bin_data, static_cast(byteLength)); + } + + } else { + if (IsDataURI(buffer->uri)) { + if (!DecodeDataURI(&buffer->data, buffer->uri, bytes, true)) { + if (err) { + (*err) += "Failed to decode 'uri' : " + buffer->uri + " in Buffer\n"; + } + return false; + } + } else { + // Assume external .bin file. + if (!LoadExternalFile(&buffer->data, err, buffer->uri, basedir, bytes, + true)) { + return false; + } + } + } + + ParseStringProperty(&buffer->name, err, o, "name", false); + + return true; +} + +static bool ParseBufferView(BufferView *bufferView, std::string *err, + const json &o) { + double buffer = -1.0; + if (!ParseNumberProperty(&buffer, err, o, "buffer", true, "BufferView")) { + return false; + } + + double byteOffset = 0.0; + ParseNumberProperty(&byteOffset, err, o, "byteOffset", false); + + double byteLength = 1.0; + if (!ParseNumberProperty(&byteLength, err, o, "byteLength", true, + "BufferView")) { + return false; + } + + size_t byteStride = 0; + double byteStrideValue = 0.0; + if (!ParseNumberProperty(&byteStrideValue, err, o, "byteStride", false)) { + // Spec says: When byteStride of referenced bufferView is not defined, it + // means that accessor elements are tightly packed, i.e., effective stride + // equals the size of the element. + // We cannot determine the actual byteStride until Accessor are parsed, thus + // set 0(= tightly packed) here(as done in OpenGL's VertexAttribPoiner) + byteStride = 0; + } else { + byteStride = static_cast(byteStrideValue); + } + + if ((byteStride > 252) || ((byteStride % 4) != 0)) { + if (err) { + std::stringstream ss; + ss << "Invalid `byteStride' value. `byteStride' must be the multiple of " + "4 : " + << byteStride << std::endl; + + (*err) += ss.str(); + } + return false; + } + + double target = 0.0; + ParseNumberProperty(&target, err, o, "target", false); + int targetValue = static_cast(target); + if ((targetValue == TINYGLTF_TARGET_ARRAY_BUFFER) || + (targetValue == TINYGLTF_TARGET_ELEMENT_ARRAY_BUFFER)) { + // OK + } else { + targetValue = 0; + } + bufferView->target = targetValue; + + ParseStringProperty(&bufferView->name, err, o, "name", false); + + bufferView->buffer = static_cast(buffer); + bufferView->byteOffset = static_cast(byteOffset); + bufferView->byteLength = static_cast(byteLength); + bufferView->byteStride = static_cast(byteStride); + + return true; +} + +static bool ParseAccessor(Accessor *accessor, std::string *err, const json &o) { + double bufferView = -1.0; + if (!ParseNumberProperty(&bufferView, err, o, "bufferView", true, + "Accessor")) { + return false; + } + + double byteOffset = 0.0; + ParseNumberProperty(&byteOffset, err, o, "byteOffset", false, "Accessor"); + + bool normalized = false; + ParseBooleanProperty(&normalized, err, o, "normalized", false, "Accessor"); + + double componentType = 0.0; + if (!ParseNumberProperty(&componentType, err, o, "componentType", true, + "Accessor")) { + return false; + } + + double count = 0.0; + if (!ParseNumberProperty(&count, err, o, "count", true, "Accessor")) { + return false; + } + + std::string type; + if (!ParseStringProperty(&type, err, o, "type", true, "Accessor")) { + return false; + } + + if (type.compare("SCALAR") == 0) { + accessor->type = TINYGLTF_TYPE_SCALAR; + } else if (type.compare("VEC2") == 0) { + accessor->type = TINYGLTF_TYPE_VEC2; + } else if (type.compare("VEC3") == 0) { + accessor->type = TINYGLTF_TYPE_VEC3; + } else if (type.compare("VEC4") == 0) { + accessor->type = TINYGLTF_TYPE_VEC4; + } else if (type.compare("MAT2") == 0) { + accessor->type = TINYGLTF_TYPE_MAT2; + } else if (type.compare("MAT3") == 0) { + accessor->type = TINYGLTF_TYPE_MAT3; + } else if (type.compare("MAT4") == 0) { + accessor->type = TINYGLTF_TYPE_MAT4; + } else { + std::stringstream ss; + ss << "Unsupported `type` for accessor object. Got \"" << type << "\"\n"; + if (err) { + (*err) += ss.str(); + } + return false; + } + + ParseStringProperty(&accessor->name, err, o, "name", false); + + accessor->minValues.clear(); + accessor->maxValues.clear(); + ParseNumberArrayProperty(&accessor->minValues, err, o, "min", false, + "Accessor"); + + ParseNumberArrayProperty(&accessor->maxValues, err, o, "max", false, + "Accessor"); + + accessor->count = static_cast(count); + accessor->bufferView = static_cast(bufferView); + accessor->byteOffset = static_cast(byteOffset); + accessor->normalized = normalized; + { + int comp = static_cast(componentType); + if (comp >= TINYGLTF_COMPONENT_TYPE_BYTE && + comp <= TINYGLTF_COMPONENT_TYPE_DOUBLE) { + // OK + accessor->componentType = comp; + } else { + std::stringstream ss; + ss << "Invalid `componentType` in accessor. Got " << comp << "\n"; + if (err) { + (*err) += ss.str(); + } + return false; + } + } + + ParseExtrasProperty(&(accessor->extras), o); + + return true; +} + +static bool ParsePrimitive(Primitive *primitive, std::string *err, + const json &o) { + double material = -1.0; + ParseNumberProperty(&material, err, o, "material", false); + primitive->material = static_cast(material); + + double mode = static_cast(TINYGLTF_MODE_TRIANGLES); + ParseNumberProperty(&mode, err, o, "mode", false); + + int primMode = static_cast(mode); + primitive->mode = primMode; // Why only triangled were supported ? + + double indices = -1.0; + ParseNumberProperty(&indices, err, o, "indices", false); + primitive->indices = static_cast(indices); + if (!ParseStringIntProperty(&primitive->attributes, err, o, "attributes", + true, "Primitive")) { + return false; + } + + // Look for morph targets + json::const_iterator targetsObject = o.find("targets"); + if ((targetsObject != o.end()) && targetsObject.value().is_array()) { + for (json::const_iterator i = targetsObject.value().begin(); + i != targetsObject.value().end(); i++) { + std::map targetAttribues; + + const json &dict = i.value(); + json::const_iterator dictIt(dict.begin()); + json::const_iterator dictItEnd(dict.end()); + + for (; dictIt != dictItEnd; ++dictIt) { + targetAttribues[dictIt.key()] = static_cast(dictIt.value()); + } + primitive->targets.push_back(targetAttribues); + } + } + + ParseExtrasProperty(&(primitive->extras), o); + + return true; +} + +static bool ParseMesh(Mesh *mesh, std::string *err, const json &o) { + ParseStringProperty(&mesh->name, err, o, "name", false); + + mesh->primitives.clear(); + json::const_iterator primObject = o.find("primitives"); + if ((primObject != o.end()) && primObject.value().is_array()) { + for (json::const_iterator i = primObject.value().begin(); + i != primObject.value().end(); i++) { + Primitive primitive; + if (ParsePrimitive(&primitive, err, i.value())) { + // Only add the primitive if the parsing succeeds. + mesh->primitives.push_back(primitive); + } + } + } + + // Look for morph targets + json::const_iterator targetsObject = o.find("targets"); + if ((targetsObject != o.end()) && targetsObject.value().is_array()) { + for (json::const_iterator i = targetsObject.value().begin(); + i != targetsObject.value().end(); i++) { + std::map targetAttribues; + + const json &dict = i.value(); + json::const_iterator dictIt(dict.begin()); + json::const_iterator dictItEnd(dict.end()); + + for (; dictIt != dictItEnd; ++dictIt) { + targetAttribues[dictIt.key()] = static_cast(dictIt.value()); + } + mesh->targets.push_back(targetAttribues); + } + } + + // Should probably check if has targets and if dimensions fit + ParseNumberArrayProperty(&mesh->weights, err, o, "weights", false); + + ParseExtrasProperty(&(mesh->extras), o); + + return true; +} + +static bool ParseParameterProperty(Parameter *param, std::string *err, + const json &o, const std::string &prop, + bool required) { + double num_val; + + // A parameter value can either be a string or an array of either a boolean or + // a number. Booleans of any kind aren't supported here. Granted, it + // complicates the Parameter structure and breaks it semantically in the sense + // that the client probably works off the assumption that if the string is + // empty the vector is used, etc. Would a tagged union work? + if (ParseStringProperty(¶m->string_value, err, o, prop, false)) { + // Found string property. + return true; + } else if (ParseNumberArrayProperty(¶m->number_array, err, o, prop, + false)) { + // Found a number array. + return true; + } else if (ParseNumberProperty(&num_val, err, o, prop, false)) { + param->number_array.push_back(num_val); + return true; + } else if (ParseJSONProperty(¶m->json_double_value, err, o, prop, + false)) { + return true; + } else if (ParseBooleanProperty(¶m->bool_value, err, o, prop, false)) { + return true; + } else { + if (required) { + if (err) { + (*err) += "parameter must be a string or number / number array.\n"; + } + } + return false; + } +} + +static bool ParseLight(Light *light, std::string *err, const json &o) { + ParseStringProperty(&light->name, err, o, "name", false); + ParseNumberArrayProperty(&light->color, err, o, "color", false); + ParseStringProperty(&light->type, err, o, "type", false); + return true; +} + +static bool ParseNode(Node *node, std::string *err, const json &o) { + ParseStringProperty(&node->name, err, o, "name", false); + + double skin = -1.0; + ParseNumberProperty(&skin, err, o, "skin", false); + node->skin = static_cast(skin); + + // Matrix and T/R/S are exclusive + if (!ParseNumberArrayProperty(&node->matrix, err, o, "matrix", false)) { + ParseNumberArrayProperty(&node->rotation, err, o, "rotation", false); + ParseNumberArrayProperty(&node->scale, err, o, "scale", false); + ParseNumberArrayProperty(&node->translation, err, o, "translation", false); + } + + double camera = -1.0; + ParseNumberProperty(&camera, err, o, "camera", false); + node->camera = static_cast(camera); + + double mesh = -1.0; + ParseNumberProperty(&mesh, err, o, "mesh", false); + node->mesh = int(mesh); + + node->children.clear(); + json::const_iterator childrenObject = o.find("children"); + if ((childrenObject != o.end()) && childrenObject.value().is_array()) { + for (json::const_iterator i = childrenObject.value().begin(); + i != childrenObject.value().end(); i++) { + if (!i.value().is_number()) { + if (err) { + (*err) += "Invalid `children` array.\n"; + } + return false; + } + const int &childrenNode = static_cast(i.value()); + node->children.push_back(childrenNode); + } + } + + ParseExtrasProperty(&(node->extras), o); + + json::const_iterator extensions_object = o.find("extensions"); + if ((extensions_object != o.end()) && extensions_object.value().is_object()) { + const json &ext_values_object = extensions_object.value(); + + json::const_iterator it(ext_values_object.begin()); + json::const_iterator itEnd(ext_values_object.end()); + + for (; it != itEnd; it++) { + if ((it.key().compare("KHR_lights_cmn") == 0) && it.value().is_object()) { + const json &light_values_object = it.value(); + + json::const_iterator itVal(light_values_object.begin()); + json::const_iterator itValEnd(light_values_object.end()); + + for (; itVal != itValEnd; itVal++) { + Parameter param; + if (ParseParameterProperty(¶m, err, light_values_object, + itVal.key(), false)) { + node->extLightsValues[itVal.key()] = param; + } + } + } + } + } + + return true; +} + +static bool ParseMaterial(Material *material, std::string *err, const json &o) { + material->values.clear(); + material->extPBRValues.clear(); + material->additionalValues.clear(); + + json::const_iterator it(o.begin()); + json::const_iterator itEnd(o.end()); + + for (; it != itEnd; it++) { + if (it.key() == "pbrMetallicRoughness") { + if (it.value().is_object()) { + const json &values_object = it.value(); + + json::const_iterator itVal(values_object.begin()); + json::const_iterator itValEnd(values_object.end()); + + for (; itVal != itValEnd; itVal++) { + Parameter param; + if (ParseParameterProperty(¶m, err, values_object, itVal.key(), + false)) { + material->values[itVal.key()] = param; + } + } + } + } else if (it.key() == "extensions") { + if (it.value().is_object()) { + const json &extension = it.value(); + + json::const_iterator extIt = extension.begin(); + if (!extIt.value().is_object()) continue; + + const json &values_object = extIt.value(); + + json::const_iterator itVal(values_object.begin()); + json::const_iterator itValEnd(values_object.end()); + + for (; itVal != itValEnd; itVal++) { + Parameter param; + if (ParseParameterProperty(¶m, err, values_object, itVal.key(), + false)) { + material->extPBRValues[itVal.key()] = param; + } + } + } + } else { + Parameter param; + if (ParseParameterProperty(¶m, err, o, it.key(), false)) { + material->additionalValues[it.key()] = param; + } + } + } + + ParseExtrasProperty(&(material->extras), o); + + return true; +} + +static bool ParseAnimationChannel(AnimationChannel *channel, std::string *err, + const json &o) { + double samplerIndex = -1.0; + double targetIndex = -1.0; + if (!ParseNumberProperty(&samplerIndex, err, o, "sampler", true, + "AnimationChannel")) { + if (err) { + (*err) += "`sampler` field is missing in animation channels\n"; + } + return false; + } + + json::const_iterator targetIt = o.find("target"); + if ((targetIt != o.end()) && targetIt.value().is_object()) { + const json &target_object = targetIt.value(); + + if (!ParseNumberProperty(&targetIndex, err, target_object, "node", true)) { + if (err) { + (*err) += "`node` field is missing in animation.channels.target\n"; + } + return false; + } + + if (!ParseStringProperty(&channel->target_path, err, target_object, "path", + true)) { + if (err) { + (*err) += "`path` field is missing in animation.channels.target\n"; + } + return false; + } + } + + channel->sampler = static_cast(samplerIndex); + channel->target_node = static_cast(targetIndex); + + ParseExtrasProperty(&(channel->extras), o); + + return true; +} + +static bool ParseAnimation(Animation *animation, std::string *err, + const json &o) { + { + json::const_iterator channelsIt = o.find("channels"); + if ((channelsIt != o.end()) && channelsIt.value().is_array()) { + for (json::const_iterator i = channelsIt.value().begin(); + i != channelsIt.value().end(); i++) { + AnimationChannel channel; + if (ParseAnimationChannel(&channel, err, i.value())) { + // Only add the channel if the parsing succeeds. + animation->channels.push_back(channel); + } + } + } + } + + { + json::const_iterator samplerIt = o.find("samplers"); + if ((samplerIt != o.end()) && samplerIt.value().is_array()) { + const json &sampler_array = samplerIt.value(); + + json::const_iterator it = sampler_array.begin(); + json::const_iterator itEnd = sampler_array.end(); + + for (; it != itEnd; it++) { + const json &s = it->get(); + + AnimationSampler sampler; + double inputIndex = -1.0; + double outputIndex = -1.0; + if (!ParseNumberProperty(&inputIndex, err, s, "input", true)) { + if (err) { + (*err) += "`input` field is missing in animation.sampler\n"; + } + return false; + } + if (!ParseStringProperty(&sampler.interpolation, err, s, + "interpolation", true)) { + if (err) { + (*err) += "`interpolation` field is missing in animation.sampler\n"; + } + return false; + } + if (!ParseNumberProperty(&outputIndex, err, s, "output", true)) { + if (err) { + (*err) += "`output` field is missing in animation.sampler\n"; + } + return false; + } + sampler.input = static_cast(inputIndex); + sampler.output = static_cast(outputIndex); + animation->samplers.push_back(sampler); + } + } + } + + ParseStringProperty(&animation->name, err, o, "name", false); + + ParseExtrasProperty(&(animation->extras), o); + + return true; +} + +static bool ParseSampler(Sampler *sampler, std::string *err, const json &o) { + ParseStringProperty(&sampler->name, err, o, "name", false); + + double minFilter = + static_cast(TINYGLTF_TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR); + double magFilter = static_cast(TINYGLTF_TEXTURE_FILTER_LINEAR); + double wrapS = static_cast(TINYGLTF_TEXTURE_WRAP_REPEAT); + double wrapT = static_cast(TINYGLTF_TEXTURE_WRAP_REPEAT); + ParseNumberProperty(&minFilter, err, o, "minFilter", false); + ParseNumberProperty(&magFilter, err, o, "magFilter", false); + ParseNumberProperty(&wrapS, err, o, "wrapS", false); + ParseNumberProperty(&wrapT, err, o, "wrapT", false); + + sampler->minFilter = static_cast(minFilter); + sampler->magFilter = static_cast(magFilter); + sampler->wrapS = static_cast(wrapS); + sampler->wrapT = static_cast(wrapT); + + ParseExtrasProperty(&(sampler->extras), o); + + return true; +} + +static bool ParseSkin(Skin *skin, std::string *err, const json &o) { + ParseStringProperty(&skin->name, err, o, "name", false, "Skin"); + + std::vector joints; + if (!ParseNumberArrayProperty(&joints, err, o, "joints", false, "Skin")) { + return false; + } + + double skeleton = -1.0; + ParseNumberProperty(&skeleton, err, o, "skeleton", false, "Skin"); + skin->skeleton = static_cast(skeleton); + + skin->joints.resize(joints.size()); + for (size_t i = 0; i < joints.size(); i++) { + skin->joints[i] = static_cast(joints[i]); + } + + double invBind = -1.0; + ParseNumberProperty(&invBind, err, o, "inverseBindMatrices", true, "Skin"); + skin->inverseBindMatrices = static_cast(invBind); + + return true; +} + +static bool ParsePerspectiveCamera(PerspectiveCamera *camera, std::string *err, + const json &o) { + double yfov = 0.0; + if (!ParseNumberProperty(&yfov, err, o, "yfov", true, "OrthographicCamera")) { + return false; + } + + double znear = 0.0; + if (!ParseNumberProperty(&znear, err, o, "znear", true, + "PerspectiveCamera")) { + return false; + } + + double aspectRatio = 0.0; // = invalid + ParseNumberProperty(&aspectRatio, err, o, "aspectRatio", false, + "PerspectiveCamera"); + + double zfar = 0.0; // = invalid + ParseNumberProperty(&zfar, err, o, "zfar", false, "PerspectiveCamera"); + + camera->aspectRatio = float(aspectRatio); + camera->zfar = float(zfar); + camera->yfov = float(yfov); + camera->znear = float(znear); + + ParseExtrasProperty(&(camera->extras), o); + + // TODO(syoyo): Validate parameter values. + + return true; +} + +static bool ParseOrthographicCamera(OrthographicCamera *camera, + std::string *err, const json &o) { + double xmag = 0.0; + if (!ParseNumberProperty(&xmag, err, o, "xmag", true, "OrthographicCamera")) { + return false; + } + + double ymag = 0.0; + if (!ParseNumberProperty(&ymag, err, o, "ymag", true, "OrthographicCamera")) { + return false; + } + + double zfar = 0.0; + if (!ParseNumberProperty(&zfar, err, o, "zfar", true, "OrthographicCamera")) { + return false; + } + + double znear = 0.0; + if (!ParseNumberProperty(&znear, err, o, "znear", true, + "OrthographicCamera")) { + return false; + } + + ParseExtrasProperty(&(camera->extras), o); + + camera->xmag = float(xmag); + camera->ymag = float(ymag); + camera->zfar = float(zfar); + camera->znear = float(znear); + + // TODO(syoyo): Validate parameter values. + + return true; +} + +static bool ParseCamera(Camera *camera, std::string *err, const json &o) { + if (!ParseStringProperty(&camera->type, err, o, "type", true, "Camera")) { + return false; + } + + if (camera->type.compare("orthographic") == 0) { + if (o.find("orthographic") == o.end()) { + if (err) { + std::stringstream ss; + ss << "Orhographic camera description not found." << std::endl; + (*err) += ss.str(); + } + return false; + } + + const json &v = o.find("orthographic").value(); + if (!v.is_object()) { + if (err) { + std::stringstream ss; + ss << "\"orthographic\" is not a JSON object." << std::endl; + (*err) += ss.str(); + } + return false; + } + + if (!ParseOrthographicCamera(&camera->orthographic, err, v.get())) { + return false; + } + } else if (camera->type.compare("perspective") == 0) { + if (o.find("perspective") == o.end()) { + if (err) { + std::stringstream ss; + ss << "Perspective camera description not found." << std::endl; + (*err) += ss.str(); + } + return false; + } + + const json &v = o.find("perspective").value(); + if (!v.is_object()) { + if (err) { + std::stringstream ss; + ss << "\"perspective\" is not a JSON object." << std::endl; + (*err) += ss.str(); + } + return false; + } + + if (!ParsePerspectiveCamera(&camera->perspective, err, v.get())) { + return false; + } + } else { + if (err) { + std::stringstream ss; + ss << "Invalid camera type: \"" << camera->type + << "\". Must be \"perspective\" or \"orthographic\"" << std::endl; + (*err) += ss.str(); + } + return false; + } + + ParseStringProperty(&camera->name, err, o, "name", false); + + ParseExtrasProperty(&(camera->extras), o); + + return true; +} + +bool TinyGLTF::LoadFromString(Model *model, std::string *err, const char *str, + unsigned int length, const std::string &base_dir, + unsigned int check_sections) { + if (length < 4) { + if (err) { + (*err) = "JSON string too short.\n"; + } + return false; + } + + json v; + +#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || \ + defined(_CPPUNWIND)) && \ + not defined(TINYGLTF_NOEXCEPTION) + try { + v = json::parse(str, str + length); + + } catch (const std::exception &e) { + if (err) { + (*err) = e.what(); + } + return false; + } +#else + { + v = json::parse(str, str + length, nullptr, /* exception */ false); + + if (!v.is_object()) { + // Assume parsing was failed. + if (err) { + (*err) = "Failed to parse JSON object\n"; + } + return false; + } + } +#endif + + if (!v.is_object()) { + // root is not an object. + if (err) { + (*err) = "Root element is not a JSON object\n"; + } + return false; + } + + // scene is not mandatory. + // FIXME Maybe a better way to handle it than removing the code + + { + json::const_iterator it = v.find("scenes"); + if ((it != v.end()) && it.value().is_array()) { + // OK + } else if (check_sections & REQUIRE_SCENES) { + if (err) { + (*err) += "\"scenes\" object not found in .gltf or not an array type\n"; + } + return false; + } + } + + { + json::const_iterator it = v.find("nodes"); + if ((it != v.end()) && it.value().is_array()) { + // OK + } else if (check_sections & REQUIRE_NODES) { + if (err) { + (*err) += "\"nodes\" object not found in .gltf\n"; + } + return false; + } + } + + { + json::const_iterator it = v.find("accessors"); + if ((it != v.end()) && it.value().is_array()) { + // OK + } else if (check_sections & REQUIRE_ACCESSORS) { + if (err) { + (*err) += "\"accessors\" object not found in .gltf\n"; + } + return false; + } + } + + { + json::const_iterator it = v.find("buffers"); + if ((it != v.end()) && it.value().is_array()) { + // OK + } else if (check_sections & REQUIRE_BUFFERS) { + if (err) { + (*err) += "\"buffers\" object not found in .gltf\n"; + } + return false; + } + } + + { + json::const_iterator it = v.find("bufferViews"); + if ((it != v.end()) && it.value().is_array()) { + // OK + } else if (check_sections & REQUIRE_BUFFER_VIEWS) { + if (err) { + (*err) += "\"bufferViews\" object not found in .gltf\n"; + } + return false; + } + } + + model->buffers.clear(); + model->bufferViews.clear(); + model->accessors.clear(); + model->meshes.clear(); + model->cameras.clear(); + model->nodes.clear(); + model->extensionsUsed.clear(); + model->extensionsRequired.clear(); + model->defaultScene = -1; + + // 1. Parse Asset + { + json::const_iterator it = v.find("asset"); + if ((it != v.end()) && it.value().is_object()) { + const json &root = it.value(); + + ParseAsset(&model->asset, err, root); + } + } + + // 2. Parse extensionUsed + { + json::const_iterator it = v.find("extensionsUsed"); + if ((it != v.end()) && it.value().is_array()) { + const json &root = it.value(); + for (unsigned int i = 0; i < root.size(); ++i) { + model->extensionsUsed.push_back(root[i].get()); + } + } + } + + { + json::const_iterator it = v.find("extensionsRequired"); + if ((it != v.end()) && it.value().is_array()) { + const json &root = it.value(); + for (unsigned int i = 0; i < root.size(); ++i) { + model->extensionsRequired.push_back(root[i].get()); + } + } + } + + // 3. Parse Buffer + { + json::const_iterator rootIt = v.find("buffers"); + if ((rootIt != v.end()) && rootIt.value().is_array()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; it++) { + if (!it.value().is_object()) { + if (err) { + (*err) += "`buffers' does not contain an JSON object."; + } + return false; + } + Buffer buffer; + if (!ParseBuffer(&buffer, err, it->get(), base_dir, is_binary_, + bin_data_, bin_size_)) { + return false; + } + + model->buffers.push_back(buffer); + } + } + } + + // 4. Parse BufferView + { + json::const_iterator rootIt = v.find("bufferViews"); + if ((rootIt != v.end()) && rootIt.value().is_array()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; it++) { + if (!it.value().is_object()) { + if (err) { + (*err) += "`bufferViews' does not contain an JSON object."; + } + return false; + } + BufferView bufferView; + if (!ParseBufferView(&bufferView, err, it->get())) { + return false; + } + + model->bufferViews.push_back(bufferView); + } + } + } + + // 5. Parse Accessor + { + json::const_iterator rootIt = v.find("accessors"); + if ((rootIt != v.end()) && rootIt.value().is_array()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; it++) { + if (!it.value().is_object()) { + if (err) { + (*err) += "`accessors' does not contain an JSON object."; + } + return false; + } + Accessor accessor; + if (!ParseAccessor(&accessor, err, it->get())) { + return false; + } + + model->accessors.push_back(accessor); + } + } + } + + // 6. Parse Mesh + { + json::const_iterator rootIt = v.find("meshes"); + if ((rootIt != v.end()) && rootIt.value().is_array()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; it++) { + if (!it.value().is_object()) { + if (err) { + (*err) += "`meshes' does not contain an JSON object."; + } + return false; + } + Mesh mesh; + if (!ParseMesh(&mesh, err, it->get())) { + return false; + } + + model->meshes.push_back(mesh); + } + } + } + + // 7. Parse Node + { + json::const_iterator rootIt = v.find("nodes"); + if ((rootIt != v.end()) && rootIt.value().is_array()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; it++) { + if (!it.value().is_object()) { + if (err) { + (*err) += "`nodes' does not contain an JSON object."; + } + return false; + } + Node node; + if (!ParseNode(&node, err, it->get())) { + return false; + } + + model->nodes.push_back(node); + } + } + } + + // 8. Parse scenes. + { + json::const_iterator rootIt = v.find("scenes"); + if ((rootIt != v.end()) && rootIt.value().is_array()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; it++) { + if (!(it.value().is_object())) { + if (err) { + (*err) += "`scenes' does not contain an JSON object."; + } + return false; + } + const json &o = it->get(); + std::vector nodes; + if (!ParseNumberArrayProperty(&nodes, err, o, "nodes", false)) { + return false; + } + + Scene scene; + ParseStringProperty(&scene.name, err, o, "name", false); + std::vector nodesIds; + for (size_t i = 0; i < nodes.size(); i++) { + nodesIds.push_back(static_cast(nodes[i])); + } + scene.nodes = nodesIds; + + model->scenes.push_back(scene); + } + } + } + + // 9. Parse default scenes. + { + json::const_iterator rootIt = v.find("scene"); + if ((rootIt != v.end()) && rootIt.value().is_number()) { + const int defaultScene = rootIt.value(); + + model->defaultScene = static_cast(defaultScene); + } + } + + // 10. Parse Material + { + json::const_iterator rootIt = v.find("materials"); + if ((rootIt != v.end()) && rootIt.value().is_array()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; it++) { + if (!it.value().is_object()) { + if (err) { + (*err) += "`materials' does not contain an JSON object."; + } + return false; + } + json jsonMaterial = it->get(); + + Material material; + ParseStringProperty(&material.name, err, jsonMaterial, "name", false); + + if (!ParseMaterial(&material, err, jsonMaterial)) { + return false; + } + + model->materials.push_back(material); + } + } + } + + // 11. Parse Image + { + json::const_iterator rootIt = v.find("images"); + if ((rootIt != v.end()) && rootIt.value().is_array()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; it++) { + if (!it.value().is_object()) { + if (err) { + (*err) += "`images' does not contain an JSON object."; + } + return false; + } + Image image; + if (!ParseImage(&image, err, it.value(), base_dir, is_binary_, + bin_data_, bin_size_, &this->LoadImageData, + load_image_user_data_)) { + return false; + } + + if (image.bufferView != -1) { + // Load image from the buffer view. + if (size_t(image.bufferView) >= model->bufferViews.size()) { + if (err) { + std::stringstream ss; + ss << "bufferView \"" << image.bufferView + << "\" not found in the scene." << std::endl; + (*err) += ss.str(); + } + return false; + } + + const BufferView &bufferView = + model->bufferViews[size_t(image.bufferView)]; + const Buffer &buffer = model->buffers[size_t(bufferView.buffer)]; + + if (*LoadImageData == nullptr) { + if (err) { + (*err) += "No LoadImageData callback specified.\n"; + } + return false; + } + bool ret = LoadImageData(&image, err, image.width, image.height, + &buffer.data[bufferView.byteOffset], + static_cast(bufferView.byteLength), + load_image_user_data_); + if (!ret) { + return false; + } + } + + model->images.push_back(image); + } + } + } + + // 12. Parse Texture + { + json::const_iterator rootIt = v.find("textures"); + if ((rootIt != v.end()) && rootIt.value().is_array()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; it++) { + if (!it.value().is_object()) { + if (err) { + (*err) += "`textures' does not contain an JSON object."; + } + return false; + } + Texture texture; + if (!ParseTexture(&texture, err, it->get(), base_dir)) { + return false; + } + + model->textures.push_back(texture); + } + } + } + + // 13. Parse Animation + { + json::const_iterator rootIt = v.find("animations"); + if ((rootIt != v.end()) && rootIt.value().is_array()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; ++it) { + if (!it.value().is_object()) { + if (err) { + (*err) += "`animations' does not contain an JSON object."; + } + return false; + } + Animation animation; + if (!ParseAnimation(&animation, err, it->get())) { + return false; + } + + model->animations.push_back(animation); + } + } + } + + // 14. Parse Skin + { + json::const_iterator rootIt = v.find("skins"); + if ((rootIt != v.end()) && rootIt.value().is_array()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; ++it) { + if (!it.value().is_object()) { + if (err) { + (*err) += "`skins' does not contain an JSON object."; + } + return false; + } + Skin skin; + if (!ParseSkin(&skin, err, it->get())) { + return false; + } + + model->skins.push_back(skin); + } + } + } + + // 15. Parse Sampler + { + json::const_iterator rootIt = v.find("samplers"); + if ((rootIt != v.end()) && rootIt.value().is_array()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; ++it) { + if (!it.value().is_object()) { + if (err) { + (*err) += "`samplers' does not contain an JSON object."; + } + return false; + } + Sampler sampler; + if (!ParseSampler(&sampler, err, it->get())) { + return false; + } + + model->samplers.push_back(sampler); + } + } + } + + // 16. Parse Camera + { + json::const_iterator rootIt = v.find("cameras"); + if ((rootIt != v.end()) && rootIt.value().is_array()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; ++it) { + if (!it.value().is_object()) { + if (err) { + (*err) += "`cameras' does not contain an JSON object."; + } + return false; + } + Camera camera; + if (!ParseCamera(&camera, err, it->get())) { + return false; + } + + model->cameras.push_back(camera); + } + } + } + + // 17. Parse Extensions + { + json::const_iterator rootIt = v.find("extensions"); + if ((rootIt != v.end()) && rootIt.value().is_object()) { + const json &root = rootIt.value(); + + json::const_iterator it(root.begin()); + json::const_iterator itEnd(root.end()); + for (; it != itEnd; ++it) { + // parse KHR_lights_cmn extension + if ((it.key().compare("KHR_lights_cmn") == 0) && + it.value().is_object()) { + const json &object = it.value(); + json::const_iterator itLight(object.find("lights")); + json::const_iterator itLightEnd(object.end()); + if (itLight == itLightEnd) { + continue; + } + + if (!itLight.value().is_array()) { + continue; + } + + const json &lights = itLight.value(); + json::const_iterator arrayIt(lights.begin()); + json::const_iterator arrayItEnd(lights.end()); + for (; arrayIt != arrayItEnd; ++arrayIt) { + Light light; + if (!ParseLight(&light, err, arrayIt.value())) { + return false; + } + model->lights.push_back(light); + } + } + } + } + } + + return true; +} + +bool TinyGLTF::LoadASCIIFromString(Model *model, std::string *err, + const char *str, unsigned int length, + const std::string &base_dir, + unsigned int check_sections) { + is_binary_ = false; + bin_data_ = nullptr; + bin_size_ = 0; + + return LoadFromString(model, err, str, length, base_dir, check_sections); +} + +bool TinyGLTF::LoadASCIIFromFile(Model *model, std::string *err, + const std::string &filename, + unsigned int check_sections) { + std::stringstream ss; + + std::ifstream f(filename.c_str()); + if (!f) { + ss << "Failed to open file: " << filename << std::endl; + if (err) { + (*err) = ss.str(); + } + return false; + } + + f.seekg(0, f.end); + size_t sz = static_cast(f.tellg()); + std::vector buf(sz); + + if (sz == 0) { + if (err) { + (*err) = "Empty file."; + } + return false; + } + + f.seekg(0, f.beg); + f.read(&buf.at(0), static_cast(sz)); + f.close(); + + std::string basedir = GetBaseDir(filename); + + bool ret = LoadASCIIFromString(model, err, &buf.at(0), + static_cast(buf.size()), basedir, + check_sections); + + return ret; +} + +bool TinyGLTF::LoadBinaryFromMemory(Model *model, std::string *err, + const unsigned char *bytes, + unsigned int size, + const std::string &base_dir, + unsigned int check_sections) { + if (size < 20) { + if (err) { + (*err) = "Too short data size for glTF Binary."; + } + return false; + } + + if (bytes[0] == 'g' && bytes[1] == 'l' && bytes[2] == 'T' && + bytes[3] == 'F') { + // ok + } else { + if (err) { + (*err) = "Invalid magic."; + } + return false; + } + + unsigned int version; // 4 bytes + unsigned int length; // 4 bytes + unsigned int model_length; // 4 bytes + unsigned int model_format; // 4 bytes; + + // @todo { Endian swap for big endian machine. } + memcpy(&version, bytes + 4, 4); + swap4(&version); + memcpy(&length, bytes + 8, 4); + swap4(&length); + memcpy(&model_length, bytes + 12, 4); + swap4(&model_length); + memcpy(&model_format, bytes + 16, 4); + swap4(&model_format); + + // In case the Bin buffer is not present, the size is exactly 20 + size of + // JSON contents, + // so use "greater than" operator. + if ((20 + model_length > size) || (model_length < 1) || + (model_format != 0x4E4F534A)) { // 0x4E4F534A = JSON format. + if (err) { + (*err) = "Invalid glTF binary."; + } + return false; + } + + // Extract JSON string. + std::string jsonString(reinterpret_cast(&bytes[20]), + model_length); + + is_binary_ = true; + bin_data_ = bytes + 20 + model_length + + 8; // 4 bytes (buffer_length) + 4 bytes(buffer_format) + bin_size_ = + length - (20 + model_length); // extract header + JSON scene data. + + bool ret = + LoadFromString(model, err, reinterpret_cast(&bytes[20]), + model_length, base_dir, check_sections); + if (!ret) { + return ret; + } + + return true; +} + +bool TinyGLTF::LoadBinaryFromFile(Model *model, std::string *err, + const std::string &filename, + unsigned int check_sections) { + std::stringstream ss; + + std::ifstream f(filename.c_str(), std::ios::binary); + if (!f) { + ss << "Failed to open file: " << filename << std::endl; + if (err) { + (*err) = ss.str(); + } + return false; + } + + f.seekg(0, f.end); + size_t sz = static_cast(f.tellg()); + std::vector buf(sz); + + f.seekg(0, f.beg); + f.read(&buf.at(0), static_cast(sz)); + f.close(); + + std::string basedir = GetBaseDir(filename); + + bool ret = LoadBinaryFromMemory( + model, err, reinterpret_cast(&buf.at(0)), + static_cast(buf.size()), basedir, check_sections); + + return ret; +} + +/////////////////////// +// GLTF Serialization +/////////////////////// + +// typedef std::pair json_object_pair; + +template +static void SerializeNumberProperty(const std::string &key, T number, + json &obj) { + // obj.insert( + // json_object_pair(key, json(static_cast(number)))); + // obj[key] = static_cast(number); + obj[key] = number; +} + +template +static void SerializeNumberArrayProperty(const std::string &key, + const std::vector &value, + json &obj) { + json o; + json vals; + + for (unsigned int i = 0; i < value.size(); ++i) { + vals.push_back(static_cast(value[i])); + } + + obj[key] = vals; +} + +static void SerializeStringProperty(const std::string &key, + const std::string &value, json &obj) { + obj[key] = value; +} + +static void SerializeStringArrayProperty(const std::string &key, + const std::vector &value, + json &obj) { + json o; + json vals; + + for (unsigned int i = 0; i < value.size(); ++i) { + vals.push_back(value[i]); + } + + obj[key] = vals; +} + +static void SerializeValue(const std::string &key, const Value &value, + json &obj) { + if (value.IsArray()) { + json jsonValue; + for (unsigned int i = 0; i < value.ArrayLen(); ++i) { + Value elementValue = value.Get(int(i)); + if (elementValue.IsString()) + jsonValue.push_back(elementValue.Get()); + } + obj[key] = jsonValue; + } else { + json jsonValue; + std::vector valueKeys = value.Keys(); + for (unsigned int i = 0; i < valueKeys.size(); ++i) { + Value elementValue = value.Get(valueKeys[i]); + if (elementValue.IsInt()) + jsonValue[valueKeys[i]] = static_cast(elementValue.Get()); + } + + obj[key] = jsonValue; + } +} + +static void SerializeGltfBufferData(const std::vector &data, + const std::string &binFilename) { + std::ofstream output(binFilename.c_str(), std::ofstream::binary); + output.write(reinterpret_cast(&data[0]), + std::streamsize(data.size())); + output.close(); +} + +static void SerializeParameterMap(ParameterMap ¶m, json &o) { + for (ParameterMap::iterator paramIt = param.begin(); paramIt != param.end(); + ++paramIt) { + if (paramIt->second.number_array.size()) { + SerializeNumberArrayProperty(paramIt->first, + paramIt->second.number_array, o); + } else if (paramIt->second.json_double_value.size()) { + json json_double_value; + + for (std::map::iterator it = + paramIt->second.json_double_value.begin(); + it != paramIt->second.json_double_value.end(); ++it) { + json_double_value[it->first] = it->second; + } + + o[paramIt->first] = json_double_value; + } else if (!paramIt->second.string_value.empty()) { + SerializeStringProperty(paramIt->first, paramIt->second.string_value, o); + } else { + o[paramIt->first] = paramIt->second.bool_value; + } + } +} + +static void SerializeGltfAccessor(Accessor &accessor, json &o) { + SerializeNumberProperty("bufferView", accessor.bufferView, o); + + if (accessor.byteOffset != 0.0) + SerializeNumberProperty("byteOffset", int(accessor.byteOffset), o); + + SerializeNumberProperty("componentType", accessor.componentType, o); + SerializeNumberProperty("count", accessor.count, o); + SerializeNumberArrayProperty("min", accessor.minValues, o); + SerializeNumberArrayProperty("max", accessor.maxValues, o); + std::string type; + switch (accessor.type) { + case TINYGLTF_TYPE_SCALAR: + type = "SCALAR"; + break; + case TINYGLTF_TYPE_VEC2: + type = "VEC2"; + break; + case TINYGLTF_TYPE_VEC3: + type = "VEC3"; + break; + case TINYGLTF_TYPE_VEC4: + type = "VEC4"; + break; + case TINYGLTF_TYPE_MAT2: + type = "MAT2"; + break; + case TINYGLTF_TYPE_MAT3: + type = "MAT3"; + break; + case TINYGLTF_TYPE_MAT4: + type = "MAT4"; + break; + } + + SerializeStringProperty("type", type, o); +} + +static void SerializeGltfAnimationChannel(AnimationChannel &channel, json &o) { + SerializeNumberProperty("sampler", channel.sampler, o); + json target; + SerializeNumberProperty("node", channel.target_node, target); + SerializeStringProperty("path", channel.target_path, target); + + o["target"] = target; +} + +static void SerializeGltfAnimationSampler(AnimationSampler &sampler, json &o) { + SerializeNumberProperty("input", sampler.input, o); + SerializeNumberProperty("output", sampler.output, o); + SerializeStringProperty("interpolation", sampler.interpolation, o); +} + +static void SerializeGltfAnimation(Animation &animation, json &o) { + SerializeStringProperty("name", animation.name, o); + json channels; + for (unsigned int i = 0; i < animation.channels.size(); ++i) { + json channel; + AnimationChannel gltfChannel = animation.channels[i]; + SerializeGltfAnimationChannel(gltfChannel, channel); + channels.push_back(channel); + } + o["channels"] = channels; + + json samplers; + for (unsigned int i = 0; i < animation.samplers.size(); ++i) { + json sampler; + AnimationSampler gltfSampler = animation.samplers[i]; + SerializeGltfAnimationSampler(gltfSampler, sampler); + samplers.push_back(sampler); + } + + o["samplers"] = samplers; +} + +static void SerializeGltfAsset(Asset &asset, json &o) { + if (!asset.generator.empty()) { + SerializeStringProperty("generator", asset.generator, o); + } + + if (!asset.version.empty()) { + SerializeStringProperty("version", asset.version, o); + } + + if (asset.extras.Keys().size()) { + SerializeValue("extras", asset.extras, o); + } +} + +static void SerializeGltfBuffer(Buffer &buffer, json &o, + const std::string &binFilename, + const std::string &binBaseFilename) { + SerializeGltfBufferData(buffer.data, binFilename); + SerializeNumberProperty("byteLength", buffer.data.size(), o); + SerializeStringProperty("uri", binBaseFilename, o); + + if (buffer.name.size()) SerializeStringProperty("name", buffer.name, o); +} + +static void SerializeGltfBufferView(BufferView &bufferView, json &o) { + SerializeNumberProperty("buffer", bufferView.buffer, o); + SerializeNumberProperty("byteLength", bufferView.byteLength, o); + SerializeNumberProperty("byteStride", bufferView.byteStride, o); + SerializeNumberProperty("byteOffset", bufferView.byteOffset, o); + SerializeNumberProperty("target", bufferView.target, o); + + if (bufferView.name.size()) { + SerializeStringProperty("name", bufferView.name, o); + } +} + +// Only external textures are serialized for now +static void SerializeGltfImage(Image &image, json &o) { + SerializeStringProperty("uri", image.uri, o); + + if (image.name.size()) { + SerializeStringProperty("name", image.name, o); + } +} + +static void SerializeGltfMaterial(Material &material, json &o) { + if (material.extPBRValues.size()) { + // Serialize PBR specular/glossiness material + json values; + SerializeParameterMap(material.extPBRValues, values); + + json extension; + o["extensions"] = extension; + } + + if (material.values.size()) { + json pbrMetallicRoughness; + SerializeParameterMap(material.values, pbrMetallicRoughness); + o["pbrMetallicRoughness"] = pbrMetallicRoughness; + } + + json additionalValues; + SerializeParameterMap(material.additionalValues, o); + + if (material.name.size()) { + SerializeStringProperty("name", material.name, o); + } +} + +static void SerializeGltfMesh(Mesh &mesh, json &o) { + json primitives; + for (unsigned int i = 0; i < mesh.primitives.size(); ++i) { + json primitive; + json attributes; + Primitive gltfPrimitive = mesh.primitives[i]; + for (std::map::iterator attrIt = + gltfPrimitive.attributes.begin(); + attrIt != gltfPrimitive.attributes.end(); ++attrIt) { + SerializeNumberProperty(attrIt->first, attrIt->second, attributes); + } + + primitive["attributes"] = attributes; + SerializeNumberProperty("indices", gltfPrimitive.indices, primitive); + SerializeNumberProperty("material", gltfPrimitive.material, primitive); + SerializeNumberProperty("mode", gltfPrimitive.mode, primitive); + + // Morph targets + if (gltfPrimitive.targets.size()) { + json targets; + for (unsigned int k = 0; k < gltfPrimitive.targets.size(); ++k) { + json targetAttributes; + std::map targetData = gltfPrimitive.targets[k]; + for (std::map::iterator attrIt = targetData.begin(); + attrIt != targetData.end(); ++attrIt) { + SerializeNumberProperty(attrIt->first, attrIt->second, + targetAttributes); + } + + targets.push_back(targetAttributes); + } + primitive["targets"] = targets; + } + + primitives.push_back(primitive); + } + + o["primitives"] = primitives; + if (mesh.weights.size()) { + SerializeNumberArrayProperty("weights", mesh.weights, o); + } + + if (mesh.name.size()) { + SerializeStringProperty("name", mesh.name, o); + } +} + +static void SerializeGltfLight(Light &light, json &o) { + SerializeStringProperty("name", light.name, o); + SerializeNumberArrayProperty("color", light.color, o); + SerializeStringProperty("type", light.type, o); +} + +static void SerializeGltfNode(Node &node, json &o) { + if (node.translation.size() > 0) { + SerializeNumberArrayProperty("translation", node.translation, o); + } + if (node.rotation.size() > 0) { + SerializeNumberArrayProperty("rotation", node.rotation, o); + } + if (node.scale.size() > 0) { + SerializeNumberArrayProperty("scale", node.scale, o); + } + if (node.matrix.size() > 0) { + SerializeNumberArrayProperty("matrix", node.matrix, o); + } + if (node.mesh != -1) { + SerializeNumberProperty("mesh", node.mesh, o); + } + + if (node.skin != -1) { + SerializeNumberProperty("skin", node.skin, o); + } + + if (node.camera != -1) { + SerializeNumberProperty("camera", node.camera, o); + } + + if (node.extLightsValues.size()) { + json values; + SerializeParameterMap(node.extLightsValues, values); + json lightsExt; + lightsExt["KHR_lights_cmn"] = values; + o["extensions"] = lightsExt; + } + + SerializeStringProperty("name", node.name, o); + SerializeNumberArrayProperty("children", node.children, o); +} + +static void SerializeGltfSampler(Sampler &sampler, json &o) { + SerializeNumberProperty("magFilter", sampler.magFilter, o); + SerializeNumberProperty("minFilter", sampler.minFilter, o); + SerializeNumberProperty("wrapS", sampler.wrapS, o); + SerializeNumberProperty("wrapT", sampler.wrapT, o); +} + +static void SerializeGltfOrthographicCamera(const OrthographicCamera &camera, + json &o) { + SerializeNumberProperty("zfar", camera.zfar, o); + SerializeNumberProperty("znear", camera.znear, o); + SerializeNumberProperty("xmag", camera.xmag, o); + SerializeNumberProperty("ymag", camera.ymag, o); +} + +static void SerializeGltfPerspectiveCamera(const PerspectiveCamera &camera, + json &o) { + SerializeNumberProperty("zfar", camera.zfar, o); + SerializeNumberProperty("znear", camera.znear, o); + if (camera.aspectRatio > 0) { + SerializeNumberProperty("aspectRatio", camera.aspectRatio, o); + } + + if (camera.yfov > 0) { + SerializeNumberProperty("yfov", camera.yfov, o); + } +} + +static void SerializeGltfCamera(const Camera &camera, json &o) { + SerializeStringProperty("type", camera.type, o); + if (!camera.name.empty()) { + SerializeStringProperty("name", camera.type, o); + } + + if (camera.type.compare("orthographic") == 0) { + json orthographic; + SerializeGltfOrthographicCamera(camera.orthographic, orthographic); + o["orthographic"] = orthographic; + } else if (camera.type.compare("perspective") == 0) { + json perspective; + SerializeGltfPerspectiveCamera(camera.perspective, perspective); + o["perspective"] = perspective; + } else { + // ??? + } +} + +static void SerializeGltfScene(Scene &scene, json &o) { + SerializeNumberArrayProperty("nodes", scene.nodes, o); + + if (scene.name.size()) { + SerializeStringProperty("name", scene.name, o); + } +} + +static void SerializeGltfSkin(Skin &skin, json &o) { + if (skin.inverseBindMatrices != -1) + SerializeNumberProperty("inverseBindMatrices", skin.inverseBindMatrices, o); + + SerializeNumberArrayProperty("joints", skin.joints, o); + SerializeNumberProperty("skeleton", skin.skeleton, o); + if (skin.name.size()) { + SerializeStringProperty("name", skin.name, o); + } +} + +static void SerializeGltfTexture(Texture &texture, json &o) { + SerializeNumberProperty("sampler", texture.sampler, o); + SerializeNumberProperty("source", texture.source, o); + + if (texture.extras.Size()) { + json extras; + SerializeValue("extras", texture.extras, o); + o["extras"] = extras; + } +} + +static void WriteGltfFile(const std::string &output, + const std::string &content) { + std::ofstream gltfFile(output.c_str()); + gltfFile << content << std::endl; +} + +bool TinyGLTF::WriteGltfSceneToFile( + Model *model, + const std::string + &filename /*, bool embedImages, bool embedBuffers, bool writeBinary*/) { + json output; + + // ACCESSORS + json accessors; + for (unsigned int i = 0; i < model->accessors.size(); ++i) { + json accessor; + SerializeGltfAccessor(model->accessors[i], accessor); + accessors.push_back(accessor); + } + output["accessors"] = accessors; + + // ANIMATIONS + if (model->animations.size()) { + json animations; + for (unsigned int i = 0; i < model->animations.size(); ++i) { + if (model->animations[i].channels.size()) { + json animation; + SerializeGltfAnimation(model->animations[i], animation); + animations.push_back(animation); + } + } + output["animations"] = animations; + } + + // ASSET + json asset; + SerializeGltfAsset(model->asset, asset); + output["asset"] = asset; + + std::string binFilename = GetBaseFilename(filename); + std::string ext = ".bin"; + std::string::size_type pos = binFilename.rfind('.', binFilename.length()); + + if (pos != std::string::npos) { + binFilename = binFilename.substr(0, pos) + ext; + } else { + binFilename = binFilename + ".bin"; + } + std::string binSaveFilePath = GetBaseDir(filename); + if (binSaveFilePath.empty()) { + binSaveFilePath = "./"; + } + + binSaveFilePath = JoinPath(binSaveFilePath, binFilename); + + // BUFFERS (We expect only one buffer here) + json buffers; + for (unsigned int i = 0; i < model->buffers.size(); ++i) { + json buffer; + SerializeGltfBuffer(model->buffers[i], buffer, binSaveFilePath, + binFilename); + buffers.push_back(buffer); + } + output["buffers"] = buffers; + + // BUFFERVIEWS + json bufferViews; + for (unsigned int i = 0; i < model->bufferViews.size(); ++i) { + json bufferView; + SerializeGltfBufferView(model->bufferViews[i], bufferView); + bufferViews.push_back(bufferView); + } + output["bufferViews"] = bufferViews; + + // Extensions used + if (model->extensionsUsed.size()) { + SerializeStringArrayProperty("extensionsUsed", model->extensionsUsed, + output); + } + + // Extensions required + if (model->extensionsRequired.size()) { + SerializeStringArrayProperty("extensionsRequired", + model->extensionsRequired, output); + } + + // IMAGES + json images; + for (unsigned int i = 0; i < model->images.size(); ++i) { + json image; + SerializeGltfImage(model->images[i], image); + images.push_back(image); + } + output["images"] = images; + + // MATERIALS + json materials; + for (unsigned int i = 0; i < model->materials.size(); ++i) { + json material; + SerializeGltfMaterial(model->materials[i], material); + materials.push_back(material); + } + output["materials"] = materials; + + // MESHES + json meshes; + for (unsigned int i = 0; i < model->meshes.size(); ++i) { + json mesh; + SerializeGltfMesh(model->meshes[i], mesh); + meshes.push_back(mesh); + } + output["meshes"] = meshes; + + // NODES + json nodes; + for (unsigned int i = 0; i < model->nodes.size(); ++i) { + json node; + SerializeGltfNode(model->nodes[i], node); + nodes.push_back(node); + } + output["nodes"] = nodes; + + // SCENE + SerializeNumberProperty("scene", model->defaultScene, output); + + // SCENES + json scenes; + for (unsigned int i = 0; i < model->scenes.size(); ++i) { + json currentScene; + SerializeGltfScene(model->scenes[i], currentScene); + scenes.push_back(currentScene); + } + output["scenes"] = scenes; + + // SKINS + if (model->skins.size()) { + json skins; + for (unsigned int i = 0; i < model->skins.size(); ++i) { + json skin; + SerializeGltfSkin(model->skins[i], skin); + skins.push_back(skin); + } + output["skins"] = skins; + } + + // TEXTURES + json textures; + for (unsigned int i = 0; i < model->textures.size(); ++i) { + json texture; + SerializeGltfTexture(model->textures[i], texture); + textures.push_back(texture); + } + output["textures"] = textures; + + // SAMPLERS + json samplers; + for (unsigned int i = 0; i < model->samplers.size(); ++i) { + json sampler; + SerializeGltfSampler(model->samplers[i], sampler); + samplers.push_back(sampler); + } + output["samplers"] = samplers; + + // CAMERAS + json cameras; + for (unsigned int i = 0; i < model->cameras.size(); ++i) { + json camera; + SerializeGltfCamera(model->cameras[i], camera); + cameras.push_back(camera); + } + output["cameras"] = cameras; + + // LIGHTS + json lights; + for (unsigned int i = 0; i < model->lights.size(); ++i) { + json light; + SerializeGltfLight(model->lights[i], light); + lights.push_back(light); + } + output["lights"] = lights; + + WriteGltfFile(filename, output.dump()); + return true; +} + +} // namespace tinygltf + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#endif // TINYGLTF_IMPLEMENTATION diff --git a/3rdparty/tinygltf/vcsetup.bat b/3rdparty/tinygltf/vcsetup.bat new file mode 100644 index 0000000..b7aaefa --- /dev/null +++ b/3rdparty/tinygltf/vcsetup.bat @@ -0,0 +1 @@ +.\\tools\\windows\\premake5.exe vs2015

;L>CQ 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�gJBLoIumiG%@$cC$*aGinDEx6;vsTTpMXXvG@E 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ⅆ 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