[med-svn] [pbcopper] 01/03: Imported Upstream version 0.0.1+20161202+ds
Afif Elghraoui
afif at moszumanska.debian.org
Wed Dec 14 10:25:06 UTC 2016
This is an automated email from the git hooks/post-receive script.
afif pushed a commit to branch master
in repository pbcopper.
commit e0fbbf231c8dea0f0d979e6a0810070fa4feec5c
Author: Afif Elghraoui <afif at ghraoui.name>
Date: Tue Dec 13 00:21:30 2016 -0800
Imported Upstream version 0.0.1+20161202+ds
---
.gitignore | 78 +
CHANGELOG.md | 51 +
CMakeLists.txt | 62 +
LICENSE.txt | 34 +
README.md | 68 +
build.sh | 21 +
circle.yml | 24 +
cmake/pbcopper-ccache.cmake | 8 +
cmake/pbcopper-compilerflags.cmake | 16 +
cmake/pbcopper-dependencies.cmake | 4 +
cmake/pbcopper-gitsha1.cmake | 20 +
cmake/pbcopper-libtype.cmake | 11 +
docs/CMakeLists.txt | 19 +
examples/CMakeLists.txt | 8 +
examples/cli_demo/CMakeLists.txt | 19 +
examples/cli_demo/main.cpp | 105 +
include/pbcopper/Config.h | 22 +
include/pbcopper/cli/CLI.h | 97 +
include/pbcopper/cli/HelpPrinter.h | 28 +
include/pbcopper/cli/Interface.h | 288 +
include/pbcopper/cli/Option.h | 224 +
include/pbcopper/cli/Parser.h | 65 +
include/pbcopper/cli/PositionalArg.h | 22 +
include/pbcopper/cli/Results.h | 213 +
include/pbcopper/cli/SingleDashMode.h | 19 +
include/pbcopper/cli/VersionPrinter.h | 25 +
include/pbcopper/cli/internal/Option-inl.h | 139 +
include/pbcopper/cli/internal/Results-inl.h | 25 +
include/pbcopper/cli/toolcontract/Config.h | 87 +
include/pbcopper/cli/toolcontract/Driver.h | 116 +
include/pbcopper/cli/toolcontract/InputFileType.h | 40 +
include/pbcopper/cli/toolcontract/JsonPrinter.h | 38 +
include/pbcopper/cli/toolcontract/OutputFileType.h | 43 +
.../cli/toolcontract/ResolvedToolContract.h | 31 +
include/pbcopper/cli/toolcontract/ResourceType.h | 20 +
include/pbcopper/cli/toolcontract/Task.h | 270 +
include/pbcopper/cli/toolcontract/TaskType.h | 19 +
.../cli/toolcontract/internal/Config-inl.h | 36 +
.../cli/toolcontract/internal/Driver-inl.h | 46 +
.../cli/toolcontract/internal/InputFileType-inl.h | 37 +
.../cli/toolcontract/internal/OutputFileType-inl.h | 42 +
.../pbcopper/cli/toolcontract/internal/Task-inl.h | 87 +
include/pbcopper/data/CCSTag.h | 14 +
include/pbcopper/data/Interval.h | 115 +
include/pbcopper/data/MovieName.h | 85 +
include/pbcopper/data/Position.h | 16 +
include/pbcopper/data/RSMovieName.h | 93 +
include/pbcopper/data/RSReadName.h | 16 +
include/pbcopper/data/ReadName.h | 16 +
include/pbcopper/data/Zmw.h | 14 +
include/pbcopper/data/internal/Interval-inl.h | 87 +
include/pbcopper/data/internal/MovieName-inl.h | 111 +
include/pbcopper/data/internal/RSMovieName-inl.h | 144 +
include/pbcopper/data/internal/ReadNameBase-inl.h | 252 +
include/pbcopper/data/internal/ReadNameBase.h | 103 +
include/pbcopper/json/JSON.h | 22 +
include/pbcopper/json/internal/json.hpp | 10182 +++++++++++++++++++
include/pbcopper/logging/Logging.h | 156 +
include/pbcopper/logging/internal/Logging-inl.h | 86 +
include/pbcopper/stream/Stream.h | 190 +
include/pbcopper/utility/CallbackTimer.h | 62 +
include/pbcopper/utility/EnumClassHash.h | 36 +
include/pbcopper/utility/Stopwatch.h | 51 +
include/pbcopper/utility/StringUtils.h | 24 +
include/pbcopper/utility/SystemInfo.h | 29 +
include/pbcopper/utility/Version.h.in | 57 +
.../pbcopper/utility/internal/CallbackTimer-inl.h | 198 +
include/pbcopper/utility/internal/Stopwatch-inl.h | 39 +
.../pbcopper/utility/internal/StringUtils-inl.h | 51 +
include/pbcopper/utility/internal/SystemInfo-inl.h | 54 +
src/CMakeLists.txt | 54 +
src/cli/CLI.cpp | 95 +
src/cli/HelpPrinter.cpp | 209 +
src/cli/Interface.cpp | 273 +
src/cli/Option.cpp | 50 +
src/cli/Parser.cpp | 200 +
src/cli/Results.cpp | 197 +
src/cli/VersionPrinter.cpp | 12 +
src/cli/toolcontract/JsonPrinter.cpp | 242 +
src/cli/toolcontract/ResolvedToolContract.cpp | 107 +
src/data/MovieName.cpp | 51 +
src/data/RSMovieName.cpp | 79 +
src/files.cmake | 143 +
src/logging/Logging.cpp | 235 +
src/utility/CallbackTimer.cpp | 138 +
tests/CMakeLists.txt | 64 +
tests/files.cmake | 44 +
tests/include/OStreamRedirector.h | 51 +
tests/src/cli/test_CLI.cpp | 433 +
tests/src/cli/test_HelpPrinter.cpp | 59 +
tests/src/cli/test_Interface.cpp | 195 +
tests/src/cli/test_Option.cpp | 162 +
tests/src/cli/test_ResolvedToolContract.cpp | 164 +
tests/src/cli/test_Results.cpp | 74 +
tests/src/cli/test_ToolContractJsonPrinter.cpp | 229 +
tests/src/cli/test_VersionPrinter.cpp | 19 +
tests/src/data/test_Interval.cpp | 199 +
tests/src/data/test_MovieName.cpp | 153 +
tests/src/data/test_RSMovieName.cpp | 217 +
tests/src/data/test_RSReadName.cpp | 188 +
tests/src/data/test_ReadName.cpp | 187 +
tests/src/json/test_JSON.cpp | 15 +
tests/src/logging/test_Logging.cpp | 60 +
tests/src/stream/test_Stream.cpp | 319 +
tests/src/utility/test_CallbackTimer.cpp | 97 +
tests/src/utility/test_Stopwatch.cpp | 67 +
tests/src/utility/test_SystemInfo.cpp | 34 +
107 files changed, 20045 insertions(+)
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ba56545
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,78 @@
+# This file is used to ignore files which are generated
+# ----------------------------------------------------------------------------
+
+*~
+*.autosave
+*.a
+*.core
+*.moc
+*.o
+*.obj
+*.orig
+*.rej
+*.so
+*.so.*
+*_pch.h.cpp
+*_resource.rc
+*.qm
+.#*
+*.*#
+core
+!core/
+tags
+.DS_Store
+.directory
+*.debug
+Makefile*
+*.prl
+*.app
+moc_*.cpp
+ui_*.h
+qrc_*.cpp
+Thumbs.db
+*.res
+*.rc
+/.qmake.cache
+/.qmake.stash
+
+# qtcreator generated files
+*.pro.user*
+CMakeLists.txt.user
+
+# xemacs temporary files
+*.flc
+
+# Vim temporary files
+.*.swp
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.pdb
+*.sln
+*.suo
+*.vcproj
+*vcproj.*.*.user
+*.ncb
+*.sdf
+*.opensdf
+*.vcxproj
+*vcxproj.*
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# Python byte code
+*.pyc
+
+# Binaries
+# --------
+*.dll
+*.exe
+
+# Generated directories
+bin
+build
+lib
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..14575ba
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,51 @@
+# pbcopper - CHANGELOG
+
+## Active
+
+### TODO
+- Interface groups
+- Initial sequence-related data structures
+
+### Added
+- Encapsulate project version and git sha1
+- RSMovieName & RSReadName: Sequel and RSII movie names are composed of
+different data, and thus need to be handled separately. MovieName & ReadName
+handle Sequel-style data as the default.
+- GoogleTest/GoogleMock in third-party/googletest
+- Access to input command line from PacBio::CLI::Results
+
+## [0.0.1] - 2016-06-22
+
+### Added
+- **PacBio::CLI** : command-line parsing & tool-contract integration
+ - CLI - entry-point methods for parsing args & invoking application callback
+ - Interface - define application's options, description, etc.
+ - Results - contains the results of arg parsing (or resolved tool contract),
+ will be passed to the application callback
+ - ToolContract sub-namespace: contains all APIs for setting up tool contract
+ integration
+- **PacBio::Data**: main data types & data structures
+ - Interval, Position, Zmw - basic data types (same as pbbam)
+ - MovieName - query parts of a PacBio movie name
+ - ReadName - query parts of a PacBio read name
+- **PacBio::JSON** : JSON support
+ - Json - wrapper around nlohmann::json
+- **PacBio::Logging** : logging utilities
+ - Logger, LogMessage, etc - basic logging (same as pbccs)
+- **PacBio::Stream** : functional-programming-like data streaming
+ - data Source, Sink, & Transform typedefs
+ - instantiated with client-defined 'callables' (lambdas, free functions,
+ static public member functions)
+ - connected via operator >>
+- **PacBio::Utility** : miscellaneous utilities
+ - CallbackTimer - schedule periodic callback invokation (or delayed
+ single-shot)
+ - EnumClassHash - allows enums/enum classes to be used as STL hash keys
+ - Stopwatch - timer for benchmarking, logging, etc
+ - StringUtils - string dicing & splicing utilities
+ - SystemInfo - currently provides endianness
+- Examples
+ - cli_demo - playground for testing the command line interface
+- Tests
+ - Unit tests for all classes/modules added
+
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..4d5662e
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,62 @@
+########################################################################
+# CMake build script for PacBio pbcopper library.
+########################################################################
+cmake_policy(SET CMP0048 NEW) # lets us set version in project()
+cmake_minimum_required(VERSION 3.0)
+
+project(pbcopper VERSION 0.0.1 LANGUAGES CXX C)
+enable_testing()
+
+# project options
+option(pbcopper_build_shared "Build pbcopper as a shared library." OFF)
+option(pbcopper_use_ccache "Build pbcopper using ccache, if available." ON)
+option(pbcopper_build_tests "Build pbcopper tests." ON)
+option(pbcopper_build_docs "Build pbcopper docs." ON)
+option(pbcopper_build_examples "Build pbcopper examples." ON)
+
+# project paths
+set(pbcopper_RootDir ${CMAKE_CURRENT_LIST_DIR})
+set(pbcopper_DocsDir ${pbcopper_RootDir}/docs)
+set(pbcopper_IncludeDir ${pbcopper_RootDir}/include)
+set(pbcopper_SourceDir ${pbcopper_RootDir}/src)
+set(pbcopper_TestsDir ${pbcopper_RootDir}/tests)
+set(pbcopper_ThirdPartyDir ${pbcopper_RootDir}/third-party)
+
+if(NOT pbcopper_OutputDir)
+ set(pbcopper_OutputDir ${CMAKE_CURRENT_BINARY_DIR})
+endif()
+
+set(pbcopper_LibDir ${pbcopper_OutputDir}/lib)
+file(MAKE_DIRECTORY ${pbcopper_LibDir})
+
+# project configuration
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/cmake ${CMAKE_MODULE_PATH})
+include(pbcopper-compilerflags)
+include(pbcopper-ccache)
+include(pbcopper-dependencies)
+include(pbcopper-libtype)
+
+# config generation
+include(pbcopper-gitsha1)
+find_git_sha1(COPPER_GIT_SHA1)
+configure_file(
+ ${pbcopper_IncludeDir}/pbcopper/utility/Version.h.in
+ ${CMAKE_BINARY_DIR}/generated/pbcopper/utility/Version.h
+)
+
+# main library
+add_subdirectory(src)
+
+# project extras - only build on demand
+#
+if (pbcopper_build_docs)
+ add_subdirectory(docs) # build with 'make doc' or 'make docs'
+endif()
+
+if (pbcopper_build_examples)
+ add_subdirectory(examples) # build with 'make examples'
+endif()
+
+if (pbcopper_build_tests)
+ add_subdirectory(tests)
+endif()
diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..0e38eca
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,34 @@
+Copyright (c) 2016, Pacific Biosciences of California, Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted (subject to the limitations in the
+disclaimer below) 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 Pacific Biosciences nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
+GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY PACIFIC
+BIOSCIENCES AND ITS 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 PACIFIC BIOSCIENCES OR ITS
+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.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..7f3077c
--- /dev/null
+++ b/README.md
@@ -0,0 +1,68 @@
+# pbcopper [](https://circleci.com/gh/PacificBiosciences/pbcopper)
+
+The **pbcopper** library provides a suite of data structures, algorithms, and utilities
+for C++ applications.
+
+## Getting Started
+
+Download repo & compile library:
+
+```sh
+git clone https://github.com/PacificBiosciences/pbcopper.git && cd pbcopper
+mkdir build && cd build
+cmake ..
+make
+```
+
+To build & run tests:
+
+```sh
+make check
+```
+
+To build examples:
+
+```sh
+make examples
+```
+
+To build Doxygen API documentation: (**not yet available**)
+
+```sh
+make docs
+```
+
+## API Overview - main modules
+
+- **PacBio::CLI** : command-line parsing & tool-contract integration
+ - CLI - entry-point methods for parsing args & invoking application callback
+ - Interface - define application's options, description, etc.
+ - Results - contains the results of arg parsing (or resolved tool contract), will be passed to the application callback
+ - ToolContract sub-namespace: contains all APIs for setting up tool contract integration
+- **PacBio::Data**: main data types & data structures
+ - Interval, Position, Zmw - basic data types (same as pbbam)
+ - MovieName - query parts of a PacBio movie name
+ - ReadName - query parts of a PacBio read name
+- **PacBio::JSON** : JSON support
+ - Json - wrapper around [nlohmann::json](https://github.com/nlohmann/json)
+- **PacBio::Logging** : logging utilities
+ - Logger, LogMessage, etc - basic logging (same as pbccs)
+- **PacBio::Stream** : functional-programming-like data streaming
+ - data Source, Sink, & Transform typedefs
+ - instantiated with client-defined 'callables' (lambdas, free functions, static public member functions)
+ - connected via operator >>
+- **PacBio::Utility** : miscellaneous utilities
+ - CallbackTimer - schedule periodic callback invokation (or delayed single-shot)
+ - EnumClassHash - allows enums/enum classes to be used as STL hash keys
+ - Stopwatch - timer for benchmarking, logging, etc
+ - StringUtils - string dicing & splicing utilities
+ - SystemInfo - currently provides endianness
+
+## Documentation
+
+ - Main docs coming soon.
+ - [Changelog](https://github.com/PacificBiosciences/pbcopper/blob/master/CHANGELOG.md)
+
+## License
+
+ - [PacBio open source license](https://github.com/PacificBiosciences/pbcopper/blob/master/LICENSE.txt)
diff --git a/build.sh b/build.sh
new file mode 100644
index 0000000..9ee5583
--- /dev/null
+++ b/build.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+echo "# DEPENDENCIES"
+echo "## Load modules"
+source /mnt/software/Modules/current/init/bash
+module load gcc/5.3.0 cmake ccache ninja boost doxygen
+
+echo "# BUILD"
+echo "## Create build directory "
+if [ ! -d build ] ; then mkdir build ; fi
+
+echo "## Build source"
+( cd build &&\
+ rm -rf * &&\
+ CMAKE_BUILD_TYPE=ReleaseWithAssert cmake -GNinja .. )
+
+( cd build && ninja )
+
+echo "# TEST"
+echo "# Run unit tests"
+( cd build && ninja check-xunit )
\ No newline at end of file
diff --git a/circle.yml b/circle.yml
new file mode 100644
index 0000000..62cfa8d
--- /dev/null
+++ b/circle.yml
@@ -0,0 +1,24 @@
+
+machine:
+ pre:
+ - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.9 20
+ - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.9 20
+
+dependencies:
+ cache_directories:
+ - "_deps/cmake-3.3.0-Linux-x86_64"
+ - "_deps/boost_1_55_0"
+ pre:
+ - if [ ! -d _deps ] ; then mkdir _deps ; fi
+ - pushd _deps ; if [ ! -d cmake-3.3.0-Linux-x86_64 ] ; then wget --no-check-certificate http://www.cmake.org/files/v3.3/cmake-3.3.0-Linux-x86_64.tar.gz ; tar xzf cmake-3.3.0-Linux-x86_64.tar.gz ; fi
+ - pushd _deps ; if [ ! -d boost_1_55_0 ] ; then wget https://downloads.sourceforge.net/project/boost/boost/1.55.0/boost_1_55_0.tar.bz2 ; tar xjf boost_1_55_0.tar.bz2 ; fi
+
+test:
+ pre:
+ - mkdir _build
+ - pushd _build ; $(readlink -f ../_deps/cmake-3.3.0-Linux-x86_64/bin/cmake) -DBoost_INCLUDE_DIRS=$(readlink -f ../_deps/boost_1_55_0) ..
+ override:
+ - pushd _build ; make -j 2
+ - pushd _build ; make check-xunit
+ post:
+ - pushd _build ; cp *-unit.xml ${CIRCLE_TEST_REPORTS}/
diff --git a/cmake/pbcopper-ccache.cmake b/cmake/pbcopper-ccache.cmake
new file mode 100644
index 0000000..2204a73
--- /dev/null
+++ b/cmake/pbcopper-ccache.cmake
@@ -0,0 +1,8 @@
+
+if(pbcopper_use_ccache)
+ find_program(CCACHE_FOUND ccache)
+ if(CCACHE_FOUND)
+ set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+ set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+ endif()
+endif()
diff --git a/cmake/pbcopper-compilerflags.cmake b/cmake/pbcopper-compilerflags.cmake
new file mode 100644
index 0000000..00cbfd8
--- /dev/null
+++ b/cmake/pbcopper-compilerflags.cmake
@@ -0,0 +1,16 @@
+
+include(CheckCXXCompilerFlag)
+
+# shared CXX flags for all source code & tests
+if (MSVC)
+ set(pbcopper_CXX_FLAGS "/Wall")
+else()
+ set(pbcopper_CXX_FLAGS "-std=c++11 -Wall")
+endif()
+
+# NOTE: quash clang warnings w/ Boost
+check_cxx_compiler_flag("-Wno-unused-local-typedefs" HAS_NO_UNUSED_LOCAL_TYPEDEFS)
+if(HAS_NO_UNUSED_LOCAL_TYPEDEFS)
+ set(pbcopper_CXX_FLAGS "${pbcopper_CXX_FLAGS} -Wno-unused-local-typedefs")
+endif()
+
diff --git a/cmake/pbcopper-dependencies.cmake b/cmake/pbcopper-dependencies.cmake
new file mode 100644
index 0000000..0aa274b
--- /dev/null
+++ b/cmake/pbcopper-dependencies.cmake
@@ -0,0 +1,4 @@
+
+if(NOT Boost_INCLUDE_DIRS)
+ find_package(Boost REQUIRED)
+endif()
diff --git a/cmake/pbcopper-gitsha1.cmake b/cmake/pbcopper-gitsha1.cmake
new file mode 100644
index 0000000..8a25e7a
--- /dev/null
+++ b/cmake/pbcopper-gitsha1.cmake
@@ -0,0 +1,20 @@
+
+if(__find_git_sha1)
+ return()
+endif()
+set(__find_git_sha1 YES)
+
+function(find_git_sha1 _GIT_SHA1)
+ find_package(Git QUIET REQUIRED)
+ execute_process(COMMAND
+ "${GIT_EXECUTABLE}" "describe" "--always" "--dirty=*"
+ WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+ RESULT_VARIABLE res
+ OUTPUT_VARIABLE out
+ ERROR_QUIET
+ OUTPUT_STRIP_TRAILING_WHITESPACE)
+ if (NOT res EQUAL 0)
+ message(FATAL_ERROR "Could not determine git sha1 via `git describe --always --dirty=*`")
+ endif()
+ set(${_GIT_SHA1} "${out}" PARENT_SCOPE)
+endfunction()
diff --git a/cmake/pbcopper-libtype.cmake b/cmake/pbcopper-libtype.cmake
new file mode 100644
index 0000000..59f52d7
--- /dev/null
+++ b/cmake/pbcopper-libtype.cmake
@@ -0,0 +1,11 @@
+
+if(pbcopper_build_shared)
+ set(BUILD_SHARED_LIBS ON)
+ set(PBCOPPER_LIB_MODE SHARED)
+ set(PBCOPPER_LIB_SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX})
+else()
+ set(BUILD_SHARED_LIBS OFF)
+ set(PBCOPPER_LIB_MODE STATIC)
+ set(PBCOPPER_LIB_SUFFIX ${CMAKE_STATIC_LIBRARY_SUFFIX})
+endif()
+
diff --git a/docs/CMakeLists.txt b/docs/CMakeLists.txt
new file mode 100644
index 0000000..dae8391
--- /dev/null
+++ b/docs/CMakeLists.txt
@@ -0,0 +1,19 @@
+
+find_package(Doxygen)
+
+if (${DOXYGEN_FOUND})
+
+ # add 'make doc' command to generate API docs
+ add_custom_target(docs
+ "echo" "Documentation not available yet. Coming soon"
+ COMMENT "Generating API documentation via Doxygen"
+ )
+
+ # create 'make doc' synonym for 'make docs'
+ add_custom_target(doc DEPENDS docs)
+
+else()
+ message("Doxygen not found. 'make doc' will not be available. Install "
+ "Doxygen and re-run cmake if you would like to be able to build "
+ "API documentation locally.")
+endif()
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
new file mode 100644
index 0000000..83c8558
--- /dev/null
+++ b/examples/CMakeLists.txt
@@ -0,0 +1,8 @@
+
+# use this destination directory for any example exe's generated
+set(examples_BinDir ${CMAKE_CURRENT_BINARY_DIR}/bin)
+add_custom_target(examples)
+
+# example exes
+add_subdirectory(cli_demo)
+
diff --git a/examples/cli_demo/CMakeLists.txt b/examples/cli_demo/CMakeLists.txt
new file mode 100644
index 0000000..7f9a7ef
--- /dev/null
+++ b/examples/cli_demo/CMakeLists.txt
@@ -0,0 +1,19 @@
+
+# includes/compile flags
+include_directories(${pbcopper_INCLUDE_DIRS})
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${pbcopper_CXX_FLAGS}")
+
+# main exe
+add_executable(cli_demo EXCLUDE_FROM_ALL
+ main.cpp)
+set_target_properties(cli_demo
+ PROPERTIES
+ RUNTIME_OUTPUT_DIRECTORY ${examples_BinDir}
+)
+
+# libs/dependencies
+add_dependencies(cli_demo pbcopper)
+target_link_libraries(cli_demo ${pbcopper_LIBRARIES})
+
+# add to 'make examples'
+add_dependencies(examples cli_demo)
diff --git a/examples/cli_demo/main.cpp b/examples/cli_demo/main.cpp
new file mode 100644
index 0000000..a9e3819
--- /dev/null
+++ b/examples/cli_demo/main.cpp
@@ -0,0 +1,105 @@
+
+#include <pbcopper/cli/CLI.h>
+#include <iostream>
+#include <string>
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace std;
+
+struct MyAppSettings {
+ bool progress;
+ bool force;
+ bool verbose;
+ string tempDir;
+ int timeout;
+ string source;
+ string dest;
+ vector<string> extras;
+};
+
+static inline
+int RunMain(const MyAppSettings& s)
+{
+ // this is where your normal app would take its settings and start rocking
+ // here, we just print out what we received from the CL
+
+ cout << "--------------------" << endl
+ << "App Settings: " << endl
+ << "--------------------" << endl
+ << "progress? " << (s.progress ? "on" : "off") << endl
+ << "force? " << (s.force ? "on" : "off") << endl
+ << "verbose? " << (s.verbose ? "on" : "off") << endl
+ << "tempDir: " << s.tempDir << endl
+ << "timeout: " << s.timeout << endl
+ << "source: " << s.source << endl
+ << "dest: " << s.dest << endl
+ << "extras: ";
+ for (const auto& extra : s.extras )
+ cout << extra << ", ";
+ cout << endl;
+
+ return EXIT_SUCCESS;
+}
+
+static
+PacBio::CLI::Interface createParser(void)
+{
+ PacBio::CLI::Interface cl {
+ "cli_demo",
+ "Play around with pbcopper's command line interface. Find bugs, report them.",
+ "1.0"
+ };
+ cl.AddHelpOption();
+ cl.AddVerboseOption();
+ cl.AddVersionOption();
+ cl.AddOptions({
+ {"progress", {"p"}, "Show progress while doing the things."},
+ {"force", {"f", "force"}, "Overwrite the things ruthlessly." },
+ {"temp_dir", {"t", "temp-dir"}, "Do the temp things in this directory.", Option::StringType("my/default/tmp/dir")},
+ {"timeout", {"timeout"}, "Abort execution after so many milliseconds.", Option::IntType(5000)},
+ {"modelPath", {"M", "modelPath"}, "Path to a model file.", Option::StringType("")}
+ });
+ cl.AddPositionalArguments({
+ {"source", "Source file for getting the things.", "<source>"},
+ {"dest", "Destination file for the generated things.", "<dest>"},
+ {"extras", "Extra stuff to pass in here, optionally.", "[extras...]"}
+ });
+ return cl;
+}
+
+static
+int argRunner(const PacBio::CLI::Results& args)
+{
+ // here, we translate the CLI Results to MyAppSettings
+ //
+ // this indirection allows the Results to come from either user-supplied
+ // CL args OR from a resolved tool contract in the pbsmrtpipe context
+ //
+
+ MyAppSettings s;
+ s.progress = args["progress"];
+ s.force = args["force"];
+ s.verbose = args["verbose"];
+ s.tempDir = args["temp_dir"];
+ s.timeout = args["timeout"];
+
+ const auto positionalArgs = args.PositionalArguments();
+ if (positionalArgs.size() < 2) {
+ cerr << "ERROR: source & dest args are required" << endl;
+ PacBio::CLI::PrintHelp(args.ApplicationInterface(), std::cout);
+ return EXIT_FAILURE;
+ }
+
+ s.source = positionalArgs.at(0);
+ s.dest = positionalArgs.at(1);
+ s.extras = { positionalArgs.begin()+2, positionalArgs.end() };
+ return RunMain(s);
+}
+
+int main(int argc, char* argv[])
+{
+ return PacBio::CLI::Run(argc, argv,
+ createParser(),
+ &argRunner
+ );
+}
diff --git a/include/pbcopper/Config.h b/include/pbcopper/Config.h
new file mode 100644
index 0000000..2d5660c
--- /dev/null
+++ b/include/pbcopper/Config.h
@@ -0,0 +1,22 @@
+#ifndef PBCOPPER_CONFIG_H
+#define PBCOPPER_CONFIG_H
+
+#include <cstddef>
+#include <cstdint>
+
+#define UNUSED(x) (void)x
+
+namespace PacBio {
+
+///// \internal
+//enum class Initialization
+//{
+// Uninitialized
+//};
+
+///// \internal
+//static constexpr Initialization Uninitialized = Initialization::Uninitialized;
+
+} // namespace PacBio
+
+#endif // PBCOPPER_CONFIG_H
diff --git a/include/pbcopper/cli/CLI.h b/include/pbcopper/cli/CLI.h
new file mode 100644
index 0000000..05b2f87
--- /dev/null
+++ b/include/pbcopper/cli/CLI.h
@@ -0,0 +1,97 @@
+#ifndef PBCOPPER_CLI_CLI_H
+#define PBCOPPER_CLI_CLI_H
+
+#include "pbcopper/Config.h"
+#include "pbcopper/cli/Interface.h"
+#include "pbcopper/cli/Results.h"
+#include <functional>
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+/// So applications's main.cpp contains something like:
+///
+/// #include "BlasrSettings.h" // for settings struct
+/// #include "BlasrEntry.h" // app entry point that takes the settings & starts working
+///
+/// static PacBio::CLI::Interface makeBlasrInterface(void)
+/// {
+/// // sets up interface object with options
+/// }
+///
+/// static int blasrRunner(const PacBio::CLI::Results& args)
+/// {
+/// // extract options from args -> settings
+/// //
+/// // if interface was configured w/ tool contract support, args may be from
+/// // cmd-line OR resolved tool contract, but the application shouldn't actually
+/// // care or be concerned with that
+/// //
+///
+/// BlasrSettings s;
+/// s.foo = args["foo"];
+/// // ...
+///
+/// // start the application's real work & return success/fail, a la main()
+/// return blasrEntry(s);
+/// }
+///
+/// int main(int argc, char* argv[])
+/// {
+/// return PacBio::CLI::Run(argc, argv,
+/// makeBlasrInterface(),
+/// &blasrRunner);
+/// }
+///
+
+namespace PacBio {
+namespace CLI {
+
+///
+/// \brief ResultsHandler
+///
+typedef std::function<int(const PacBio::CLI::Results&)> ResultsHandler;
+
+///
+/// \brief PrintHelp
+/// \param interface
+/// \param out
+///
+void PrintHelp(const Interface& interface, std::ostream& out);
+
+///
+/// \brief PrintVersion
+/// \param interface
+/// \param out
+///
+void PrintVersion(const Interface& interface, std::ostream& out);
+
+// TODO: add logging input here
+
+///
+/// \brief Run
+/// \param argc
+/// \param argv
+/// \param interface
+/// \param handler
+/// \return
+///
+int Run(int argc, char* argv[],
+ const Interface& interface,
+ const ResultsHandler& handler);
+
+///
+/// \brief Run
+/// \param args
+/// \param interface
+/// \param handler
+/// \return
+///
+int Run(const std::vector<std::string>& args,
+ const Interface& interface,
+ const ResultsHandler& handler);
+
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_CLI_H
diff --git a/include/pbcopper/cli/HelpPrinter.h b/include/pbcopper/cli/HelpPrinter.h
new file mode 100644
index 0000000..bcbb7ae
--- /dev/null
+++ b/include/pbcopper/cli/HelpPrinter.h
@@ -0,0 +1,28 @@
+#ifndef PBCOPPER_CLI_HELPPRINTER_H
+#define PBCOPPER_CLI_HELPPRINTER_H
+
+#include <iosfwd>
+
+namespace PacBio {
+namespace CLI {
+
+class Interface;
+
+///
+/// \brief The HelpPrinter class
+///
+class HelpPrinter
+{
+public:
+ ///
+ /// \brief Print
+ /// \param interface
+ /// \param out
+ ///
+ static void Print(const Interface& interface, std::ostream& out);
+};
+
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_HELPPRINTER_H
diff --git a/include/pbcopper/cli/Interface.h b/include/pbcopper/cli/Interface.h
new file mode 100644
index 0000000..e8ac497
--- /dev/null
+++ b/include/pbcopper/cli/Interface.h
@@ -0,0 +1,288 @@
+#ifndef PBCOPPER_CLI_INTERFACE_H
+#define PBCOPPER_CLI_INTERFACE_H
+
+#include "pbcopper/Config.h"
+#include "pbcopper/cli/Option.h"
+#include "pbcopper/cli/PositionalArg.h"
+#include "pbcopper/cli/SingleDashMode.h"
+#include "pbcopper/cli/toolcontract/Config.h"
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace PacBio {
+namespace CLI {
+
+namespace internal { class InterfacePrivate; }
+
+///
+/// \brief The Interface class
+///
+class Interface
+{
+public:
+ /// \name Constructors & Related Methods
+ /// \{
+
+ ///
+ /// \brief Interface
+ /// \param appName
+ /// \param appDescription
+ /// \param appVersion
+ ///
+ Interface(const std::string& appName,
+ const std::string& appDescription = std::string(),
+ const std::string& appVersion = std::string());
+
+ ///
+ /// \brief Interface
+ /// \param other
+ ///
+ Interface(const Interface& other);
+
+ ~Interface(void);
+
+ /// \}
+
+public:
+ /// \name Application Attributes
+ /// \{
+
+ ///
+ /// \brief ApplicationDescription
+ /// \return
+ ///
+ std::string ApplicationDescription(void) const;
+
+ ///
+ /// \brief ApplicationName
+ /// \return
+ ///
+ std::string ApplicationName(void) const;
+
+ ///
+ /// \brief ApplicationVersion
+ /// \return
+ ///
+ std::string ApplicationVersion(void) const;
+
+ ///
+ /// \brief AlternativeToolContractName
+ /// \return
+ ///
+ std::string AlternativeToolContractName(void) const;
+
+ /// \}
+
+public:
+ /// \name Interface Query
+ /// \{
+
+ ///
+ /// \brief ExpectsValue
+ /// \param optionName
+ /// \return
+ ///
+ bool ExpectsValue(const std::string& optionName) const;
+
+ ///
+ /// \brief HasOptionRegistered
+ /// \param optionName
+ /// \return
+ ///
+ bool HasOptionRegistered(const std::string& optionName) const;
+
+ ///
+ /// \brief HasHelpOptionRegistered
+ /// \return
+ ///
+ bool HasHelpOptionRegistered(void) const;
+
+ ///
+ /// \brief HasLogLevelOptionRegistered
+ /// \return
+ ///
+ bool HasLogLevelOptionRegistered(void) const;
+
+ ///
+ /// \brief HasVerboseOptionRegistered
+ /// \return
+ ///
+ bool HasVerboseOptionRegistered(void) const;
+
+ ///
+ /// \brief HasVersionOptionRegistered
+ /// \return
+ ///
+ bool HasVersionOptionRegistered(void) const;
+
+
+ ///
+ /// \brief HelpOption
+ /// \return
+ ///
+ const Option& HelpOption(void) const;
+
+ ///
+ /// \brief IdForOptionName
+ /// \param optionName
+ /// \return
+ ///
+ std::string IdForOptionName(const std::string& optionName) const;
+
+ ///
+ /// \brief IsToolContractEnabled
+ /// \return
+ ///
+ bool IsToolContractEnabled(void) const;
+
+ ///
+ /// \brief LogLevelOption
+ /// \return
+ ///
+ const Option& LogLevelOption(void) const;
+
+ ///
+ /// \brief RegisteredOptions
+ /// \return
+ ///
+ std::vector<Option> RegisteredOptions(void) const;
+
+ ///
+ /// \brief RegisteredPositionalArgs
+ /// \return
+ ///
+ std::vector<PositionalArg> RegisteredPositionalArgs(void) const;
+
+ ///
+ /// \brief ToolContract
+ /// \return
+ ///
+ const ToolContract::Config& ToolContract(void) const;
+
+ ///
+ /// \brief VerboseOption
+ /// \return
+ ///
+ const Option& VerboseOption(void) const;
+
+ ///
+ /// \brief VersionOption
+ /// \return
+ ///
+ const Option& VersionOption(void) const;
+
+ /// \}
+
+public:
+ /// \name Application Attributes
+ /// \{
+
+ ///
+ /// \brief ApplicationDescription
+ /// \param description
+ /// \return
+ ///
+ Interface& ApplicationDescription(const std::string& description);
+
+ ///
+ /// \brief ApplicationName
+ /// \param name
+ /// \return
+ ///
+ Interface& ApplicationName(const std::string& name);
+
+ ///
+ /// \brief ApplicationVersion
+ /// \param version
+ /// \return
+ ///
+ Interface& ApplicationVersion(const std::string& version);
+
+ ///
+ /// \brief AlternativeToolContractName
+ /// This name, if set, will be used as the alternative prefix of the
+ /// tool contract option prefix and replace the actual ApplicationName.
+ ///
+ /// \param name
+ /// \return
+ ///
+ Interface& AlternativeToolContractName(const std::string& name);
+
+ /// \}
+
+public:
+ /// \name Interface Setup
+ /// \{
+ /// \brief AddOption
+ /// \param option
+ /// \return
+ ///
+ Interface& AddOption(const Option& option);
+
+ ///
+ /// \brief AddOptions
+ /// \param options
+ /// \return
+ ///
+ Interface& AddOptions(const std::vector<Option>& options);
+
+ ///
+ /// \brief AddPositionalArgument
+ /// \param posArg
+ /// \return
+ ///
+ Interface& AddPositionalArgument(const PositionalArg& posArg);
+
+ ///
+ /// \brief AddPositionalArguments
+ /// \param posArgs
+ /// \return
+ ///
+ Interface& AddPositionalArguments(const std::vector<PositionalArg>& posArgs);
+
+ ///
+ /// \brief AddHelpOption
+ /// \param option
+ /// \return
+ ///
+ Interface& AddHelpOption(const Option& option = Option::DefaultHelpOption());
+
+ ///
+ /// \brief AddLogLevelOption
+ /// \param option
+ /// \return
+ ///
+ Interface& AddLogLevelOption(const Option& option = Option::DefaultLogLevelOption());
+
+ ///
+ /// \brief AddVerboseOption
+ /// \param option
+ /// \return
+ ///
+ Interface& AddVerboseOption(const Option& option = Option::DefaultVerboseOption());
+
+ ///
+ /// \brief AddVersionOption
+ /// \param option
+ /// \return
+ ///
+ Interface& AddVersionOption(const Option& option = Option::DefaultVersionOption());
+
+ ///
+ /// \brief EnableToolContract
+ /// \param tcConfig
+ /// \return
+ ///
+ Interface& EnableToolContract(const ToolContract::Config& tcConfig);
+
+ /// \}
+
+private:
+ std::unique_ptr<internal::InterfacePrivate> d_;
+};
+
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_INTERFACE_H
diff --git a/include/pbcopper/cli/Option.h b/include/pbcopper/cli/Option.h
new file mode 100644
index 0000000..0f0ae19
--- /dev/null
+++ b/include/pbcopper/cli/Option.h
@@ -0,0 +1,224 @@
+#ifndef PBCOPPER_CLI_OPTION_H
+#define PBCOPPER_CLI_OPTION_H
+
+#include "pbcopper/Config.h"
+#include "pbcopper/json/JSON.h"
+#include <initializer_list>
+#include <string>
+#include <memory>
+#include <vector>
+
+namespace PacBio {
+namespace CLI {
+
+namespace internal { class OptionPrivate; }
+
+/// \brief The Option class defines a possible command-line option.
+///
+/// This class is used to describe an option on the command line. It allows
+/// different ways of defining the same option with multiple aliases possible.
+/// It is also used to describe how the option is used - it may be a flag
+/// (e.g. -v) or take a value (e.g. -o file).
+///
+class Option
+{
+public:
+ using BoolType = JSON::Json::boolean_t;
+ using IntType = JSON::Json::number_integer_t;
+ using UIntType = JSON::Json::number_unsigned_t;
+ using FloatType = JSON::Json::number_float_t;
+ using StringType = JSON::Json::string_t;
+
+public:
+ /// \name Default Options
+ /// \{
+
+ ///
+ /// \brief DefaultHelpOption
+ /// \return
+ ///
+ static const Option& DefaultHelpOption(void);
+
+ ///
+ /// \brief DefaultLogLevelOption
+ /// \return
+ ///
+ static const Option& DefaultLogLevelOption(void);
+
+ ///
+ /// \brief DefaultVerboseOption
+ /// \return
+ ///
+ static const Option& DefaultVerboseOption(void);
+
+ ///
+ /// \brief DefaultVersionOption
+ /// \return
+ ///
+ static const Option& DefaultVersionOption(void);
+
+ /// \}
+
+public:
+ /// \name Constructors & Related Methods
+ /// \{
+
+ /// \brief Constructs a command line option object with the given arguments.
+ ///
+ /// The name of the option are set to \p name. Option names can be either
+ /// short or long. If a name is one character in length, it is considered a
+ /// short name. %Option names must not be empty, must not start with a dash
+ /// or a slash character, must not contain a '=' and cannot be repeated.
+ ///
+ /// The description is set to \p description. In addition, the \p valueName
+ /// can be set if the option expects a value. The default value for the
+ /// option is set to \p defaultValue.
+ ///
+ /// If \p defaultValue is not provided, the option is considered to be a
+ /// switch.
+ ///
+ /// This class can participate in C++11-style uniform initialization:
+ ///
+ /// \code
+ /// PacBio::CLI::Interface cl;
+ /// cl.addOption({"verbose_arg", "verbose", "Verbose mode."});
+ /// \endcode
+ ///
+ /// \param[in] name option name
+ /// \param[in] description option description
+ /// \param[in] valueName value name (used in help display)
+ /// \param[in] defaultValue default value for option if not specified
+ ///
+ Option(const std::string& id,
+ const std::string& name,
+ const std::string& description,
+ const JSON::Json& defaultValue = JSON::Json(nullptr));
+
+ /// \brief Constructs a command line option object with the given arguments.
+ ///
+ /// This overload allows to set multiple names for the option, for instance
+ /// "o" and "output".
+ ///
+ /// The names of the option are set to \p names. Option names can be either
+ /// short or long. If a name is one character in length, it is considered a
+ /// short name. %Option names must not be empty, must not start with a dash
+ /// or a slash character, must not contain a '=' and cannot be repeated.
+ ///
+ /// The description is set to \p description. In addition, the \p valueName
+ /// can be set if the option expects a value. The default value for the
+ /// option is set to \p defaultValue.
+ ///
+ /// If \p defaultValue is not provided, the option is considered to be a
+ /// switch.
+ ///
+ /// This class can participate in C++11-style uniform initialization:
+ ///
+ /// \code
+ /// PacBio::CLI::Interface cl;
+ /// cl.addOption({"output_file", {"o", "output"}, "Write results to <file>."});
+ /// \endcode
+ ///
+ /// \param[in] name option name
+ /// \param[in] description option description
+ /// \param[in] valueName value name (used in help display)
+ /// \param[in] defaultValue default value for option if not specified
+ ///
+ Option(const std::string& id,
+ const std::vector<std::string>& names,
+ const std::string& description,
+ const JSON::Json& defaultValue = JSON::Json(nullptr));
+
+ /// \brief Constructs a command line option object with the given arguments.
+ ///
+ /// This overload allows to set multiple names for the option, for instance
+ /// "o" and "output".
+ ///
+ /// The names of the option are set to \p names. Option names can be either
+ /// short or long. If a name is one character in length, it is considered a
+ /// short name. %Option names must not be empty, must not start with a dash
+ /// or a slash character, must not contain a '=' and cannot be repeated.
+ ///
+ /// The description is set to \p description. In addition, the \p valueName
+ /// can be set if the option expects a value. The default value for the
+ /// option is set to \p defaultValue.
+ ///
+ /// If \p defaultValue is not provided, the option is considered to be a
+ /// switch.
+ ///
+ /// This class can participate in C++11-style uniform initialization:
+ ///
+ /// \code
+ /// PacBio::CLI::Interface cl;
+ /// cl.addOption({"output_file", {"o", "output"}, "Write results to <file>."});
+ /// \endcode
+ ///
+ /// \param[in] name option name
+ /// \param[in] description option description
+ /// \param[in] valueName value name (used in help display)
+ /// \param[in] defaultValue default value for option if not specified
+ ///
+ Option(const std::string& id,
+ const std::initializer_list<std::string>& names,
+ const std::string& description,
+ const JSON::Json& defaultValue = JSON::Json(nullptr));
+
+ Option(const Option& other);
+ Option(Option&& other);
+ Option& operator=(const Option& other);
+ Option& operator=(Option&& other);
+ ~Option(void);
+
+ /// \}
+
+public:
+ /// \name Attributes
+ /// \{
+
+ ///
+ /// \brief DefaultValue
+ /// \return
+ ///
+ JSON::Json DefaultValue(void) const;
+
+ ///
+ /// \brief Description
+ /// \return
+ ///
+ std::string Description(void) const;
+
+ ///
+ /// \brief Id
+ /// \return
+ ///
+ std::string Id(void) const;
+
+ ///
+ /// \brief IsHidden
+ /// \return
+ ///
+ bool IsHidden(void) const;
+
+ ///
+ /// \brief Names
+ /// \return
+ ///
+ std::vector<std::string> Names(void) const;
+
+ ///
+ /// \brief ValueName
+ /// \return
+ ///
+ std::string ValueName(void) const;
+
+ /// \}
+
+private:
+ std::shared_ptr<internal::OptionPrivate> d_;
+};
+
+} // namespace CLI
+} // namespace PacBio
+
+#include "internal/Option-inl.h"
+
+#endif // PBCOPPER_CLI_OPTION_H
diff --git a/include/pbcopper/cli/Parser.h b/include/pbcopper/cli/Parser.h
new file mode 100644
index 0000000..5d3e522
--- /dev/null
+++ b/include/pbcopper/cli/Parser.h
@@ -0,0 +1,65 @@
+#ifndef PBCOPPER_CLI_PARSER_H
+#define PBCOPPER_CLI_PARSER_H
+
+#include "pbcopper/Config.h"
+#include "pbcopper/cli/Results.h"
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace PacBio {
+namespace CLI {
+
+class Interface;
+
+namespace internal { class ParserPrivate; }
+
+///
+/// \brief The Parser class
+///
+class Parser
+{
+public:
+ /// \name Constructors & Related Methods
+ /// \{
+
+ ///
+ /// \brief Parser
+ /// \param interface
+ ///
+ Parser(const Interface& interface);
+
+ Parser(const Parser& other);
+ ~Parser(void);
+
+ /// \}
+
+public:
+ /// \name Argument Parsing
+ /// \{
+
+ ///
+ /// \brief Parse
+ /// \param argc
+ /// \param argv
+ /// \return
+ ///
+ Results Parse(int argc, char* argv[]);
+
+ ///
+ /// \brief Parse
+ /// \param args
+ /// \return
+ ///
+ Results Parse(const std::vector<std::string>& args);
+
+ /// \}
+
+private:
+ std::unique_ptr<internal::ParserPrivate> d_;
+};
+
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_PARSER_H
diff --git a/include/pbcopper/cli/PositionalArg.h b/include/pbcopper/cli/PositionalArg.h
new file mode 100644
index 0000000..44c19d4
--- /dev/null
+++ b/include/pbcopper/cli/PositionalArg.h
@@ -0,0 +1,22 @@
+#ifndef PBCOPPER_CLI_POSITIONALARG_H
+#define PBCOPPER_CLI_POSITIONALARG_H
+
+#include <string>
+
+namespace PacBio {
+namespace CLI {
+
+///
+/// \brief The PositionalArg struct
+///
+struct PositionalArg
+{
+ std::string name_;
+ std::string description_;
+ std::string syntax_;
+};
+
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_POSITIONALARG_H
diff --git a/include/pbcopper/cli/Results.h b/include/pbcopper/cli/Results.h
new file mode 100644
index 0000000..85451fb
--- /dev/null
+++ b/include/pbcopper/cli/Results.h
@@ -0,0 +1,213 @@
+#ifndef PBCOPPER_CLI_RESULTS_H
+#define PBCOPPER_CLI_RESULTS_H
+
+#include "pbcopper/Config.h"
+#include "pbcopper/cli/Interface.h"
+#include "pbcopper/cli/Option.h"
+#include "pbcopper/logging/Logging.h"
+#include "pbcopper/json/JSON.h"
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace PacBio {
+namespace CLI {
+
+namespace internal { class ResultsPrivate; }
+
+///
+/// \brief The Results class
+///
+class Results
+{
+public:
+ using Result = JSON::Json;
+
+public:
+ /// \name Constructors & Related Methods
+ /// \{
+
+ ///
+ /// \brief Results
+ /// \param interface
+ ///
+ Results(const Interface& interface);
+
+ Results(const Interface& interface,
+ const std::vector<std::string>& inputCommandLine);
+
+ Results(const Results& other);
+ Results& operator=(const Results& other);
+
+ ~Results(void);
+
+ /// \}
+
+public:
+ /// \name CLI Results Query
+ /// \{
+
+ ///
+ /// \brief ApplicationInterface
+ /// \return
+ ///
+ const Interface& ApplicationInterface(void) const;
+
+ ///
+ /// \brief InputCommandLine
+ /// \return
+ ///
+ std::string InputCommandLine(void) const;
+
+ ///
+ /// \brief IsFromRTC
+ /// \return true if this Results object generated from a resolved tool
+ /// contract (as opposed to command-line args)
+ ///
+ bool IsFromRTC(void) const;
+
+ ///
+ /// \brief LogLevel
+ ///
+ /// Default level
+ ///
+ /// \note Currently only set by resolved tool contract. Setting from
+ /// command-line will follow shortly.
+ ///
+ /// \return
+ ///
+ PacBio::Logging::LogLevel LogLevel(void) const;
+
+ ///
+ /// \brief NumProcessors
+ ///
+ /// \note Currently, this field is \b only populated when the Results
+ /// object was created from a resolved tool contract.
+ ///
+ /// \sa IsFromRTC to check if this will be available
+ ///
+ /// \return number of processors specified by resolved tool contract.
+ ///
+ uint16_t NumProcessors(void) const;
+
+ ///
+ /// \brief PositionalArguments
+ /// \return
+ ///
+ std::vector<std::string> PositionalArguments(void) const;
+
+// std::string PositionalArgument(const std::string& posArgName) const;
+
+ ///
+ /// \brief operator []
+ /// \param optionId
+ /// \return
+ ///
+ const Result& operator[](const std::string& optionId) const;
+
+ ///
+ /// \brief operator []
+ /// \param id
+ /// \return
+ ///
+ Result& operator[](const std::string& id);
+
+ /// \}
+
+public:
+ /// \name Results Construction
+ /// \{
+
+ ///
+ /// \brief LogLevel
+ ///
+ /// \note Intended for internal use only. This method will likely disappear
+ /// in a future version.
+ ///
+ /// \param logLevel
+ /// \return
+ ///
+ Results& LogLevel(const PacBio::Logging::LogLevel logLevel);
+
+ ///
+ /// \brief NumProcessors
+ ///
+ /// \note Intended for internal use only. This method will likely disappear
+ /// in a future version.
+ ///
+ /// \param nproc
+ /// \return
+ ///
+ Results& NumProcessors(const uint16_t nproc);
+
+ ///
+ /// \brief Registers observed positional arg.
+ ///
+ /// Used in constructing results from command line or RTC; unlikely needed
+ /// by client code.
+ ///
+ /// \param arg
+ /// \return
+ ///
+ Results& RegisterPositionalArg(const std::string& arg);
+
+ ///
+ /// \brief RegisterObservedOption
+ ///
+ /// Used in constructing results from command line or RTC; unlikely needed
+ /// by client code.
+ ///
+ /// \param optionId
+ /// \return
+ ///
+ Results& RegisterObservedOption(const std::string& optionId);
+
+ ///
+ /// \brief RegisterOptionValue
+ ///
+ /// Used in constructing results from command line or RTC; unlikely needed
+ /// by client code.
+ ///
+ /// \param optionId
+ /// \param optionValue
+ /// \return
+ ///
+ Results& RegisterOptionValue(const std::string& optionId,
+ const JSON::Json& optionValue);
+
+ ///
+ /// \brief RegisterOptionValueString
+ ///
+ /// Used in constructing results from command line or RTC; unlikely needed
+ /// by client code.
+ ///
+ /// \param optionId
+ /// \param optionValue
+ /// \return
+ ///
+ Results& RegisterOptionValueString(const std::string& optionId,
+ const std::string& optionValue);
+
+ ///
+ /// \brief SetFromRTC
+ ///
+ /// \note Intended for internal use only. This method will likely disappear
+ /// in a future version.
+ ///
+ /// \param ok
+ /// \return
+ ///
+ Results& SetFromRTC(const bool ok = true);
+
+ /// \}
+
+private:
+ std::unique_ptr<internal::ResultsPrivate> d_;
+};
+
+} // namespace CLI
+} // namespace PacBio
+
+#include "internal/Results-inl.h"
+
+#endif // PBCOPPER_CLI_RESULTS_H
diff --git a/include/pbcopper/cli/SingleDashMode.h b/include/pbcopper/cli/SingleDashMode.h
new file mode 100644
index 0000000..f60517e
--- /dev/null
+++ b/include/pbcopper/cli/SingleDashMode.h
@@ -0,0 +1,19 @@
+#ifndef PBCOPPER_CLI_SINGLEDASHMODE_H
+#define PBCOPPER_CLI_SINGLEDASHMODE_H
+
+namespace PacBio {
+namespace CLI {
+
+///
+/// \brief The SingleDashMode enum
+///
+enum class SingleDashMode
+{
+ ParseAsShortOptions, // "-abc" equivalent to "-a -b -c" (default & recommended)
+ ParseAsLongOptions // "-abc" equivalent to "--abc"
+};
+
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_SINGLEDASHMODE_H
diff --git a/include/pbcopper/cli/VersionPrinter.h b/include/pbcopper/cli/VersionPrinter.h
new file mode 100644
index 0000000..d2e696a
--- /dev/null
+++ b/include/pbcopper/cli/VersionPrinter.h
@@ -0,0 +1,25 @@
+#ifndef PBCOPPER_CLI_VERSIONPRINTER_H
+#define PBCOPPER_CLI_VERSIONPRINTER_H
+
+#include <iosfwd>
+
+namespace PacBio {
+namespace CLI {
+
+class Interface;
+
+class VersionPrinter
+{
+public:
+ ///
+ /// \brief Print
+ /// \param interface
+ /// \param out
+ ///
+ static void Print(const Interface& interface, std::ostream& out);
+};
+
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_VERSIONPRINTER_H
diff --git a/include/pbcopper/cli/internal/Option-inl.h b/include/pbcopper/cli/internal/Option-inl.h
new file mode 100644
index 0000000..04e1ad2
--- /dev/null
+++ b/include/pbcopper/cli/internal/Option-inl.h
@@ -0,0 +1,139 @@
+#ifndef PBCOPPER_CLI_OPTION_INL_H
+#define PBCOPPER_CLI_OPTION_INL_H
+
+#include "pbcopper/cli/Option.h"
+
+namespace PacBio {
+namespace CLI {
+namespace internal {
+
+class OptionPrivate
+{
+public:
+ PacBio::JSON::Json option_;
+
+public:
+ explicit OptionPrivate(const std::string& id,
+ const std::vector<std::string>& names,
+ const std::string& description,
+ const PacBio::JSON::Json& defaultValue)
+ : option_(PacBio::JSON::Json::object_t())
+ {
+ // validate ID & name(s)
+ if (id.empty())
+ throw std::runtime_error("CLI::Option: options must have at non-empty ID");
+ if (names.empty())
+ throw std::runtime_error("CLI::Option: options must have at least one name");
+ for (const std::string& name : names) {
+ if (name.empty())
+ throw std::runtime_error("CLI::Option: options cannot be empty");
+ if (name.at(0) == '-')
+ throw std::runtime_error("CLI::Option: options cannot start with '-'");
+ if (name.at(0) == '/')
+ throw std::runtime_error("CLI::Option: options cannot start with '/'");
+ if (name.find('=') != std::string::npos)
+ throw std::runtime_error("CLI::Option: options cannot contain an '='");
+ }
+
+ // store data
+ option_["id"] = id;
+ option_["names"] = names;
+ option_["description"] = description;
+ option_["hidden"] = false;
+
+ // if none provided, treat as a switch-type option (init w/ false)
+ if (defaultValue.is_null())
+ option_["defaultValue"] = PacBio::JSON::Json::boolean_t(false);
+ else
+ option_["defaultValue"] = defaultValue;
+ }
+
+ OptionPrivate(const OptionPrivate& other)
+ : option_(other.option_)
+ { }
+};
+
+} // namespace internal
+
+// ------------------------
+// PacBio::CLI::Option
+// ------------------------
+
+inline Option::Option(const std::string& id,
+ const std::string& name,
+ const std::string& description,
+ const PacBio::JSON::Json& defaultValue)
+ : d_(new internal::OptionPrivate{
+ id,
+ std::vector<std::string>{1, name},
+ description,
+ defaultValue
+ })
+{ }
+
+inline Option::Option(const std::string& id,
+ const std::initializer_list<std::string>& init,
+ const std::string& description,
+ const PacBio::JSON::Json& defaultValue)
+ : Option(id,
+ std::vector<std::string>{init},
+ description,
+ defaultValue)
+{ }
+
+inline Option::Option(const std::string& id,
+ const std::vector<std::string>& names,
+ const std::string& description,
+ const PacBio::JSON::Json& defaultValue)
+ : d_(new internal::OptionPrivate{
+ id,
+ names,
+ description,
+ defaultValue
+ })
+{ }
+
+inline Option::Option(const Option& other)
+ : d_(new internal::OptionPrivate(*other.d_.get()))
+{ }
+
+inline Option::Option(Option&& other)
+ : d_(std::move(other.d_))
+{ }
+
+inline Option& Option::operator=(const Option& other)
+{
+ d_->option_ = other.d_->option_;
+ return *this;
+}
+
+inline Option& Option::operator=(Option&& other)
+{
+ std::swap(d_, other.d_);
+ return *this;
+}
+
+inline Option::~Option(void) { }
+
+inline PacBio::JSON::Json Option::DefaultValue(void) const
+{ return d_->option_["defaultValue"]; }
+
+inline std::string Option::Description(void) const
+{ return d_->option_["description"]; }
+
+inline std::string Option::Id(void) const
+{ return d_->option_["id"]; }
+
+inline bool Option::IsHidden(void) const
+{ return d_->option_["hidden"]; }
+
+inline std::vector<std::string> Option::Names(void) const
+{ return d_->option_["names"]; }
+
+inline std::string Option::ValueName(void) const
+{ return std::string(); }
+
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_OPTION_INL_H
diff --git a/include/pbcopper/cli/internal/Results-inl.h b/include/pbcopper/cli/internal/Results-inl.h
new file mode 100644
index 0000000..4e0ee22
--- /dev/null
+++ b/include/pbcopper/cli/internal/Results-inl.h
@@ -0,0 +1,25 @@
+#ifndef PBCOPPER_CLI_RESULTS_INL_H
+#define PBCOPPER_CLI_RESULTS_INL_H
+
+#include "pbcopper/cli/Results.h"
+
+namespace PacBio {
+namespace CLI {
+
+//Result& Results::operator[](const std::string& optionId) const
+//{ return FetchResult(optionId); }
+
+//template<>
+//inline std::string Results::operator[](const std::string& optionName) const
+//{
+//// return string{};
+// const auto values = Values(optionName);
+// if (!values.empty())
+// return values.back();
+// return std::string(); // or throw on unknown name?
+//}
+
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_RESULTS_INL_H
diff --git a/include/pbcopper/cli/toolcontract/Config.h b/include/pbcopper/cli/toolcontract/Config.h
new file mode 100644
index 0000000..5d88645
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/Config.h
@@ -0,0 +1,87 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_CONFIG_H
+#define PBCOPPER_CLI_TOOLCONTRACT_CONFIG_H
+
+#include "pbcopper/Config.h"
+#include "pbcopper/cli/toolcontract/Task.h"
+#include "pbcopper/cli/toolcontract/Driver.h"
+#include <string>
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+
+///
+/// \brief The ToolContractConfig class
+///
+class Config
+{
+public:
+ /// \name Constructors & Related Methods
+ /// \{
+
+ /// \brief Contructs a tool contract configuration with the provided task
+ /// settings and default driver settings.
+ ///
+ /// \param task
+ ///
+ Config(const ToolContract::Task& task);
+
+ /// \brief Contructs a tool contract configuration with the provided task &
+ /// driver settings.
+ ///
+ /// \param task
+ /// \param driver
+ ///
+ Config(const ToolContract::Task& task,
+ const ToolContract::Driver& driver);
+
+ Config(const Config& other) = default;
+ Config(Config&& other) = default;
+ Config& operator=(const Config& other) = default;
+ Config& operator=(Config&& other) = default;
+ ~Config(void) = default;
+
+ /// \}
+
+public:
+ /// \name Main Components
+ /// \{
+
+ ///
+ /// \brief Driver
+ /// \return
+ ///
+ const ToolContract::Driver& Driver(void) const;
+
+ ///
+ /// \brief Task
+ /// \return
+ ///
+ const ToolContract::Task& Task(void) const;
+
+ /// \}
+
+public:
+ /// \name Other Attributes
+ /// \{
+
+ std::string Version(void) const;
+
+ /// \}
+
+public:
+ Config& Version(const std::string& version);
+
+private:
+ ToolContract::Task task_;
+ ToolContract::Driver driver_;
+ std::string version_;
+};
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+#include "internal/Config-inl.h"
+
+#endif // PBCOPPER_CLI_TOOLCONTRACT_CONFIG_H
diff --git a/include/pbcopper/cli/toolcontract/Driver.h b/include/pbcopper/cli/toolcontract/Driver.h
new file mode 100644
index 0000000..c94886a
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/Driver.h
@@ -0,0 +1,116 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_DRIVER_H
+#define PBCOPPER_CLI_TOOLCONTRACT_DRIVER_H
+
+#include "pbcopper/Config.h"
+#include <unordered_map>
+#include <string>
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+
+///
+/// \brief The ToolDriver class
+///
+class Driver
+{
+public:
+ typedef std::unordered_map<std::string, std::string> Environment;
+
+public:
+ /// \name Constructors & Related Methods
+ /// \{
+
+ ///
+ /// \brief ToolDriver
+ ///
+ Driver(void);
+
+ ///
+ /// \brief ToolDriver
+ /// \param exe
+ ///
+ Driver(const std::string& exe);
+
+ ///
+ /// \brief ToolDriver
+ /// \param exe
+ /// \param env
+ /// \param serialization
+ ///
+ Driver(const std::string& exe,
+ const Environment& env,
+ const std::string& serialization);
+
+ Driver(const Driver& other) = default;
+ Driver(Driver&& other) = default;
+ Driver& operator=(const Driver& other) = default;
+ Driver& operator=(Driver&& other) = default;
+ ~Driver(void) = default;
+
+ /// \}
+
+public:
+ /// \name Attributes
+ /// \{
+
+ ///
+ /// \brief Env
+ /// \return
+ ///
+ const Environment& Env(void) const;
+
+ ///
+ /// \brief Exe
+ /// \return
+ ///
+ const std::string& Exe(void) const;
+
+ ///
+ /// \brief Serialization
+ /// \return
+ ///
+ const std::string& Serialization(void) const;
+
+ /// \}
+
+public:
+ /// \name Attributes
+ /// \{
+
+ ///
+ /// \brief Env
+ /// \param env
+ /// \return
+ ///
+ Driver& Env(const Environment& env);
+
+ ///
+ /// \brief Exe
+ /// \param exe
+ /// \return
+ ///
+ Driver& Exe(const std::string& exe);
+
+ ///
+ /// \brief Serialization
+ /// \param serialization
+ /// \return
+ ///
+ Driver& Serialization(const std::string& serialization);
+
+ /// \}
+
+private:
+ std::string exe_;
+ std::string serialization_;
+ std::unordered_map<std::string, std::string> env_;
+};
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+#include "internal/Driver-inl.h"
+
+#endif // PBCOPPER_CLI_TOOLCONTRACT_DRIVER_H
diff --git a/include/pbcopper/cli/toolcontract/InputFileType.h b/include/pbcopper/cli/toolcontract/InputFileType.h
new file mode 100644
index 0000000..58e2013
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/InputFileType.h
@@ -0,0 +1,40 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_INPUTFILETYPE_H
+#define PBCOPPER_CLI_TOOLCONTRACT_INPUTFILETYPE_H
+
+#include <string>
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+
+class InputFileType
+{
+public:
+ InputFileType(const std::string& id,
+ const std::string& title,
+ const std::string& description,
+ const std::string& type);
+
+ InputFileType(const InputFileType& other) = default;
+ ~InputFileType(void) = default;
+
+public:
+ const std::string& Id(void) const;
+ const std::string& Title(void) const;
+ const std::string& Description(void) const;
+ const std::string& Type(void) const;
+
+private:
+ std::string id_;
+ std::string title_;
+ std::string description_;
+ std::string type_;
+};
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+#include "internal/InputFileType-inl.h"
+
+#endif // PBCOPPER_CLI_TOOLCONTRACT_INPUTFILETYPE_H
diff --git a/include/pbcopper/cli/toolcontract/JsonPrinter.h b/include/pbcopper/cli/toolcontract/JsonPrinter.h
new file mode 100644
index 0000000..a2a5265
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/JsonPrinter.h
@@ -0,0 +1,38 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_JSONPRINTER_H
+#define PBCOPPER_CLI_TOOLCONTRACT_JSONPRINTER_H
+
+#include <iosfwd>
+
+namespace PacBio {
+namespace CLI {
+
+class Interface;
+
+namespace ToolContract {
+
+class JsonPrinter
+{
+public:
+
+ /// \brief Prints a JSON-formatted tool contract.
+ ///
+ /// \param interface Interface object to generate tool contract from
+ /// \param out destination output stream
+ /// \param indent If indent is non-negative, then array elements and
+ /// object members will be pretty-printed with that
+ /// indent level. An indent level of 0 will only insert
+ /// newlines. Indent level of -1 selects the most
+ /// compact representation.
+ ///
+ /// \throws std::runtime_error if failed to print
+ ///
+ static void Print(const Interface& interface,
+ std::ostream& out,
+ const int indent = 4);
+};
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_TOOLCONTRACT_JSONPRINTER_H
diff --git a/include/pbcopper/cli/toolcontract/OutputFileType.h b/include/pbcopper/cli/toolcontract/OutputFileType.h
new file mode 100644
index 0000000..90caedd
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/OutputFileType.h
@@ -0,0 +1,43 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_OUTPUTFILETYPE_H
+#define PBCOPPER_CLI_TOOLCONTRACT_OUTPUTFILETYPE_H
+
+#include <string>
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+
+class OutputFileType
+{
+public:
+ OutputFileType(const std::string& id,
+ const std::string& title,
+ const std::string& description,
+ const std::string& type,
+ const std::string& defaultName);
+
+ OutputFileType(const OutputFileType& other) = default;
+ ~OutputFileType(void) = default;
+
+public:
+ const std::string& Id(void) const;
+ const std::string& Title(void) const;
+ const std::string& DefaultName(void) const;
+ const std::string& Description(void) const;
+ const std::string& Type(void) const;
+
+private:
+ std::string id_;
+ std::string title_;
+ std::string description_;
+ std::string type_;
+ std::string defaultName_;
+};
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+#include "internal/OutputFileType-inl.h"
+
+#endif // PBCOPPER_CLI_TOOLCONTRACT_OUTPUTFILETYPE_H
diff --git a/include/pbcopper/cli/toolcontract/ResolvedToolContract.h b/include/pbcopper/cli/toolcontract/ResolvedToolContract.h
new file mode 100644
index 0000000..6cd807a
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/ResolvedToolContract.h
@@ -0,0 +1,31 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_RESOLVEDTOOLCONTRACT_H
+#define PBCOPPER_CLI_TOOLCONTRACT_RESOLVEDTOOLCONTRACT_H
+
+#include "pbcopper/cli/Results.h"
+#include <iosfwd>
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+
+namespace internal { class RtcPrivate; }
+
+class ResolvedToolContract
+{
+public:
+ ResolvedToolContract(const Interface& interface);
+ ~ResolvedToolContract(void);
+
+public:
+ Results Parse(std::istream& in);
+
+private:
+ std::unique_ptr<internal::RtcPrivate> d_;
+};
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_TOOLCONTRACT_RESOLVEDTOOLCONTRACT_H
+
diff --git a/include/pbcopper/cli/toolcontract/ResourceType.h b/include/pbcopper/cli/toolcontract/ResourceType.h
new file mode 100644
index 0000000..d0e3aa8
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/ResourceType.h
@@ -0,0 +1,20 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_RESOURCETYPE_H
+#define PBCOPPER_CLI_TOOLCONTRACT_RESOURCETYPE_H
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+
+enum class ResourceType
+{
+ TMP_DIR
+ , TMP_FILE
+ , LOG_FILE
+ , OUTPUT_DIR
+};
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_TOOLCONTRACT_RESOURCETYPE_H
diff --git a/include/pbcopper/cli/toolcontract/Task.h b/include/pbcopper/cli/toolcontract/Task.h
new file mode 100644
index 0000000..6cf5c4e
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/Task.h
@@ -0,0 +1,270 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_TASK_H
+#define PBCOPPER_CLI_TOOLCONTRACT_TASK_H
+
+#include "pbcopper/Config.h"
+#include "pbcopper/cli/toolcontract/InputFileType.h"
+#include "pbcopper/cli/toolcontract/OutputFileType.h"
+#include "pbcopper/cli/toolcontract/ResourceType.h"
+#include "pbcopper/cli/toolcontract/TaskType.h"
+#include <map>
+#include <string>
+#include <vector>
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+
+///
+/// \brief The Task class
+///
+class Task
+{
+public:
+
+ /// Used to indicate that the maximum number of available processors, as
+ /// determined by the tool contract resolving system, should be used for
+ /// this task.
+ ///
+ /// The actual integer value (zero) is not used; instead this should be
+ /// considered more of a "sentinel" value.
+ ///
+ static const uint16_t MAX_NPROC = 0;
+
+public:
+ /// \name Constructors & Related Methods
+ /// \{
+
+ ///
+ /// \brief ToolContractTask
+ /// \param taskId
+ ///
+ Task(const std::string& taskId);
+
+ Task(const Task&) = default;
+ ~Task(void) = default;
+
+ /// \}
+
+public:
+ /// \name Attributes
+ /// \{
+
+ ///
+ /// \brief Description
+ /// \return
+ ///
+ std::string Description(void) const;
+
+ ///
+ /// \brief IsDistributed
+ /// \return
+ ///
+ bool IsDistributed(void) const;
+
+ ///
+ /// \brief NumProcessors
+ ///
+ /// Default is 1.
+ ///
+ /// \return
+ ///
+ uint16_t NumProcessors(void) const;
+
+
+ ///
+ /// \brief TaskId
+ /// \return
+ ///
+ const std::string& TaskId(void) const;
+
+ ///
+ /// \brief Type
+ /// \return
+ ///
+ TaskType Type(void) const;
+
+ /// \}
+
+public:
+ /// \name Options
+ /// \{
+
+ std::map<std::string, std::string> Options(void) const;
+
+ /// \}
+
+public:
+ /// \name File & Resource Types
+ /// \{
+
+ ///
+ /// \brief InputFileTypes
+ /// \return
+ ///
+ std::vector<InputFileType> InputFileTypes(void) const;
+
+ ///
+ /// \brief InputFilesToOptions
+ /// \return
+ ///
+ std::map<size_t, std::string> InputFilesToOptions(void) const;
+
+ ///
+ /// \brief OutputFileTypes
+ /// \return
+ ///
+ std::vector<OutputFileType> OutputFileTypes(void) const;
+
+ ///
+ /// \brief OutputFilesToOptions
+ /// \return
+ ///
+ std::map<size_t, std::string> OutputFilesToOptions(void) const;
+
+ ///
+ /// \brief ResourceTypes
+ /// \return
+ ///
+ std::vector<ResourceType> ResourceTypes(void) const;
+
+ /// \}
+
+public:
+ /// \name Attributes
+ /// \{
+
+ ///
+ /// \brief Description
+ /// \param description
+ /// \return
+ ///
+ Task& Description(const std::string& description);
+
+ ///
+ /// \brief NumProcessors
+ ///
+ /// Set an explicit number of processors for this task (default is 1).
+ ///
+ /// Task::MAX_NPROC can be used here to let the tool contract resolving
+ /// system determine the actual processor count. Using \p nProc of 0 yields
+ /// the same effect.
+ ///
+ /// \param nProc
+ /// \return
+ ///
+ Task& NumProcessors(const uint16_t nProc);
+
+ ///
+ /// \brief SetDistributed
+ /// \param ok
+ /// \return
+ ///
+ Task& SetDistributed(const bool ok = true);
+
+ ///
+ /// \brief Type
+ /// \param type
+ /// \return
+ ///
+ Task& Type(const TaskType& type);
+
+ /// \}
+
+public:
+ /// \name Options
+ /// \{
+
+ ///
+ /// \brief Options
+ /// \param optionConfigs
+ /// \return
+ ///
+ Task& Options(const std::map<std::string, std::string>& optionConfigs);
+
+ ///
+ /// \brief Add single option
+ /// \param OptionConfig
+ /// \return
+ ///
+ Task& AddOption(const std::pair<std::string, std::string>& optionConfig);
+
+ /// \}
+
+public:
+ /// \name File & Resource Types
+ /// \{
+
+ /// \brief Sets the task's input files list to provided list.
+ ///
+ /// \param inputFileTypes
+ /// \returns reference to this task
+ ///
+ Task& InputFileTypes(const std::vector<InputFileType>& inputFileTypes);
+
+ ///
+ /// \brief OutputFilesToOptions
+ ///
+ /// Set a mapping for RTC's input_files[] JSON array to named command-line
+ /// options. Key is the position in the array, and value is the option's ID.
+ ///
+ /// \param mapping
+ /// \return
+ ///
+ Task& InputFilesToOptions(const std::map<size_t, std::string>& mapping);
+
+ /// \brief Sets the task's output files list to provided list.
+ ///
+ /// \param outputFileTypes
+ /// \returns reference to this taskn
+ ///
+ Task& OutputFileTypes(const std::vector<OutputFileType>& outputFileTypes);
+
+ ///
+ /// \brief OutputFilesToOptions
+ ///
+ /// Set a mapping for RTC's output_files[] JSON array to named command-line
+ /// options. Key is the position in the array, and value is the option's ID.
+ ///
+ /// \param mapping
+ /// \return
+ ///
+ Task& OutputFilesToOptions(const std::map<size_t, std::string>& mapping);
+
+ /// \brief Sets the task's resource list to provided list.
+ ///
+ /// \param resourceTypes
+ /// \returns reference to this task
+ ///
+ Task& ResourceTypes(const std::vector<ResourceType>& resourceTypes);
+
+ /// \}
+
+private:
+
+ // attributes
+ std::string id_;
+ std::string description_;
+ uint16_t nProc_;
+ bool isDistributed_;
+ TaskType type_;
+
+ // registered task options
+ std::map<std::string, std::string> optionDisplayNames_;
+
+ // files & resources
+ std::vector<InputFileType> inputFileTypes_;
+ std::vector<OutputFileType> outputFileTypes_;
+ std::vector<ResourceType> resourceTypes_;
+
+ // file -> option mappings
+ std::map<size_t, std::string> inputFilesToOptions_;
+ std::map<size_t, std::string> outputFilesToOptions_;
+};
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+#include "internal/Task-inl.h"
+
+#endif // PBCOPPER_CLI_TOOLCONTRACT_TASK_H
diff --git a/include/pbcopper/cli/toolcontract/TaskType.h b/include/pbcopper/cli/toolcontract/TaskType.h
new file mode 100644
index 0000000..e1b7c8d
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/TaskType.h
@@ -0,0 +1,19 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_TASKTYPE_H
+#define PBCOPPER_CLI_TOOLCONTRACT_TASKTYPE_H
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+
+enum class TaskType
+{
+ STANDARD
+ , SCATTERED
+ , GATHERED
+};
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_TOOLCONTRACT_TASKTYPE_H
diff --git a/include/pbcopper/cli/toolcontract/internal/Config-inl.h b/include/pbcopper/cli/toolcontract/internal/Config-inl.h
new file mode 100644
index 0000000..b44ca87
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/internal/Config-inl.h
@@ -0,0 +1,36 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_CONFIG_INL_H
+#define PBCOPPER_CLI_TOOLCONTRACT_CONFIG_INL_H
+
+#include "pbcopper/cli/toolcontract/Config.h"
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+
+inline Config::Config(const ToolContract::Task& task)
+ : task_(task)
+{ }
+
+inline Config::Config(const ToolContract::Task& task,
+ const ToolContract::Driver& driver)
+ : task_(task)
+ , driver_(driver)
+{ }
+
+inline const Driver& Config::Driver(void) const
+{ return driver_; }
+
+inline const Task& Config::Task(void) const
+{ return task_; }
+
+inline std::string Config::Version(void) const
+{ return version_; }
+
+inline Config& Config::Version(const std::string& version)
+{ version_ = version; return *this; }
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_TOOLCONTRACT_CONFIG_INL_H
diff --git a/include/pbcopper/cli/toolcontract/internal/Driver-inl.h b/include/pbcopper/cli/toolcontract/internal/Driver-inl.h
new file mode 100644
index 0000000..0759b37
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/internal/Driver-inl.h
@@ -0,0 +1,46 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_DRIVER_INL_H
+#define PBCOPPER_CLI_TOOLCONTRACT_DRIVER_INL_H
+
+#include "pbcopper/cli/toolcontract/Driver.h"
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+
+inline Driver::Driver(void) { }
+
+inline Driver::Driver(const std::string& exe)
+ : exe_(exe)
+{ }
+
+inline Driver::Driver(const std::string& exe,
+ const Environment& env,
+ const std::string& serialization)
+ : exe_(exe)
+ , serialization_(serialization)
+ , env_(env)
+{ }
+
+inline const Driver::Environment& Driver::Env(void) const
+{ return env_; }
+
+inline Driver& Driver::Env(const Driver::Environment& env)
+{ env_ = env; return *this; }
+
+inline const std::string& Driver::Exe(void) const
+{ return exe_; }
+
+inline Driver& Driver::Exe(const std::string& exe)
+{ exe_ = exe; return *this; }
+
+inline const std::string& Driver::Serialization(void) const
+{ return serialization_; }
+
+inline Driver& Driver::Serialization(const std::string& serialization)
+{ serialization_ = serialization; return *this; }
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_TOOLCONTRACT_DRIVER_INL_H
diff --git a/include/pbcopper/cli/toolcontract/internal/InputFileType-inl.h b/include/pbcopper/cli/toolcontract/internal/InputFileType-inl.h
new file mode 100644
index 0000000..a4f2dad
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/internal/InputFileType-inl.h
@@ -0,0 +1,37 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_INPUTFILETYPE_INL_H
+#define PBCOPPER_CLI_TOOLCONTRACT_INPUTFILETYPE_INL_H
+
+#include "pbcopper/cli/toolcontract/InputFileType.h"
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+
+inline InputFileType::InputFileType(const std::string& id,
+ const std::string& title,
+ const std::string& description,
+ const std::string& type)
+ : id_(id)
+ , title_(title)
+ , description_(description)
+ , type_(type)
+{ }
+
+inline const std::string& InputFileType::Description(void) const
+{ return description_; }
+
+inline const std::string& InputFileType::Id(void) const
+{ return id_; }
+
+inline const std::string& InputFileType::Title(void) const
+{ return title_; }
+
+inline const std::string& InputFileType::Type(void) const
+{ return type_; }
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+
+#endif // PBCOPPER_CLI_TOOLCONTRACT_INPUTFILETYPE_INL_H
diff --git a/include/pbcopper/cli/toolcontract/internal/OutputFileType-inl.h b/include/pbcopper/cli/toolcontract/internal/OutputFileType-inl.h
new file mode 100644
index 0000000..3e3cbd6
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/internal/OutputFileType-inl.h
@@ -0,0 +1,42 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_OUTPUTFILETYPE_INL_H
+#define PBCOPPER_CLI_TOOLCONTRACT_OUTPUTFILETYPE_INL_H
+
+#include "pbcopper/cli/toolcontract/OutputFileType.h"
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+
+inline OutputFileType::OutputFileType(const std::string& id,
+ const std::string& title,
+ const std::string& description,
+ const std::string& type,
+ const std::string& defaultName)
+ : id_(id)
+ , title_(title)
+ , description_(description)
+ , type_(type)
+ , defaultName_(defaultName)
+{ }
+
+inline const std::string& OutputFileType::DefaultName(void) const
+{ return defaultName_; }
+
+inline const std::string& OutputFileType::Description(void) const
+{ return description_; }
+
+inline const std::string& OutputFileType::Id(void) const
+{ return id_; }
+
+inline const std::string& OutputFileType::Title(void) const
+{ return title_; }
+
+inline const std::string& OutputFileType::Type(void) const
+{ return type_; }
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+
+#endif // PBCOPPER_CLI_TOOLCONTRACT_OUTPUTFILETYPE_INL_H
diff --git a/include/pbcopper/cli/toolcontract/internal/Task-inl.h b/include/pbcopper/cli/toolcontract/internal/Task-inl.h
new file mode 100644
index 0000000..b5b4773
--- /dev/null
+++ b/include/pbcopper/cli/toolcontract/internal/Task-inl.h
@@ -0,0 +1,87 @@
+#ifndef PBCOPPER_CLI_TOOLCONTRACT_TASK_INL_H
+#define PBCOPPER_CLI_TOOLCONTRACT_TASK_INL_H
+
+#include "pbcopper/cli/toolcontract/Task.h"
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+
+inline Task::Task(const std::string& taskId)
+ : id_(taskId)
+ , nProc_(1)
+ , isDistributed_(true)
+ , type_(TaskType::STANDARD)
+{ }
+
+inline std::string Task::Description(void) const
+{ return description_; }
+
+inline Task& Task::Description(const std::string& description)
+{ description_ = description; return *this; }
+
+inline std::vector<InputFileType> Task::InputFileTypes(void) const
+{ return inputFileTypes_; }
+
+inline Task& Task::InputFileTypes(const std::vector<InputFileType>& inputFileTypes)
+{ inputFileTypes_ = inputFileTypes; return *this; }
+
+inline std::map<size_t, std::string> Task::InputFilesToOptions(void) const
+{ return inputFilesToOptions_; }
+
+inline Task& Task::InputFilesToOptions(const std::map<size_t, std::string>& mapping)
+{ inputFilesToOptions_ = mapping; return *this; }
+
+inline bool Task::IsDistributed(void) const
+{ return isDistributed_; }
+
+inline uint16_t Task::NumProcessors(void) const
+{ return nProc_; }
+
+inline Task& Task::NumProcessors(const uint16_t nProc)
+{ nProc_ = nProc; return *this; }
+
+inline std::map<std::string, std::string> Task::Options(void) const
+{ return optionDisplayNames_; }
+
+inline Task& Task::Options(const std::map<std::string, std::string>& optionDisplayNames)
+{ optionDisplayNames_ = optionDisplayNames; return *this; }
+
+inline Task& Task::AddOption(const std::pair<std::string, std::string>& optionConfig)
+{ optionDisplayNames_.insert(optionConfig); return *this; }
+
+inline std::vector<OutputFileType> Task::OutputFileTypes(void) const
+{ return outputFileTypes_; }
+
+inline std::map<size_t, std::string> Task::OutputFilesToOptions(void) const
+{ return outputFilesToOptions_; }
+
+inline Task& Task::OutputFilesToOptions(const std::map<size_t, std::string>& mapping)
+{ outputFilesToOptions_ = mapping; return *this; }
+
+inline Task& Task::OutputFileTypes(const std::vector<OutputFileType>& outputFileTypes)
+{ outputFileTypes_ = outputFileTypes; return *this; }
+
+inline std::vector<ResourceType> Task::ResourceTypes(void) const
+{ return resourceTypes_; }
+
+inline Task& Task::ResourceTypes(const std::vector<ResourceType>& resourceTypes)
+{ resourceTypes_ = resourceTypes; return *this; }
+
+inline Task& Task::SetDistributed(const bool ok)
+{ isDistributed_ = ok; return *this; }
+
+inline const std::string& Task::TaskId(void) const
+{ return id_; }
+
+inline TaskType Task::Type(void) const
+{ return type_; }
+
+inline Task& Task::Type(const TaskType& type)
+{ type_ = type; return *this; }
+
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_TOOLCONTRACT_TASK_INL_H
diff --git a/include/pbcopper/data/CCSTag.h b/include/pbcopper/data/CCSTag.h
new file mode 100644
index 0000000..010eeb2
--- /dev/null
+++ b/include/pbcopper/data/CCSTag.h
@@ -0,0 +1,14 @@
+
+#ifndef PBCOPPER_DATA_CCSTAG_H
+#define PBCOPPER_DATA_CCSTAG_H
+
+namespace PacBio {
+namespace Data {
+
+// used as a 'tag' for overloading methods
+struct CCSTag { };
+
+} // namespace Data
+} // namespace PacBio
+
+#endif // PBCOPPER_DATA_CCSTAG_H
diff --git a/include/pbcopper/data/Interval.h b/include/pbcopper/data/Interval.h
new file mode 100644
index 0000000..565a4a5
--- /dev/null
+++ b/include/pbcopper/data/Interval.h
@@ -0,0 +1,115 @@
+#ifndef PBCOPPER_DATA_INTERVAL_H
+#define PBCOPPER_DATA_INTERVAL_H
+
+#include "pbcopper/Config.h"
+
+#define BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS
+#include <boost/icl/discrete_interval.hpp>
+#include <boost/icl/interval_traits.hpp>
+
+namespace PacBio {
+namespace Data {
+
+/// \brief Represents a half-open (right-open) interval [start, end)
+///
+/// \note This class is agnostic whether the values are 0-based or 1-based.
+///
+template<typename T>
+class Interval
+{
+public:
+ typedef boost::icl::discrete_interval<T> interval_type;
+
+public:
+ /// \name Constructors & Related Methods
+ /// \{
+
+ /// \brief Creates an empty interval [0,0)
+ Interval(void);
+
+ /// \brief Creates a 'singleton' interval [val,val+1)
+ Interval(const T val);
+
+ /// \brief Creates an interval from [start, end) */
+ Interval(const T start, const T end);
+
+ /// \brief Copy constructs an interval
+ Interval(const Interval<T>& other);
+
+ /// \brief Move constructs an interval
+ Interval(Interval<T>&& other);
+
+ Interval<T>& operator=(const Interval<T>& other) = default;
+ Interval<T>& operator=(Interval<T>&& other) = default;
+ ~Interval<T>(void) = default;
+
+ /// \}
+
+public:
+ /// \name Comparison Operators
+ /// \{
+
+ /// \returns true if both intervals share the same endpoints
+ bool operator==(const Interval<T>& other) const;
+
+ /// \returns true if either interval's endpoints differ
+ bool operator!=(const Interval<T>& other) const;
+
+ /// \}
+
+public:
+ /// \name Attributes
+ /// \{
+
+ /// \returns interval's start coordinate
+ T Start(void) const;
+
+ /// Sets this interval's start coordinate.
+ ///
+ /// \param[in] start
+ /// \returns reference to this interval
+ ///
+ Interval<T>& Start(const T& start);
+
+ /// \returns interval's end coordinate
+ T End(void) const;
+
+ /// Sets this interval's end coordinate.
+ ///
+ /// \param[in] end
+ /// \returns reference to this interval
+ ///
+ Interval<T>& End(const T& end);
+
+ /// \}
+
+public:
+ /// \name Interval Operations
+
+ /// \returns true if this interval is fully covered by (or contained in) \p other
+ bool CoveredBy(const Interval<T>& other) const;
+
+ //// \returns true if this interval covers (or contains) \p other
+ bool Covers(const Interval<T>& other) const;
+
+ /// \returns true if intervals interset
+ bool Intersects(const Interval<T>& other) const;
+
+ /// \returns true if interval is valid (e.g. start < stop)
+ bool IsValid(void) const;
+
+ /// \returns interval length
+ size_t Length(void) const;
+
+ /// \}
+
+private:
+ interval_type data_;
+};
+
+} // namespace Data
+} // namespace PacBio
+
+#include "internal/Interval-inl.h"
+
+#endif // PBCOPPER_DATA_INTERVAL_H
diff --git a/include/pbcopper/data/MovieName.h b/include/pbcopper/data/MovieName.h
new file mode 100644
index 0000000..71fb63a
--- /dev/null
+++ b/include/pbcopper/data/MovieName.h
@@ -0,0 +1,85 @@
+#ifndef PBCOPPER_DATA_MOVIENAME_H
+#define PBCOPPER_DATA_MOVIENAME_H
+
+#include "pbcopper/Config.h"
+#include <boost/utility/string_ref.hpp>
+#include <iosfwd>
+#include <memory>
+#include <string>
+
+namespace PacBio {
+namespace Data {
+
+/// \brief The MovieName class provides methods for working with PacBio movie
+/// names.
+class MovieName
+{
+public:
+ /// \name Constructors & Related Methods
+ /// \{
+
+ // create MovieName from string
+ explicit MovieName(const std::string& name);
+ explicit MovieName(std::string&& name);
+
+ // create MovieName from name parts
+ MovieName(const std::string& instrumentName,
+ const std::string& runStartTime);
+
+ MovieName(void);
+ MovieName(const MovieName& other);
+ MovieName(MovieName&& other) noexcept;
+ MovieName& operator=(const MovieName& other);
+ MovieName& operator=(MovieName&& other) noexcept;
+ ~MovieName(void);
+
+ /// \}
+
+public:
+ /// \name Name Parts
+ /// \{
+
+ boost::string_ref InstrumentName(void) const;
+ boost::string_ref RunStartTime(void) const;
+
+ /// \}
+
+public:
+ /// \name Additional Methods & Operators
+ /// \{
+
+ std::string ToStdString(void) const;
+
+ /// \}
+
+private:
+ std::string movieName_;
+
+ struct PartsCache;
+ mutable std::unique_ptr<PartsCache> partsCache_;
+
+private:
+ void UpdatePartsCache(void) const;
+};
+
+/// \name Related Non-members
+/// \{
+
+
+// comparison operators
+inline bool operator==(const MovieName& lhs, const MovieName& rhs);
+inline bool operator!=(const MovieName& lhs, const MovieName& rhs);
+inline bool operator<(const MovieName& lhs, const MovieName& rhs);
+
+// I/O
+inline std::ostream& operator<<(std::ostream& os, const MovieName& movieName);
+inline std::istream& operator>>(std::istream& is, MovieName& movieName);
+
+/// \}
+
+} // namespace Data
+} // namespace PacBio
+
+#include "internal/MovieName-inl.h"
+
+#endif // PBCOPPER_DATA_MOVIENAME_H
diff --git a/include/pbcopper/data/Position.h b/include/pbcopper/data/Position.h
new file mode 100644
index 0000000..96eaf63
--- /dev/null
+++ b/include/pbcopper/data/Position.h
@@ -0,0 +1,16 @@
+#ifndef PBCOPPER_DATA_POSITION_H
+#define PBCOPPER_DATA_POSITION_H
+
+#include "pbcopper/Config.h"
+
+namespace PacBio {
+namespace Data {
+
+typedef int32_t Position;
+
+static const Position UnmappedPosition = Position{ -1 };
+
+} // namespace Data
+} // namespace PacBio
+
+#endif // PBCOPPER_DATA_POSITION_H
diff --git a/include/pbcopper/data/RSMovieName.h b/include/pbcopper/data/RSMovieName.h
new file mode 100644
index 0000000..d521066
--- /dev/null
+++ b/include/pbcopper/data/RSMovieName.h
@@ -0,0 +1,93 @@
+#ifndef PBCOPPER_DATA_RSMOVIENAME_H
+#define PBCOPPER_DATA_RSMOVIENAME_H
+
+#include "pbcopper/Config.h"
+#include <boost/utility/string_ref.hpp>
+#include <iosfwd>
+#include <memory>
+#include <string>
+
+namespace PacBio {
+namespace Data {
+
+/// \brief The RSMovieName class provides methods for working with PacBio RSII
+/// movie names.
+///
+class RSMovieName
+{
+public:
+ /// \name Constructors & Related Methods
+ /// \{
+
+ // create RSMovieName from string
+ explicit RSMovieName(const std::string& name);
+ explicit RSMovieName(std::string&& name);
+
+ // create MovieName from name parts
+ RSMovieName(const std::string& runStartTime,
+ const std::string& instrumentSerialNumber,
+ const std::string& smrtCellBarcode,
+ const std::string& setNumber,
+ const std::string& partNumber);
+
+ RSMovieName(void);
+ RSMovieName(const RSMovieName& other);
+ RSMovieName(RSMovieName&& other) noexcept;
+ RSMovieName& operator=(const RSMovieName& other);
+ RSMovieName& operator=(RSMovieName&& other) noexcept;
+ ~RSMovieName(void);
+
+ /// \}
+
+public:
+ /// \name Name Parts
+ /// \{
+
+ boost::string_ref InstrumentSerialNumber(void) const;
+ boost::string_ref PartNumber(void) const;
+ boost::string_ref RunStartTime(void) const;
+ boost::string_ref SetNumber(void) const;
+ boost::string_ref SMRTCellBarcode(void) const;
+
+ /// \}
+
+public:
+ /// \name Additional Methods & Operators
+ /// \{
+
+ bool IsReagentExpired(void) const;
+ std::string ToStdString(void) const;
+
+ /// \}
+
+private:
+ std::string movieName_;
+
+ struct PartsCache;
+ mutable std::unique_ptr<PartsCache> partsCache_;
+
+private:
+ void UpdatePartsCache(void) const;
+};
+
+/// \name Related Non-members
+/// \{
+
+
+// comparison operators
+inline bool operator==(const RSMovieName& lhs, const RSMovieName& rhs);
+inline bool operator!=(const RSMovieName& lhs, const RSMovieName& rhs);
+inline bool operator<(const RSMovieName& lhs, const RSMovieName& rhs);
+
+// I/O
+inline std::ostream& operator<<(std::ostream& os, const RSMovieName& movieName);
+inline std::istream& operator>>(std::istream& is, RSMovieName& movieName);
+
+/// \}
+
+} // namespace Data
+} // namespace PacBio
+
+#include "internal/RSMovieName-inl.h"
+
+#endif // PBCOPPER_DATA_RSMOVIENAME_H
diff --git a/include/pbcopper/data/RSReadName.h b/include/pbcopper/data/RSReadName.h
new file mode 100644
index 0000000..f80650d
--- /dev/null
+++ b/include/pbcopper/data/RSReadName.h
@@ -0,0 +1,16 @@
+#ifndef PBCOPPER_DATA_RSREADNAME_H
+#define PBCOPPER_DATA_RSREADNAME_H
+
+#include "pbcopper/Config.h"
+#include "pbcopper/data/RSMovieName.h"
+#include "pbcopper/data/internal/ReadNameBase.h"
+
+namespace PacBio {
+namespace Data {
+
+typedef internal::ReadNameBase<RSMovieName> RSReadName;
+
+} // namespace Data
+} // namespace PacBio
+
+#endif // PBCOPPER_DATA_RSREADNAME_H
diff --git a/include/pbcopper/data/ReadName.h b/include/pbcopper/data/ReadName.h
new file mode 100644
index 0000000..4cf4c25
--- /dev/null
+++ b/include/pbcopper/data/ReadName.h
@@ -0,0 +1,16 @@
+#ifndef PBCOPPER_DATA_READNAME_H
+#define PBCOPPER_DATA_READNAME_H
+
+#include "pbcopper/Config.h"
+#include "pbcopper/data/MovieName.h"
+#include "pbcopper/data/internal/ReadNameBase.h"
+
+namespace PacBio {
+namespace Data {
+
+typedef internal::ReadNameBase<MovieName> ReadName;
+
+} // namespace Data
+} // namespace PacBio
+
+#endif // PBCOPPER_DATA_READNAME_H
diff --git a/include/pbcopper/data/Zmw.h b/include/pbcopper/data/Zmw.h
new file mode 100644
index 0000000..cd4c2ee
--- /dev/null
+++ b/include/pbcopper/data/Zmw.h
@@ -0,0 +1,14 @@
+#ifndef PBCOPPER_DATA_ZMW_H
+#define PBCOPPER_DATA_ZMW_H
+
+#include "pbcopper/Config.h"
+
+namespace PacBio {
+namespace Data {
+
+typedef int32_t Zmw;
+
+} // namespace Data
+} // namespace PacBio
+
+#endif // PBCOPPER_DATA_ZMW_H
diff --git a/include/pbcopper/data/internal/Interval-inl.h b/include/pbcopper/data/internal/Interval-inl.h
new file mode 100644
index 0000000..35ea121
--- /dev/null
+++ b/include/pbcopper/data/internal/Interval-inl.h
@@ -0,0 +1,87 @@
+#ifndef PBCOPPER_DATA_INTERVAL_INL_H
+#define PBCOPPER_DATA_INTERVAL_INL_H
+
+#include "pbcopper/data/Interval.h"
+
+namespace PacBio {
+namespace Data {
+
+template<typename T>
+inline Interval<T>::Interval(void)
+ : data_(boost::icl::discrete_interval<T>::right_open(0,0))
+{ }
+
+template<typename T>
+inline Interval<T>::Interval(const T val)
+ : data_(boost::icl::discrete_interval<T>::right_open(val,val+1))
+{ }
+
+template<typename T>
+inline Interval<T>::Interval(const T start, const T end)
+ : data_(boost::icl::discrete_interval<T>::right_open(start,end))
+{ }
+
+template<typename T>
+inline Interval<T>::Interval(const Interval<T>& other)
+ : data_(boost::icl::discrete_interval<T>::right_open(other.Start(), other.End()))
+{ }
+
+template<typename T>
+inline Interval<T>::Interval(Interval<T>&& other)
+ : data_(boost::icl::discrete_interval<T>::right_open(other.Start(), other.End()))
+{ }
+
+template<typename T>
+inline bool Interval<T>::operator==(const Interval<T>& other) const
+{ return data_ == other.data_; }
+
+template<typename T>
+inline bool Interval<T>::operator!=(const Interval<T>& other) const
+{ return !(data_ == other.data_); }
+
+template<typename T>
+inline bool Interval<T>::CoveredBy(const Interval<T>& other) const
+{ return boost::icl::within(data_, other.data_); }
+
+template<typename T>
+inline bool Interval<T>::Covers(const Interval<T>& other) const
+{ return boost::icl::contains(data_, other.data_); }
+
+template<typename T>
+inline T Interval<T>::End(void) const
+{ return data_.upper(); }
+
+template<typename T>
+inline Interval<T>& Interval<T>::End(const T& end)
+{
+ data_ = boost::icl::discrete_interval<T>::right_open(data_.lower(), end);
+ return *this;
+}
+
+template<typename T>
+inline bool Interval<T>::Intersects(const Interval<T>& other) const
+{ return boost::icl::intersects(data_, other.data_); }
+
+template<typename T>
+inline bool Interval<T>::IsValid(void) const
+{ return !boost::icl::is_empty(data_); }
+
+template<typename T>
+inline size_t Interval<T>::Length(void) const
+{ return boost::icl::length(data_); }
+
+template<typename T>
+inline T Interval<T>::Start(void) const
+{ return data_.lower(); }
+
+template<typename T>
+inline Interval<T>& Interval<T>::Start(const T& start)
+{
+ data_ = boost::icl::discrete_interval<T>::right_open(start, data_.upper());
+ return *this;
+}
+
+} // namespace Data
+} // namespace PacBio
+
+#endif // PBCOPPER_DATA_INTERVAL_INL_H
diff --git a/include/pbcopper/data/internal/MovieName-inl.h b/include/pbcopper/data/internal/MovieName-inl.h
new file mode 100644
index 0000000..bae02b7
--- /dev/null
+++ b/include/pbcopper/data/internal/MovieName-inl.h
@@ -0,0 +1,111 @@
+
+#ifndef PBCOPPER_DATA_MOVIENAME_INL_H
+#define PBCOPPER_DATA_MOVIENAME_INL_H
+
+#include "pbcopper/data/MovieName.h"
+#include "pbcopper/utility/StringUtils.h"
+#include <iostream>
+#include <stdexcept>
+#include <cassert>
+
+namespace PacBio {
+namespace Data {
+
+struct MovieName::PartsCache
+{
+ boost::string_ref instrumentName_;
+ boost::string_ref runStartTime_;
+};
+
+// NOTE: We're not going to re-calculate cache in copies until actually needed.
+// We can't completely re-use the original cache, since the string_refs
+// point to other string::c_str(). So we won't pay for the calculation
+// until the components are again requested. That should happen less often
+// than moving these guys around.
+
+inline MovieName::MovieName(void)
+ : partsCache_(nullptr)
+{ }
+
+inline MovieName::MovieName(const MovieName& other)
+ : movieName_(other.movieName_)
+ , partsCache_(nullptr)
+{ }
+
+inline MovieName::MovieName(MovieName&& other) noexcept
+ : movieName_(std::move(other.movieName_))
+ , partsCache_(std::move(other.partsCache_))
+{ }
+
+inline MovieName& MovieName::operator=(const MovieName& other)
+{
+ movieName_ = other.movieName_;
+ partsCache_.reset(nullptr);
+ return *this;
+}
+
+inline MovieName& MovieName::operator=(MovieName&& other) noexcept
+{
+ movieName_ = std::move(other.movieName_);
+ partsCache_ = std::move(other.partsCache_);
+ return *this;
+}
+
+inline MovieName::MovieName(const std::string& name)
+ : movieName_(name)
+ , partsCache_(nullptr)
+{ }
+
+inline MovieName::MovieName(std::string&& name)
+ : movieName_(std::move(name))
+ , partsCache_(nullptr)
+{ }
+
+inline MovieName::~MovieName(void) { }
+
+inline boost::string_ref MovieName::InstrumentName(void) const
+{
+ if (!partsCache_)
+ UpdatePartsCache();
+ assert(partsCache_);
+ return partsCache_->instrumentName_;
+}
+
+inline boost::string_ref MovieName::RunStartTime(void) const
+{
+ if (!partsCache_)
+ UpdatePartsCache();
+ assert(partsCache_);
+ return partsCache_->runStartTime_;
+}
+
+inline std::string MovieName::ToStdString(void)const
+{ return movieName_; }
+
+inline bool operator==(const MovieName& lhs, const MovieName& rhs)
+{ return lhs.ToStdString() == rhs.ToStdString(); }
+
+inline bool operator!=(const MovieName& lhs, const MovieName& rhs)
+{ return !(lhs == rhs); }
+
+inline bool operator<(const MovieName& lhs, const MovieName& rhs)
+{ return lhs.ToStdString() < rhs.ToStdString(); }
+
+inline std::ostream& operator<<(std::ostream& os, const MovieName& movieName)
+{
+ os << movieName.ToStdString();
+ return os;
+}
+
+inline std::istream& operator>>(std::istream& is, MovieName& movieName)
+{
+ auto s = std::string{ };
+ is >> s;
+ movieName = MovieName{ std::move(s) };
+ return is;
+}
+
+} // namespace Data
+} // namespace PacBio
+
+#endif // PBCOPPER_DATA_MOVIENAME_INL_H
diff --git a/include/pbcopper/data/internal/RSMovieName-inl.h b/include/pbcopper/data/internal/RSMovieName-inl.h
new file mode 100644
index 0000000..82d05a2
--- /dev/null
+++ b/include/pbcopper/data/internal/RSMovieName-inl.h
@@ -0,0 +1,144 @@
+
+#ifndef PBCOPPER_DATA_RSMOVIENAME_INL_H
+#define PBCOPPER_DATA_RSMOVIENAME_INL_H
+
+#include "pbcopper/data/RSMovieName.h"
+#include "pbcopper/utility/StringUtils.h"
+#include <iostream>
+#include <stdexcept>
+#include <cassert>
+
+namespace PacBio {
+namespace Data {
+
+struct RSMovieName::PartsCache
+{
+ boost::string_ref runStartTime_;
+ boost::string_ref serialNumber_;
+ boost::string_ref smrtCellBarcode_;
+ boost::string_ref setNumber_;
+ boost::string_ref partNumber_;
+};
+
+// NOTE: We're not going to re-calculate cache in copies until actually needed.
+// We can't completely re-use the original cache, since the string_refs
+// point to other string::c_str(). So we won't pay for the calculation
+// until the components are again requested. That should happen less often
+// than moving these guys around.
+
+inline RSMovieName::RSMovieName(void)
+ : partsCache_(nullptr)
+{ }
+
+inline RSMovieName::RSMovieName(const RSMovieName& other)
+ : movieName_(other.movieName_)
+ , partsCache_(nullptr)
+{ }
+
+inline RSMovieName::RSMovieName(RSMovieName&& other) noexcept
+ : movieName_(std::move(other.movieName_))
+ , partsCache_(std::move(other.partsCache_))
+{ }
+
+inline RSMovieName& RSMovieName::operator=(const RSMovieName& other)
+{
+ movieName_ = other.movieName_;
+ partsCache_.reset(nullptr);
+ return *this;
+}
+
+inline RSMovieName& RSMovieName::operator=(RSMovieName&& other) noexcept
+{
+ movieName_ = std::move(other.movieName_);
+ partsCache_ = std::move(other.partsCache_);
+ return *this;
+}
+
+inline RSMovieName::RSMovieName(const std::string& name)
+ : movieName_(name)
+ , partsCache_(nullptr)
+{ }
+
+inline RSMovieName::RSMovieName(std::string&& name)
+ : movieName_(std::move(name))
+ , partsCache_(nullptr)
+{ }
+
+inline RSMovieName::~RSMovieName(void) { }
+
+inline boost::string_ref RSMovieName::InstrumentSerialNumber(void) const
+{
+ if (!partsCache_)
+ UpdatePartsCache();
+ assert(partsCache_);
+ return partsCache_->serialNumber_;
+}
+
+inline bool RSMovieName::IsReagentExpired(void) const
+{
+ const auto expiredStatus = PartNumber().at(0);
+ return expiredStatus == 'X' || expiredStatus == 'x';
+}
+
+inline boost::string_ref RSMovieName::PartNumber(void) const
+{
+ if (!partsCache_)
+ UpdatePartsCache();
+ assert(partsCache_);
+ return partsCache_->partNumber_;
+}
+
+inline boost::string_ref RSMovieName::RunStartTime(void) const
+{
+ if (!partsCache_)
+ UpdatePartsCache();
+ assert(partsCache_);
+ return partsCache_->runStartTime_;
+}
+
+inline boost::string_ref RSMovieName::SetNumber(void) const
+{
+ if (!partsCache_)
+ UpdatePartsCache();
+ assert(partsCache_);
+ return partsCache_->setNumber_;
+}
+
+inline boost::string_ref RSMovieName::SMRTCellBarcode(void) const
+{
+ if (!partsCache_)
+ UpdatePartsCache();
+ assert(partsCache_);
+ return partsCache_->smrtCellBarcode_;
+}
+
+inline std::string RSMovieName::ToStdString(void)const
+{ return movieName_; }
+
+inline bool operator==(const RSMovieName& lhs, const RSMovieName& rhs)
+{ return lhs.ToStdString() == rhs.ToStdString(); }
+
+inline bool operator!=(const RSMovieName& lhs, const RSMovieName& rhs)
+{ return !(lhs == rhs); }
+
+inline bool operator<(const RSMovieName& lhs, const RSMovieName& rhs)
+{ return lhs.ToStdString() < rhs.ToStdString(); }
+
+inline std::ostream& operator<<(std::ostream& os, const RSMovieName& movieName)
+{
+ os << movieName.ToStdString();
+ return os;
+}
+
+inline std::istream& operator>>(std::istream& is, RSMovieName& movieName)
+{
+ auto s = std::string{ };
+ is >> s;
+ movieName = RSMovieName{ std::move(s) };
+ return is;
+}
+
+} // namespace Data
+} // namespace PacBio
+
+#endif // PBCOPPER_DATA_RSMOVIENAME_INL_H
diff --git a/include/pbcopper/data/internal/ReadNameBase-inl.h b/include/pbcopper/data/internal/ReadNameBase-inl.h
new file mode 100644
index 0000000..0ffeff4
--- /dev/null
+++ b/include/pbcopper/data/internal/ReadNameBase-inl.h
@@ -0,0 +1,252 @@
+#ifndef PBCOPPER_DATA_READNAMEBASE_INL_H
+#define PBCOPPER_DATA_READNAMEBASE_INL_H
+
+#include "pbcopper/data/internal/ReadNameBase.h"
+#include "pbcopper/utility/StringUtils.h"
+#include <stdexcept>
+
+namespace PacBio {
+namespace Data {
+namespace internal {
+
+template<typename MovieNameType>
+inline ReadNameBase<MovieNameType>::ReadNameBase(void)
+ : movieName_()
+ , zmw_(-1)
+ , queryInterval_(nullptr)
+{ }
+
+template<typename MovieNameType>
+inline ReadNameBase<MovieNameType>::ReadNameBase(const std::string& name)
+{
+ auto copy = std::string{ name };
+ FromString(std::move(copy));
+ Check();
+}
+
+template<typename MovieNameType>
+inline ReadNameBase<MovieNameType>::ReadNameBase(std::string&& name)
+{
+ FromString(std::move(name));
+ Check();
+}
+
+template<typename MovieNameType>
+inline ReadNameBase<MovieNameType>::ReadNameBase(const MovieNameType& movieName,
+ const PacBio::Data::Zmw& zmw,
+ const Interval<Position>& queryInterval)
+ : movieName_(movieName)
+ , zmw_(zmw)
+ , queryInterval_(new Interval<Position>{ queryInterval })
+{ }
+
+template<typename MovieNameType>
+inline ReadNameBase<MovieNameType>::ReadNameBase(const MovieNameType& movieName,
+ const PacBio::Data::Zmw& zmw,
+ const Position& queryStart,
+ const Position& queryEnd)
+ : ReadNameBase<MovieNameType>(movieName,
+ zmw,
+ Interval<Position>(queryStart, queryEnd))
+{ }
+
+template<typename MovieNameType>
+inline ReadNameBase<MovieNameType>::ReadNameBase(const MovieNameType& movieName,
+ const PacBio::Data::Zmw& zmw,
+ const CCSTag)
+ : movieName_(movieName)
+ , zmw_(zmw)
+ , queryInterval_(nullptr)
+{ }
+
+template<typename MovieNameType>
+inline bool ReadNameBase<MovieNameType>::IsCCS(void) const
+{ return !queryInterval_; }
+
+template<typename MovieNameType>
+inline MovieNameType ReadNameBase<MovieNameType>::MovieName(void) const
+{ return movieName_; }
+
+template<typename MovieNameType>
+inline Interval<Position> ReadNameBase<MovieNameType>::QueryInterval(void) const
+{
+ if (IsCCS())
+ throw std::runtime_error("ReadName: cannot get query interval from CCS read");
+ return *queryInterval_;
+}
+
+template<typename MovieNameType>
+inline Position ReadNameBase<MovieNameType>::QueryStart(void) const
+{
+ if (IsCCS())
+ throw std::runtime_error("ReadName: cannot get query start from CCS read");
+ return queryInterval_->Start();
+}
+
+template<typename MovieNameType>
+inline Position ReadNameBase<MovieNameType>::QueryEnd(void) const
+{
+ if (IsCCS())
+ throw std::runtime_error("ReadName: cannot get query end from CCS read");
+ return queryInterval_->End();
+}
+
+template<typename MovieNameType>
+inline PacBio::Data::Zmw ReadNameBase<MovieNameType>::Zmw(void) const
+{ return zmw_; }
+
+template<typename MovieNameType>
+inline bool ReadNameBase<MovieNameType>::operator==(const ReadNameBase<MovieNameType>& other) const
+{
+ // simple int check first
+ if (zmw_ != other.zmw_)
+ return false;
+
+ // not equal if one is CCS and one is not
+ if (IsCCS() != other.IsCCS())
+ return false;
+ else {
+ // reads share same CCS status, check intervals if both non-CCS
+ if (!IsCCS()) {
+ assert(queryInterval_);
+ assert(other.queryInterval_);
+ if (*queryInterval_ != *other.queryInterval_)
+ return false;
+ }
+ }
+
+ // else compare on movie
+ return movieName_ == other.movieName_;
+}
+
+template<typename MovieNameType>
+inline bool ReadNameBase<MovieNameType>::operator<(const ReadNameBase<MovieNameType>& other) const
+{
+ // sort by:
+ // 1 - movie name
+ // 2 - zmw hole number
+ // 3 - query_interval (CCS to end)
+
+ if (movieName_ != other.movieName_)
+ return movieName_ < other.movieName_;
+ if (zmw_ != other.zmw_)
+ return zmw_ < other.zmw_;
+
+ // if this read name is CCS, then we're either never less-than a subread
+ // with query interval... or the other read is the same read name, so not
+ // "less than" either
+ if (IsCCS())
+ return false;
+
+ // this read is non-CCS. so if other is CCS, then we are always "less-than"
+ else if (other.IsCCS())
+ return true;
+
+ // if here, both non-CCS, compare on query interval
+ assert(!IsCCS());
+ assert(!other.IsCCS());
+ const auto thisInterval = *queryInterval_;
+ const auto otherInterval = *other.queryInterval_;
+ if (thisInterval.Start() == otherInterval.Start())
+ return thisInterval.End() < otherInterval.End();
+ return thisInterval.End() < otherInterval.End();
+}
+
+template<typename MovieNameType>
+inline void ReadNameBase<MovieNameType>::Check(void) const
+{
+ if (movieName_.ToStdString().empty())
+ throw std::runtime_error("ReadName: movie name must not be empty");
+
+ if (zmw_ < 0)
+ throw std::runtime_error("ReadName: ZMW hole number must be a positive integer");
+
+ if (!IsCCS()) {
+ if (QueryStart() < 0)
+ throw std::runtime_error("ReadName: query start must be a positive integer");
+ if (QueryEnd() < 0)
+ throw std::runtime_error("ReadName: query end must be a positive integer");
+ }
+}
+
+template<typename MovieNameType>
+inline void ReadNameBase<MovieNameType>::FromString(std::string&& name)
+{
+ // ensure clean slate
+ movieName_ = MovieNameType{ };
+ zmw_ = -1;
+ queryInterval_.reset(nullptr);
+
+ // parse name parts
+ if (name.empty())
+ return;
+ auto parts = PacBio::Utility::Split(name, '/');
+ if (parts.size() != 3)
+ return;
+
+ // rip out & store name parts
+ movieName_ = MovieNameType{ std::move(parts.at(0)) };
+ zmw_ = std::stoi(parts.at(1));
+ if (parts.at(2) != "ccs") {
+ auto queryParts = PacBio::Utility::Split(parts.at(2), '_');
+ if (queryParts.size() != 2)
+ return;
+ const Position queryStart = std::stoi(queryParts.at(0));
+ const Position queryEnd = std::stoi(queryParts.at(1));
+ queryInterval_.reset(new Interval<Position>{ queryStart, queryEnd });
+ }
+}
+
+template<typename MovieNameType>
+inline std::string ReadNameBase<MovieNameType>::ToString(void) const
+{
+ // ensure we're OK
+ Check();
+
+ // construct name from parts
+ std::string result;
+ result.reserve(128);
+ result += movieName_.ToStdString();
+ result += "/";
+ result += std::to_string(zmw_);
+ result += "/";
+
+ if (IsCCS()) {
+ result += "ccs";
+ } else {
+ result += std::to_string(queryInterval_->Start());
+ result += "_";
+ result += std::to_string(queryInterval_->End());
+ }
+
+ return result;
+}
+
+template<typename MovieNameType>
+inline bool operator!=(const ReadNameBase<MovieNameType>& lhs,
+ const ReadNameBase<MovieNameType>& rhs)
+{ return !(lhs == rhs); }
+
+template<typename MovieNameType>
+inline std::ostream& operator<<(std::ostream& os,
+ const ReadNameBase<MovieNameType>& readName)
+{
+ os << readName.ToString();
+ return os;
+}
+
+template<typename MovieNameType>
+inline std::istream& operator>>(std::istream& is,
+ ReadNameBase<MovieNameType>& readName)
+{
+ std::string s;
+ is >> s;
+ readName = ReadNameBase<MovieNameType>{ std::move(s) };
+ return is;
+}
+
+} // namespace internal
+} // namespace Data
+} // namespace PacBio
+
+#endif // PBCOPPER_DATA_READNAMEBASE_INL_H
diff --git a/include/pbcopper/data/internal/ReadNameBase.h b/include/pbcopper/data/internal/ReadNameBase.h
new file mode 100644
index 0000000..40d3d07
--- /dev/null
+++ b/include/pbcopper/data/internal/ReadNameBase.h
@@ -0,0 +1,103 @@
+#ifndef PBCOPPER_DATA_READNAMEBASE_H
+#define PBCOPPER_DATA_READNAMEBASE_H
+
+#include "pbcopper/Config.h"
+#include "pbcopper/data/CCSTag.h"
+#include "pbcopper/data/Interval.h"
+#include "pbcopper/data/MovieName.h"
+#include "pbcopper/data/Position.h"
+#include "pbcopper/data/Zmw.h"
+
+namespace PacBio {
+namespace Data {
+namespace internal {
+
+template<typename MovieNameType>
+class ReadNameBase
+{
+public:
+ /// \name Constructors & Related Methods
+ /// \{
+
+ // create ReadNameBase from string
+ explicit ReadNameBase(const std::string& name);
+ explicit ReadNameBase(std::string&& name);
+
+ // create ReadName from name parts
+ ReadNameBase(const MovieNameType& movieName,
+ const PacBio::Data::Zmw& zmw,
+ const Interval<Position>& queryInterval);
+
+ ReadNameBase(const MovieNameType& movieName,
+ const PacBio::Data::Zmw& zmw,
+ const Position& queryStart,
+ const Position& queryEnd);
+
+ ReadNameBase(const MovieNameType& movieName,
+ const PacBio::Data::Zmw& zmw,
+ const CCSTag ccs);
+
+ ReadNameBase(void);
+ ReadNameBase(const ReadNameBase<MovieNameType>& other) = default;
+ ReadNameBase(ReadNameBase<MovieNameType>&& other) = default;
+ ReadNameBase<MovieNameType>& operator=(const ReadNameBase<MovieNameType>& other) = default;
+ ReadNameBase<MovieNameType>& operator=(ReadNameBase<MovieNameType>&& other) = default;
+ ~ReadNameBase(void) = default;
+
+ /// \}
+
+public:
+ /// \name Name Parts
+ /// \{
+
+ MovieNameType MovieName(void) const;
+ PacBio::Data::Zmw Zmw(void) const;
+ Interval<Position> QueryInterval(void) const;
+ Position QueryStart(void) const;
+ Position QueryEnd(void) const;
+
+ /// \}
+
+public:
+ /// \name Additional Methods & Operators
+ /// \{
+
+ bool IsCCS(void) const;
+ std::string ToString(void) const;
+
+ bool operator==(const ReadNameBase<MovieNameType>& other) const;
+ bool operator<(const ReadNameBase<MovieNameType>& other) const;
+
+ /// \}
+
+private:
+ MovieNameType movieName_;
+ PacBio::Data::Zmw zmw_;
+ std::unique_ptr<Interval<Position>> queryInterval_;
+
+private:
+ void Check(void) const;
+ void FromString(std::string&& name);
+};
+
+// add'l comparison operators
+template<typename MovieNameType>
+inline bool operator!=(const ReadNameBase<MovieNameType>& lhs,
+ const ReadNameBase<MovieNameType>& rhs);
+
+// I/O
+template<typename MovieNameType>
+inline std::ostream& operator<<(std::ostream& os,
+ const ReadNameBase<MovieNameType>& readName);
+
+template<typename MovieNameType>
+inline std::istream& operator>>(std::istream& is,
+ ReadNameBase<MovieNameType>& readName);
+
+} // namespace internal
+} // namespace Data
+} // namespace PacBio
+
+#include "ReadNameBase-inl.h"
+
+#endif // PBCOPPER_DATA_READNAMEBASE_H
diff --git a/include/pbcopper/json/JSON.h b/include/pbcopper/json/JSON.h
new file mode 100644
index 0000000..1043972
--- /dev/null
+++ b/include/pbcopper/json/JSON.h
@@ -0,0 +1,22 @@
+#ifndef PBCOPPER_JSON_JSON_H
+#define PBCOPPER_JSON_JSON_H
+
+#include "pbcopper/Config.h"
+#include "pbcopper/json/internal/json.hpp"
+
+//
+// Simple wrapper around nlohmann's JSON implementation:
+// https://github.com/nlohmann/json
+//
+// Currently wrapping commit: a3f432b3dde1d71c8940961947db5938ed11ee91
+//
+
+namespace PacBio {
+namespace JSON {
+
+typedef nlohmann::json Json;
+
+} // namespace JSON
+} // namespace PacBio
+
+#endif // PBCOPPER_JSON_JSON_H
diff --git a/include/pbcopper/json/internal/json.hpp b/include/pbcopper/json/internal/json.hpp
new file mode 100644
index 0000000..4364676
--- /dev/null
+++ b/include/pbcopper/json/internal/json.hpp
@@ -0,0 +1,10182 @@
+/*
+ __ _____ _____ _____
+ __| | __| | | | JSON for Modern C++
+| | |__ | | | | | | version 2.0.0
+|_____|_____|_____|_|___| https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+Copyright (c) 2013-2016 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#ifndef NLOHMANN_JSON_HPP
+#define NLOHMANN_JSON_HPP
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cerrno>
+#include <ciso646>
+#include <cmath>
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>
+#include <functional>
+#include <initializer_list>
+#include <iomanip>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+// 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
+
+/*!
+ at brief namespace for Niels Lohmann
+ at see https://github.com/nlohmann
+ at since version 1.0.0
+*/
+namespace nlohmann
+{
+
+
+/*!
+ at brief unnamed namespace with internal helper functions
+ at since version 1.0.0
+*/
+namespace
+{
+/*!
+ at brief Helper to determine whether there's a key_type for T.
+ at sa http://stackoverflow.com/a/7728728/266378
+*/
+template<typename T>
+struct has_mapped_type
+{
+ private:
+ template<typename C> static char test(typename C::mapped_type*);
+ template<typename C> static char (&test(...))[2];
+ public:
+ static constexpr bool value = sizeof(test<T>(0)) == 1;
+};
+
+/*!
+ at brief helper class to create locales with decimal point
+ at sa https://github.com/nlohmann/json/issues/51#issuecomment-86869315
+*/
+class DecimalSeparator : public std::numpunct<char>
+{
+ protected:
+ char do_decimal_point() const
+ {
+ return '.';
+ }
+};
+
+}
+
+/*!
+ at brief a class to store JSON values
+
+ at tparam ObjectType type for JSON objects (`std::map` by default; will be used
+in @ref object_t)
+ at tparam ArrayType type for JSON arrays (`std::vector` by default; will be used
+in @ref array_t)
+ at tparam StringType type for JSON strings and object keys (`std::string` by
+default; will be used in @ref string_t)
+ at tparam BooleanType type for JSON booleans (`bool` by default; will be used
+in @ref boolean_t)
+ at tparam NumberIntegerType type for JSON integer numbers (`int64_t` by
+default; will be used in @ref number_integer_t)
+ at tparam NumberUnsignedType type for JSON unsigned integer numbers (@c
+`uint64_t` by default; will be used in @ref number_unsigned_t)
+ at tparam NumberFloatType type for JSON floating-point numbers (`double` by
+default; will be used in @ref number_float_t)
+ at tparam AllocatorType type of the allocator to use (`std::allocator` by
+default)
+
+ at 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.
+
+ at internal
+ at note ObjectType trick from http://stackoverflow.com/a/9860911
+ at endinternal
+
+ at see [RFC 7159: The JavaScript Object Notation (JSON) Data Interchange
+Format](http://rfc7159.net/rfc7159)
+
+ at since version 1.0.0
+
+ at nosubgrouping
+*/
+template <
+ template<typename U, typename V, typename... Args> class ObjectType = std::map,
+ template<typename U, typename... Args> class ArrayType = std::vector,
+ class StringType = std::string,
+ class BooleanType = bool,
+ class NumberIntegerType = std::int64_t,
+ class NumberUnsignedType = std::uint64_t,
+ class NumberFloatType = double,
+ template<typename U> class AllocatorType = std::allocator
+ >
+class basic_json
+{
+ private:
+ /// workaround type for MSVC
+ using basic_json_t = basic_json<ObjectType,
+ ArrayType,
+ StringType,
+ BooleanType,
+ NumberIntegerType,
+ NumberUnsignedType,
+ NumberFloatType,
+ AllocatorType>;
+
+ public:
+ // forward declarations
+ template<typename Base> class json_reverse_iterator;
+ class json_pointer;
+
+ /////////////////////
+ // container types //
+ /////////////////////
+
+ /// @name container types
+ /// @{
+
+ /// the type of elements in a basic_json container
+ using value_type = basic_json;
+
+ /// the type of an element reference
+ using reference = value_type&;
+ /// the type of an element const reference
+ using const_reference = const value_type&;
+
+ /// a type to represent differences between iterators
+ using difference_type = std::ptrdiff_t;
+ /// a type to represent container sizes
+ using size_type = std::size_t;
+
+ /// the allocator type
+ using allocator_type = AllocatorType<basic_json>;
+
+ /// the type of an element pointer
+ using pointer = typename std::allocator_traits<allocator_type>::pointer;
+ /// the type of an element const pointer
+ using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+
+ /// an iterator for a basic_json container
+ class iterator;
+ /// a const iterator for a basic_json container
+ class const_iterator;
+ /// a reverse iterator for a basic_json container
+ using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
+ /// a const reverse iterator for a basic_json container
+ using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
+
+ /// @}
+
+
+ /*!
+ @brief returns the allocator associated with the container
+ */
+ static allocator_type get_allocator()
+ {
+ return allocator_type();
+ }
+
+
+ ///////////////////////////
+ // JSON value data types //
+ ///////////////////////////
+
+ /// @name JSON value data types
+ /// @{
+
+ /*!
+ @brief a type for an object
+
+ [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:
+ > An object is an unordered collection of zero or more name/value pairs,
+ > where a name is a string and a value is a string, number, boolean, null,
+ > object, or array.
+
+ To store objects in C++, a type is defined by the template parameters
+ described below.
+
+ @tparam ObjectType the container to store objects (e.g., `std::map` or
+ `std::unordered_map`)
+ @tparam StringType the type of the keys or names (e.g., `std::string`).
+ The comparison function `std::less<StringType>` is used to order elements
+ inside the container.
+ @tparam AllocatorType the allocator to use for objects (e.g.,
+ `std::allocator`)
+
+ #### Default type
+
+ With the default values for @a ObjectType (`std::map`), @a StringType
+ (`std::string`), and @a AllocatorType (`std::allocator`), the default
+ value for @a object_t is:
+
+ @code {.cpp}
+ std::map<
+ std::string, // key_type
+ basic_json, // value_type
+ std::less<std::string>, // key_compare
+ std::allocator<std::pair<const std::string, basic_json>> // allocator_type
+ >
+ @endcode
+
+ #### Behavior
+
+ The choice of @a object_t influences the behavior of the JSON class. With
+ the default type, objects have the following behavior:
+
+ - When all names are unique, objects will be interoperable in the sense
+ that all software implementations receiving that object will agree on
+ the name-value mappings.
+ - When the names within an object are not unique, later stored name/value
+ pairs overwrite previously stored name/value pairs, leaving the used
+ names unique. For instance, `{"key": 1}` and `{"key": 2, "key": 1}` will
+ be treated as equal and both stored as `{"key": 1}`.
+ - Internally, name/value pairs are stored in lexicographical order of the
+ names. Objects will also be serialized (see @ref dump) in this order.
+ For instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored
+ and serialized as `{"a": 2, "b": 1}`.
+ - When comparing objects, the order of the name/value pairs is irrelevant.
+ This makes objects interoperable in the sense that they will not be
+ affected by these differences. For instance, `{"b": 1, "a": 2}` and
+ `{"a": 2, "b": 1}` will be treated as equal.
+
+ #### Limits
+
+ [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+ > An implementation may set limits on the maximum depth of nesting.
+
+ In this class, the object's limit of nesting is not constraint explicitly.
+ However, a maximum depth of nesting may be introduced by the compiler or
+ runtime environment. A theoretical limit can be queried by calling the
+ @ref max_size function of a JSON object.
+
+ #### Storage
+
+ Objects are stored as pointers in a @ref basic_json type. That is, for any
+ access to object values, a pointer of type `object_t*` must be
+ dereferenced.
+
+ @sa @ref array_t -- type for an array value
+
+ @since version 1.0.0
+
+ @note The order name/value pairs are added to the object is *not*
+ preserved by the library. Therefore, iterating an object may return
+ name/value pairs in a different order than they were originally stored. In
+ fact, keys will be traversed in alphabetical order as `std::map` with
+ `std::less` is used by default. Please note this behavior conforms to [RFC
+ 7159](http://rfc7159.net/rfc7159), because any order implements the
+ specified "unordered" nature of JSON objects.
+ */
+ using object_t = ObjectType<StringType,
+ basic_json,
+ std::less<StringType>,
+ AllocatorType<std::pair<const StringType,
+ basic_json>>>;
+
+ /*!
+ @brief a type for an array
+
+ [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:
+ > An array is an ordered sequence of zero or more values.
+
+ To store objects in C++, a type is defined by the template parameters
+ explained below.
+
+ @tparam ArrayType container type to store arrays (e.g., `std::vector` or
+ `std::list`)
+ @tparam AllocatorType allocator to use for arrays (e.g., `std::allocator`)
+
+ #### Default type
+
+ With the default values for @a ArrayType (`std::vector`) and @a
+ AllocatorType (`std::allocator`), the default value for @a array_t is:
+
+ @code {.cpp}
+ std::vector<
+ basic_json, // value_type
+ std::allocator<basic_json> // allocator_type
+ >
+ @endcode
+
+ #### Limits
+
+ [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+ > An implementation may set limits on the maximum depth of nesting.
+
+ In this class, the array's limit of nesting is not constraint explicitly.
+ However, a maximum depth of nesting may be introduced by the compiler or
+ runtime environment. A theoretical limit can be queried by calling the
+ @ref max_size function of a JSON array.
+
+ #### Storage
+
+ Arrays are stored as pointers in a @ref basic_json type. That is, for any
+ access to array values, a pointer of type `array_t*` must be dereferenced.
+
+ @sa @ref object_t -- type for an object value
+
+ @since version 1.0.0
+ */
+ using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
+
+ /*!
+ @brief a type for a string
+
+ [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:
+ > A string is a sequence of zero or more Unicode characters.
+
+ To store objects in C++, a type is defined by the template parameter
+ described below. Unicode values are split by the JSON class into
+ byte-sized characters during deserialization.
+
+ @tparam StringType the container to store strings (e.g., `std::string`).
+ Note this container is used for keys/names in objects, see @ref object_t.
+
+ #### Default type
+
+ With the default values for @a StringType (`std::string`), the default
+ value for @a string_t is:
+
+ @code {.cpp}
+ std::string
+ @endcode
+
+ #### 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;
+
+ /// @}
+
+
+ ///////////////////////////
+ // 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 is_null(), @ref
+ is_object(), @ref is_array(), @ref is_string(), @ref is_boolean(), @ref
+ is_number(), and @ref is_discarded() rely on it.
+
+ @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 (integer)
+ number_unsigned, ///< number value (unsigned integer)
+ number_float, ///< number value (floating-point)
+ discarded ///< discarded by the the parser callback function
+ };
+
+
+ private:
+
+ /*!
+ @brief a type to hold JSON type information
+
+ This bitfield type holds information about JSON types. It is internally
+ used to hold the basic JSON type enumeration, as well as additional
+ information in the case of values that have been parsed from a string
+ including whether of not it was created directly or parsed, and in the
+ case of floating point numbers the number of significant figures in the
+ original representaiton and if it was in exponential form, if a '+' was
+ included in the exponent and the capitilization of the exponent marker.
+ The sole purpose of this information is to permit accurate round trips.
+
+ @since version 2.0.0
+ */
+ union type_data_t
+ {
+ struct
+ {
+ /// the type of the value (@ref value_t)
+ uint16_t type : 4;
+ /// whether the number was parsed from a string
+ uint16_t parsed : 1;
+ /// whether parsed number contained an exponent ('e'/'E')
+ uint16_t has_exp : 1;
+ /// whether parsed number contained a plus in the exponent
+ uint16_t exp_plus : 1;
+ /// whether parsed number's exponent was capitalized ('E')
+ uint16_t exp_cap : 1;
+ /// the number of figures for a parsed number
+ uint16_t precision : 8;
+ } bits;
+ uint16_t data;
+
+ /// return the type as value_t
+ operator value_t() const
+ {
+ return static_cast<value_t>(bits.type);
+ }
+
+ /// test type for equality (ignore other fields)
+ bool operator==(const value_t& rhs) const
+ {
+ return static_cast<value_t>(bits.type) == rhs;
+ }
+
+ /// assignment
+ type_data_t& operator=(value_t rhs)
+ {
+ bits.type = static_cast<uint16_t>(rhs) & 15; // avoid overflow
+ return *this;
+ }
+
+ /// construct from value_t
+ type_data_t(value_t t) noexcept
+ {
+ *reinterpret_cast<uint16_t*>(this) = 0;
+ bits.type = static_cast<uint16_t>(t) & 15; // avoid overflow
+ }
+
+ /// default constructor
+ type_data_t() noexcept
+ {
+ data = 0;
+ bits.type = reinterpret_cast<uint16_t>(value_t::null);
+ }
+ };
+
+ /// helper for exception-safe object creation
+ template<typename T, typename... Args>
+ static T* create(Args&& ... args)
+ {
+ AllocatorType<T> alloc;
+ auto deleter = [&](T * object)
+ {
+ alloc.deallocate(object, 1);
+ };
+ std::unique_ptr<T, decltype(deleter)> object(alloc.allocate(1), deleter);
+ alloc.construct(object.get(), std::forward<Args>(args)...);
+ return object.release();
+ }
+
+ ////////////////////////
+ // JSON value storage //
+ ////////////////////////
+
+ /*!
+ @brief a JSON value
+
+ The actual storage for a JSON value of the @ref basic_json class.
+
+ @since version 1.0.0
+ */
+ union json_value
+ {
+ /// object (stored with pointer to save storage)
+ object_t* object;
+ /// array (stored with pointer to save storage)
+ array_t* array;
+ /// string (stored with pointer to save storage)
+ string_t* string;
+ /// boolean
+ boolean_t boolean;
+ /// number (integer)
+ number_integer_t number_integer;
+ /// number (unsigned integer)
+ number_unsigned_t number_unsigned;
+ /// number (floating-point)
+ number_float_t number_float;
+
+ /// default constructor (for null values)
+ json_value() = default;
+ /// constructor for booleans
+ json_value(boolean_t v) noexcept : boolean(v) {}
+ /// constructor for numbers (integer)
+ json_value(number_integer_t v) noexcept : number_integer(v) {}
+ /// constructor for numbers (unsigned)
+ json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
+ /// constructor for numbers (floating-point)
+ json_value(number_float_t v) noexcept : number_float(v) {}
+ /// constructor for empty values of a given type
+ json_value(value_t t)
+ {
+ switch (t)
+ {
+ case value_t::object:
+ {
+ object = create<object_t>();
+ break;
+ }
+
+ case value_t::array:
+ {
+ array = create<array_t>();
+ break;
+ }
+
+ case value_t::string:
+ {
+ string = create<string_t>("");
+ break;
+ }
+
+ case value_t::boolean:
+ {
+ boolean = boolean_t(false);
+ break;
+ }
+
+ case value_t::number_integer:
+ {
+ number_integer = number_integer_t(0);
+ break;
+ }
+
+ case value_t::number_unsigned:
+ {
+ number_unsigned = number_unsigned_t(0);
+ break;
+ }
+
+ case value_t::number_float:
+ {
+ number_float = number_float_t(0.0);
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+ /// constructor for strings
+ json_value(const string_t& value)
+ {
+ string = create<string_t>(value);
+ }
+
+ /// constructor for objects
+ json_value(const object_t& value)
+ {
+ object = create<object_t>(value);
+ }
+
+ /// constructor for arrays
+ json_value(const array_t& value)
+ {
+ array = create<array_t>(value);
+ }
+ };
+
+
+ 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.
+
+ @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&, parser_callback_t) or
+ @ref parse(const string_t&, 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
+
+ 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 string_t&, parser_callback_t) for examples
+
+ @since version 1.0.0
+ */
+ using parser_callback_t = std::function<bool(int depth, parse_event_t event, basic_json& parsed)>;
+
+
+ //////////////////
+ // constructors //
+ //////////////////
+
+ /// @name constructors and destructors
+ /// @{
+
+ /*!
+ @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}
+
+ @sa @ref basic_json(std::nullptr_t) -- create a `null` value
+ @sa @ref basic_json(boolean_t value) -- create a boolean value
+ @sa @ref basic_json(const string_t&) -- create a string value
+ @sa @ref basic_json(const object_t&) -- create a object value
+ @sa @ref basic_json(const array_t&) -- create a array value
+ @sa @ref basic_json(const number_float_t) -- create a number
+ (floating-point) value
+ @sa @ref basic_json(const number_integer_t) -- create a number (integer)
+ value
+ @sa @ref basic_json(const number_unsigned_t) -- create a number (unsigned)
+ value
+
+ @since version 1.0.0
+ */
+ basic_json(const value_t value_type)
+ : m_type(value_type), m_value(value_type)
+ {}
+
+ /*!
+ @brief create a null object (implicitly)
+
+ Create a `null` JSON value. This is the implicit version of the `null`
+ value constructor as it takes no parameters.
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this constructor 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.
+ - As postcondition, it holds: `basic_json().empty() == true`.
+
+ @liveexample{The following code shows the constructor for a `null` JSON
+ value.,basic_json}
+
+ @sa @ref basic_json(std::nullptr_t) -- create a `null` value
+
+ @since version 1.0.0
+ */
+ basic_json() = default;
+
+ /*!
+ @brief create a null object (explicitly)
+
+ Create a `null` JSON value. This is the explicitly version of the `null`
+ value constructor as it takes a null pointer as parameter. It allows to
+ create `null` values by explicitly assigning a `nullptr` to a JSON value.
+ 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 null pointer
+ parameter.,basic_json__nullptr_t}
+
+ @sa @ref basic_json() -- default constructor (implicitly creating a `null`
+ value)
+
+ @since version 1.0.0
+ */
+ basic_json(std::nullptr_t) noexcept
+ : basic_json(value_t::null)
+ {}
+
+ /*!
+ @brief create an object (explicit)
+
+ Create an object JSON value with a given content.
+
+ @param[in] val a value for the object
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for object value fails
+
+ @liveexample{The following code shows the constructor with an @ref
+ object_t parameter.,basic_json__object_t}
+
+ @sa @ref basic_json(const CompatibleObjectType&) -- create an object value
+ from a compatible STL container
+
+ @since version 1.0.0
+ */
+ basic_json(const object_t& val)
+ : m_type(value_t::object), m_value(val)
+ {}
+
+ /*!
+ @brief create an object (implicit)
+
+ Create an object JSON value with a given content. This constructor allows
+ any type @a CompatibleObjectType that can be used to construct values of
+ type @ref object_t.
+
+ @tparam CompatibleObjectType An object type whose `key_type` and
+ `value_type` is compatible to @ref object_t. Examples include `std::map`,
+ `std::unordered_map`, `std::multimap`, and `std::unordered_multimap` with
+ a `key_type` of `std::string`, and a `value_type` from which a @ref
+ basic_json value can be constructed.
+
+ @param[in] val a value for the object
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for object value fails
+
+ @liveexample{The following code shows the constructor with several
+ compatible object type parameters.,basic_json__CompatibleObjectType}
+
+ @sa @ref basic_json(const object_t&) -- create an object value
+
+ @since version 1.0.0
+ */
+ template <class CompatibleObjectType, typename
+ std::enable_if<
+ std::is_constructible<typename object_t::key_type, typename CompatibleObjectType::key_type>::value and
+ std::is_constructible<basic_json, typename CompatibleObjectType::mapped_type>::value, int>::type
+ = 0>
+ basic_json(const CompatibleObjectType& val)
+ : m_type(value_t::object)
+ {
+ using std::begin;
+ using std::end;
+ m_value.object = create<object_t>(begin(val), end(val));
+ }
+
+ /*!
+ @brief create an array (explicit)
+
+ Create an array JSON value with a given content.
+
+ @param[in] val a value for the array
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for array value fails
+
+ @liveexample{The following code shows the constructor with an @ref array_t
+ parameter.,basic_json__array_t}
+
+ @sa @ref basic_json(const CompatibleArrayType&) -- create an array value
+ from a compatible STL containers
+
+ @since version 1.0.0
+ */
+ basic_json(const array_t& val)
+ : m_type(value_t::array), m_value(val)
+ {}
+
+ /*!
+ @brief create an array (implicit)
+
+ Create an array JSON value with a given content. This constructor allows
+ any type @a CompatibleArrayType that can be used to construct values of
+ type @ref array_t.
+
+ @tparam CompatibleArrayType An object type whose `value_type` is
+ compatible to @ref array_t. Examples include `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.
+
+ @param[in] val a value for the array
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for array value fails
+
+ @liveexample{The following code shows the constructor with several
+ compatible array type parameters.,basic_json__CompatibleArrayType}
+
+ @sa @ref basic_json(const array_t&) -- create an array value
+
+ @since version 1.0.0
+ */
+ template <class CompatibleArrayType, typename
+ std::enable_if<
+ not std::is_same<CompatibleArrayType, typename basic_json_t::iterator>::value and
+ not std::is_same<CompatibleArrayType, typename basic_json_t::const_iterator>::value and
+ not std::is_same<CompatibleArrayType, typename basic_json_t::reverse_iterator>::value and
+ not std::is_same<CompatibleArrayType, typename basic_json_t::const_reverse_iterator>::value and
+ not std::is_same<CompatibleArrayType, typename array_t::iterator>::value and
+ not std::is_same<CompatibleArrayType, typename array_t::const_iterator>::value and
+ std::is_constructible<basic_json, typename CompatibleArrayType::value_type>::value, int>::type
+ = 0>
+ basic_json(const CompatibleArrayType& val)
+ : m_type(value_t::array)
+ {
+ using std::begin;
+ using std::end;
+ m_value.array = create<array_t>(begin(val), end(val));
+ }
+
+ /*!
+ @brief create a string (explicit)
+
+ Create an string JSON value with a given content.
+
+ @param[in] val a value for the string
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for string value fails
+
+ @liveexample{The following code shows the constructor with an @ref
+ string_t parameter.,basic_json__string_t}
+
+ @sa @ref basic_json(const typename string_t::value_type*) -- create a
+ string value from a character pointer
+ @sa @ref basic_json(const CompatibleStringType&) -- create a string value
+ from a compatible string container
+
+ @since version 1.0.0
+ */
+ basic_json(const string_t& val)
+ : m_type(value_t::string), m_value(val)
+ {}
+
+ /*!
+ @brief create a string (explicit)
+
+ Create a string JSON value with a given content.
+
+ @param[in] val a literal value for the string
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for string value fails
+
+ @liveexample{The following code shows the constructor with string literal
+ parameter.,basic_json__string_t_value_type}
+
+ @sa @ref basic_json(const string_t&) -- create a string value
+ @sa @ref basic_json(const CompatibleStringType&) -- create a string value
+ from a compatible string container
+
+ @since version 1.0.0
+ */
+ basic_json(const typename string_t::value_type* val)
+ : basic_json(string_t(val))
+ {}
+
+ /*!
+ @brief create a string (implicit)
+
+ Create a string JSON value with a given content.
+
+ @param[in] val a value for the string
+
+ @tparam CompatibleStringType an string type which is compatible to @ref
+ string_t, for instance `std::string`.
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for string value fails
+
+ @liveexample{The following code shows the construction of a string value
+ from a compatible type.,basic_json__CompatibleStringType}
+
+ @sa @ref basic_json(const string_t&) -- create a string value
+ @sa @ref basic_json(const typename string_t::value_type*) -- create a
+ string value from a character pointer
+
+ @since version 1.0.0
+ */
+ template <class CompatibleStringType, typename
+ std::enable_if<
+ std::is_constructible<string_t, CompatibleStringType>::value, int>::type
+ = 0>
+ basic_json(const CompatibleStringType& val)
+ : basic_json(string_t(val))
+ {}
+
+ /*!
+ @brief create a boolean (explicit)
+
+ Creates a JSON boolean type from a given value.
+
+ @param[in] val a boolean value to store
+
+ @complexity Constant.
+
+ @liveexample{The example below demonstrates boolean
+ values.,basic_json__boolean_t}
+
+ @since version 1.0.0
+ */
+ basic_json(boolean_t val) noexcept
+ : m_type(value_t::boolean), m_value(val)
+ {}
+
+ /*!
+ @brief create an integer number (explicit)
+
+ Create an integer number JSON value with a given content.
+
+ @tparam T A helper type to remove this function via SFINAE in case @ref
+ number_integer_t is the same as `int`. In this case, this constructor
+ would have the same signature as @ref basic_json(const int value). Note
+ the helper type @a T is not visible in this constructor's interface.
+
+ @param[in] val an integer to create a JSON number from
+
+ @complexity Constant.
+
+ @liveexample{The example below shows the construction of an integer
+ number value.,basic_json__number_integer_t}
+
+ @sa @ref basic_json(const int) -- create a number value (integer)
+ @sa @ref basic_json(const CompatibleNumberIntegerType) -- create a number
+ value (integer) from a compatible number type
+
+ @since version 1.0.0
+ */
+ template<typename T,
+ typename std::enable_if<
+ not (std::is_same<T, int>::value)
+ and std::is_same<T, number_integer_t>::value
+ , int>::type
+ = 0>
+ basic_json(const number_integer_t val) noexcept
+ : m_type(value_t::number_integer), m_value(val)
+ {}
+
+ /*!
+ @brief create an integer number from an enum type (explicit)
+
+ Create an integer number JSON value with a given content.
+
+ @param[in] val an integer to create a JSON number from
+
+ @note This constructor allows to pass enums directly to a constructor. As
+ C++ has no way of specifying the type of an anonymous enum explicitly, we
+ can only rely on the fact that such values implicitly convert to int. As
+ int may already be the same type of number_integer_t, we may need to
+ switch off the constructor @ref basic_json(const number_integer_t).
+
+ @complexity Constant.
+
+ @liveexample{The example below shows the construction of an integer
+ number value from an anonymous enum.,basic_json__const_int}
+
+ @sa @ref basic_json(const number_integer_t) -- create a number value
+ (integer)
+ @sa @ref basic_json(const CompatibleNumberIntegerType) -- create a number
+ value (integer) from a compatible number type
+
+ @since version 1.0.0
+ */
+ basic_json(const int val) noexcept
+ : m_type(value_t::number_integer),
+ m_value(static_cast<number_integer_t>(val))
+ {}
+
+ /*!
+ @brief create an integer number (implicit)
+
+ Create an integer number JSON value with a given content. This constructor
+ allows any type @a CompatibleNumberIntegerType that can be used to
+ construct values of type @ref number_integer_t.
+
+ @tparam CompatibleNumberIntegerType An integer type which is compatible to
+ @ref number_integer_t. Examples include the types `int`, `int32_t`,
+ `long`, and `short`.
+
+ @param[in] val an integer to create a JSON number from
+
+ @complexity Constant.
+
+ @liveexample{The example below shows the construction of several integer
+ number values from compatible
+ types.,basic_json__CompatibleIntegerNumberType}
+
+ @sa @ref basic_json(const number_integer_t) -- create a number value
+ (integer)
+ @sa @ref basic_json(const int) -- create a number value (integer)
+
+ @since version 1.0.0
+ */
+ template<typename CompatibleNumberIntegerType, typename
+ std::enable_if<
+ std::is_constructible<number_integer_t, CompatibleNumberIntegerType>::value and
+ std::numeric_limits<CompatibleNumberIntegerType>::is_integer and
+ std::numeric_limits<CompatibleNumberIntegerType>::is_signed,
+ CompatibleNumberIntegerType>::type
+ = 0>
+ basic_json(const CompatibleNumberIntegerType val) noexcept
+ : m_type(value_t::number_integer),
+ m_value(static_cast<number_integer_t>(val))
+ {}
+
+ /*!
+ @brief create an unsigned integer number (explicit)
+
+ Create an unsigned integer number JSON value with a given content.
+
+ @tparam T helper type to compare number_unsigned_t and unsigned int
+ (not visible in) the interface.
+
+ @param[in] val an integer to create a JSON number from
+
+ @complexity Constant.
+
+ @sa @ref basic_json(const CompatibleNumberUnsignedType) -- create a number
+ value (unsigned integer) from a compatible number type
+
+ @since version 2.0.0
+ */
+ template<typename T,
+ typename std::enable_if<
+ not (std::is_same<T, int>::value)
+ and std::is_same<T, number_unsigned_t>::value
+ , int>::type
+ = 0>
+ basic_json(const number_unsigned_t val) noexcept
+ : m_type(value_t::number_unsigned), m_value(val)
+ {}
+
+ /*!
+ @brief create an unsigned number (implicit)
+
+ Create an unsigned number JSON value with a given content. This
+ constructor allows any type @a CompatibleNumberUnsignedType that can be
+ used to construct values of type @ref number_unsigned_t.
+
+ @tparam CompatibleNumberUnsignedType An integer type which is compatible
+ to @ref number_unsigned_t. Examples may include the types `unsigned int`,
+ `uint32_t`, or `unsigned short`.
+
+ @param[in] val an unsigned integer to create a JSON number from
+
+ @complexity Constant.
+
+ @sa @ref basic_json(const number_unsigned_t) -- create a number value
+ (unsigned)
+
+ @since version 2.0.0
+ */
+ template < typename CompatibleNumberUnsignedType, typename
+ std::enable_if <
+ std::is_constructible<number_unsigned_t, CompatibleNumberUnsignedType>::value and
+ std::numeric_limits<CompatibleNumberUnsignedType>::is_integer and
+ !std::numeric_limits<CompatibleNumberUnsignedType>::is_signed,
+ CompatibleNumberUnsignedType >::type
+ = 0 >
+ basic_json(const CompatibleNumberUnsignedType val) noexcept
+ : m_type(value_t::number_unsigned),
+ m_value(static_cast<number_unsigned_t>(val))
+ {}
+
+ /*!
+ @brief create a floating-point number (explicit)
+
+ Create a floating-point number JSON value with a given content.
+
+ @param[in] val a floating-point value to create a JSON number from
+
+ @note [RFC 7159](http://www.rfc-editor.org/rfc/rfc7159.txt), section 6
+ disallows NaN values:
+ > Numeric values that cannot be represented in the grammar below (such as
+ > Infinity and NaN) are not permitted.
+ In case the parameter @a val is not a number, a JSON null value is
+ created instead.
+
+ @complexity Constant.
+
+ @liveexample{The following example creates several floating-point
+ values.,basic_json__number_float_t}
+
+ @sa @ref basic_json(const CompatibleNumberFloatType) -- create a number
+ value (floating-point) from a compatible number type
+
+ @since version 1.0.0
+ */
+ basic_json(const number_float_t val) noexcept
+ : m_type(value_t::number_float), m_value(val)
+ {
+ // replace infinity and NAN by null
+ if (not std::isfinite(val))
+ {
+ m_type = value_t::null;
+ m_value = json_value();
+ }
+ }
+
+ /*!
+ @brief create an floating-point number (implicit)
+
+ Create an floating-point number JSON value with a given content. This
+ constructor allows any type @a CompatibleNumberFloatType that can be used
+ to construct values of type @ref number_float_t.
+
+ @tparam CompatibleNumberFloatType A floating-point type which is
+ compatible to @ref number_float_t. Examples may include the types `float`
+ or `double`.
+
+ @param[in] val a floating-point to create a JSON number from
+
+ @note [RFC 7159](http://www.rfc-editor.org/rfc/rfc7159.txt), section 6
+ disallows NaN values:
+ > Numeric values that cannot be represented in the grammar below (such as
+ > Infinity and NaN) are not permitted.
+ In case the parameter @a val is not a number, a JSON null value is
+ created instead.
+
+ @complexity Constant.
+
+ @liveexample{The example below shows the construction of several
+ floating-point number values from compatible
+ types.,basic_json__CompatibleNumberFloatType}
+
+ @sa @ref basic_json(const number_float_t) -- create a number value
+ (floating-point)
+
+ @since version 1.0.0
+ */
+ template<typename CompatibleNumberFloatType, typename = typename
+ std::enable_if<
+ std::is_constructible<number_float_t, CompatibleNumberFloatType>::value and
+ std::is_floating_point<CompatibleNumberFloatType>::value>::type
+ >
+ basic_json(const CompatibleNumberFloatType val) noexcept
+ : basic_json(number_float_t(val))
+ {}
+
+ /*!
+ @brief create a container (array or object) from an initializer list
+
+ Creates a JSON value of type array or object from the passed initializer
+ list @a init. In case @a type_deduction is `true` (default), the type of
+ the JSON value to be created is deducted from the initializer list @a init
+ according to the following rules:
+
+ 1. If the list is empty, an empty JSON object value `{}` is created.
+ 2. If the list consists of pairs whose first element is a string, a JSON
+ object value is created where the first elements of the pairs are treated
+ as keys and the second elements are as values.
+ 3. In all other cases, an array is created.
+
+ The rules aim to create the best fit between a C++ initializer list and
+ JSON values. The rationale is as follows:
+
+ 1. The empty initializer list is written as `{}` which is exactly an empty
+ JSON object.
+ 2. C++ has now way of describing mapped types other than to list a list of
+ pairs. As JSON requires that keys must be of type string, rule 2 is the
+ weakest constraint one can pose on initializer lists to interpret them as
+ an object.
+ 3. In all other cases, the initializer list could not be interpreted as
+ JSON object type, so interpreting it as JSON array type is safe.
+
+ With the rules described above, the following JSON values cannot be
+ expressed by an initializer list:
+
+ - the empty array (`[]`): use @ref array(std::initializer_list<basic_json>)
+ with an empty initializer list in this case
+ - arrays whose elements satisfy rule 2: use @ref
+ array(std::initializer_list<basic_json>) with the same initializer list
+ in this case
+
+ @note When used without parentheses around an empty initializer list, @ref
+ basic_json() is called instead of this function, yielding the JSON null
+ value.
+
+ @param[in] init initializer list with JSON values
+
+ @param[in] type_deduction internal parameter; when set to `true`, the type
+ of the JSON value is deducted from the initializer list @a init; when set
+ to `false`, the type provided via @a manual_type is forced. This mode is
+ used by the functions @ref array(std::initializer_list<basic_json>) and
+ @ref object(std::initializer_list<basic_json>).
+
+ @param[in] manual_type internal parameter; when @a type_deduction is set
+ to `false`, the created JSON value will use the provided type (only @ref
+ value_t::array and @ref value_t::object are valid); when @a type_deduction
+ is set to `true`, this parameter has no effect
+
+ @throw std::domain_error if @a type_deduction is `false`, @a manual_type
+ is `value_t::object`, but @a init contains an element which is not a pair
+ whose first element is a string; example: `"cannot create object from
+ initializer list"`
+
+ @complexity Linear in the size of the initializer list @a init.
+
+ @liveexample{The example below shows how JSON values are created from
+ initializer lists.,basic_json__list_init_t}
+
+ @sa @ref array(std::initializer_list<basic_json>) -- create a JSON array
+ value from an initializer list
+ @sa @ref object(std::initializer_list<basic_json>) -- create a JSON object
+ value from an initializer list
+
+ @since version 1.0.0
+ */
+ basic_json(std::initializer_list<basic_json> init,
+ bool type_deduction = true,
+ value_t manual_type = value_t::array)
+ {
+ // the initializer list could describe an object
+ bool is_an_object = true;
+
+ // check if each element is an array with two elements whose first
+ // element is a string
+ for (const auto& element : init)
+ {
+ if (not element.is_array() or element.size() != 2
+ or not element[0].is_string())
+ {
+ // we found an element that makes it impossible to use the
+ // initializer list as object
+ is_an_object = false;
+ break;
+ }
+ }
+
+ // 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)
+ {
+ 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;
+
+ assert(m_value.object != nullptr);
+
+ for (auto& element : init)
+ {
+ m_value.object->emplace(*(element[0].m_value.string), element[1]);
+ }
+ }
+ else
+ {
+ // the initializer list describes an array -> create array
+ m_type = value_t::array;
+ m_value.array = create<array_t>(init);
+ }
+ }
+
+ /*!
+ @brief explicitly create an array from an initializer list
+
+ Creates a JSON array value from a given initializer list. That is, given a
+ list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the
+ initializer list is empty, the empty array `[]` is created.
+
+ @note This function is only needed to express two edge cases that cannot
+ be realized with the initializer list constructor (@ref
+ basic_json(std::initializer_list<basic_json>, bool, value_t)). These cases
+ are:
+ 1. creating an array whose elements are all pairs whose first element is a
+ string -- in this case, the initializer list constructor would create an
+ object, taking the first elements as keys
+ 2. creating an empty array -- passing the empty initializer list to the
+ initializer list constructor yields an empty object
+
+ @param[in] init initializer list with JSON values to create an array from
+ (optional)
+
+ @return JSON array value
+
+ @complexity Linear in the size of @a init.
+
+ @liveexample{The following code shows an example for the `array`
+ function.,array}
+
+ @sa @ref basic_json(std::initializer_list<basic_json>, bool, value_t) --
+ create a JSON value from an initializer list
+ @sa @ref object(std::initializer_list<basic_json>) -- create a JSON object
+ value from an initializer list
+
+ @since version 1.0.0
+ */
+ static basic_json array(std::initializer_list<basic_json> init =
+ std::initializer_list<basic_json>())
+ {
+ return basic_json(init, false, value_t::array);
+ }
+
+ /*!
+ @brief explicitly create an object from an initializer list
+
+ Creates a JSON object value from a given initializer list. The initializer
+ lists elements must be pairs, and their first elements must be strings. If
+ the initializer list is empty, the empty object `{}` is created.
+
+ @note This function is only added for symmetry reasons. In contrast to the
+ related function @ref array(std::initializer_list<basic_json>), there are
+ no cases which can only be expressed by this function. That is, any
+ initializer list @a init can also be passed to the initializer list
+ constructor @ref basic_json(std::initializer_list<basic_json>, bool,
+ value_t).
+
+ @param[in] init initializer list to create an object from (optional)
+
+ @return JSON object value
+
+ @throw std::domain_error if @a init is not a pair whose first elements are
+ strings; thrown by
+ @ref basic_json(std::initializer_list<basic_json>, bool, value_t)
+
+ @complexity Linear in the size of @a init.
+
+ @liveexample{The following code shows an example for the `object`
+ function.,object}
+
+ @sa @ref basic_json(std::initializer_list<basic_json>, bool, value_t) --
+ create a JSON value from an initializer list
+ @sa @ref array(std::initializer_list<basic_json>) -- create a JSON array
+ value from an initializer list
+
+ @since version 1.0.0
+ */
+ static basic_json object(std::initializer_list<basic_json> init =
+ std::initializer_list<basic_json>())
+ {
+ return basic_json(init, false, value_t::object);
+ }
+
+ /*!
+ @brief construct an array with count copies of given value
+
+ Constructs a JSON array value by creating @a cnt copies of a passed value.
+ In case @a cnt is `0`, an empty array is created. As postcondition,
+ `std::distance(begin(),end()) == cnt` holds.
+
+ @param[in] cnt the number of JSON copies of @a val to create
+ @param[in] val the JSON value to copy
+
+ @complexity Linear in @a cnt.
+
+ @liveexample{The following code shows examples for the @ref
+ basic_json(size_type\, const basic_json&)
+ constructor.,basic_json__size_type_basic_json}
+
+ @since version 1.0.0
+ */
+ basic_json(size_type cnt, const basic_json& val)
+ : m_type(value_t::array)
+ {
+ m_value.array = create<array_t>(cnt, val);
+ }
+
+ /*!
+ @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)
+
+ @throw std::domain_error if iterators are not compatible; that is, do not
+ belong to the same JSON value; example: `"iterators are not compatible"`
+ @throw std::out_of_range if iterators are for a primitive type (number,
+ boolean, or string) where an out of range error can be detected easily;
+ example: `"iterators out of range"`
+ @throw std::bad_alloc if allocation for object, array, or string fails
+ @throw std::domain_error if called with a null value; example: `"cannot
+ use construct with iterators from null"`
+
+ @complexity Linear in distance between @a first and @a last.
+
+ @liveexample{The example below shows several ways to create JSON values by
+ specifying a subrange with iterators.,basic_json__InputIt_InputIt}
+
+ @since version 1.0.0
+ */
+ template <class InputIT, typename
+ std::enable_if<
+ std::is_same<InputIT, typename basic_json_t::iterator>::value or
+ std::is_same<InputIT, typename basic_json_t::const_iterator>::value
+ , int>::type
+ = 0>
+ basic_json(InputIT first, InputIT last) : m_type(first.m_object->m_type)
+ {
+ // make sure iterator fits the current value
+ if (first.m_object != last.m_object)
+ {
+ throw std::domain_error("iterators are not compatible");
+ }
+
+ // 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())
+ {
+ throw std::out_of_range("iterators out of range");
+ }
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+
+ switch (m_type)
+ {
+ case value_t::number_integer:
+ {
+ assert(first.m_object != nullptr);
+ m_value.number_integer = first.m_object->m_value.number_integer;
+ break;
+ }
+
+ case value_t::number_unsigned:
+ {
+ assert(first.m_object != nullptr);
+ m_value.number_unsigned = first.m_object->m_value.number_unsigned;
+ break;
+ }
+
+ case value_t::number_float:
+ {
+ assert(first.m_object != nullptr);
+ m_value.number_float = first.m_object->m_value.number_float;
+ break;
+ }
+
+ case value_t::boolean:
+ {
+ assert(first.m_object != nullptr);
+ m_value.boolean = first.m_object->m_value.boolean;
+ break;
+ }
+
+ case value_t::string:
+ {
+ assert(first.m_object != nullptr);
+ m_value = *first.m_object->m_value.string;
+ break;
+ }
+
+ case value_t::object:
+ {
+ m_value.object = create<object_t>(first.m_it.object_iterator, last.m_it.object_iterator);
+ break;
+ }
+
+ case value_t::array:
+ {
+ m_value.array = create<array_t>(first.m_it.array_iterator, last.m_it.array_iterator);
+ break;
+ }
+
+ default:
+ {
+ assert(first.m_object != nullptr);
+ throw std::domain_error("cannot use construct with iterators from " + first.m_object->type_name());
+ }
+ }
+ }
+
+ /*!
+ @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.
+
+ @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
+ */
+ explicit basic_json(std::istream& i, parser_callback_t cb = nullptr)
+ {
+ *this = parser(i, cb).parse();
+ }
+
+ ///////////////////////////////////////
+ // 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)
+ {
+ switch (m_type)
+ {
+ case value_t::object:
+ {
+ assert(other.m_value.object != nullptr);
+ m_value = *other.m_value.object;
+ break;
+ }
+
+ case value_t::array:
+ {
+ assert(other.m_value.array != nullptr);
+ m_value = *other.m_value.array;
+ break;
+ }
+
+ case value_t::string:
+ {
+ assert(other.m_value.string != nullptr);
+ 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;
+ }
+ }
+ }
+
+ /*!
+ @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))
+ {
+ // invalidate payload
+ other.m_type = value_t::null;
+ other.m_value = {};
+ }
+
+ /*!
+ @brief copy assignment
+
+ Copy assignment operator. Copies a JSON value via the "copy and swap"
+ strategy: It is expressed in terms of the copy constructor, destructor,
+ and the swap() member function.
+
+ @param[in] other value to copy from
+
+ @complexity Linear.
+
+ @requirement This function helps `basic_json` satisfying the
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)
+ requirements:
+ - The complexity is linear.
+
+ @liveexample{The code below shows and example for the copy assignment. It
+ creates a copy of value `a` which is then swapped with `b`. Finally\, the
+ copy of `a` (which is the null value after the swap) is
+ destroyed.,basic_json__copyassignment}
+
+ @since version 1.0.0
+ */
+ reference& operator=(basic_json other) noexcept (
+ std::is_nothrow_move_constructible<value_t>::value and
+ std::is_nothrow_move_assignable<value_t>::value and
+ std::is_nothrow_move_constructible<json_value>::value and
+ std::is_nothrow_move_assignable<json_value>::value
+ )
+ {
+ using std::swap;
+ swap(m_type, other.m_type);
+ swap(m_value, other.m_value);
+ 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()
+ {
+ switch (m_type)
+ {
+ case value_t::object:
+ {
+ AllocatorType<object_t> alloc;
+ alloc.destroy(m_value.object);
+ alloc.deallocate(m_value.object, 1);
+ break;
+ }
+
+ case value_t::array:
+ {
+ AllocatorType<array_t> alloc;
+ alloc.destroy(m_value.array);
+ alloc.deallocate(m_value.array, 1);
+ break;
+ }
+
+ case value_t::string:
+ {
+ AllocatorType<string_t> alloc;
+ alloc.destroy(m_value.string);
+ alloc.deallocate(m_value.string, 1);
+ break;
+ }
+
+ default:
+ {
+ // all other types need no specific destructor
+ break;
+ }
+ }
+ }
+
+ /// @}
+
+ public:
+ ///////////////////////
+ // object inspection //
+ ///////////////////////
+
+ /// @name object inspection
+ /// @{
+
+ /*!
+ @brief serialization
+
+ Serialization function for JSON values. The function tries to mimic
+ Python's @p json.dumps() function, and currently supports its @p indent
+ parameter.
+
+ @param[in] indent if indent is nonnegative, then array elements and object
+ members will be pretty-printed with that indent level. An indent level of
+ 0 will only insert newlines. -1 (the default) selects the most compact
+ representation
+
+ @return string containing the serialization of the JSON value
+
+ @complexity Linear.
+
+ @liveexample{The following example shows the effect of different @a indent
+ parameters to the result of the serialization.,dump}
+
+ @see https://docs.python.org/2/library/json.html#json.dump
+
+ @since version 1.0.0
+ */
+ string_t dump(const int indent = -1) const
+ {
+ std::stringstream ss;
+
+ if (indent >= 0)
+ {
+ dump(ss, true, static_cast<unsigned int>(indent));
+ }
+ else
+ {
+ dump(ss, false, 0);
+ }
+
+ return ss.str();
+ }
+
+ /*!
+ @brief return the type of the JSON value (explicit)
+
+ Return the type of the JSON value as a value from the @ref value_t
+ enumeration.
+
+ @return the type of the JSON value
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies `type()` for all JSON
+ types.,type}
+
+ @since version 1.0.0
+ */
+ constexpr value_t type() const noexcept
+ {
+ return m_type;
+ }
+
+ /*!
+ @brief return whether type is primitive
+
+ This function returns true iff the JSON type is primitive (string, number,
+ boolean, or null).
+
+ @return `true` if type is primitive (string, number, boolean, or null),
+ `false` otherwise.
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies `is_primitive()` for all JSON
+ types.,is_primitive}
+
+ @sa @ref is_structured() -- returns whether JSON value is structured
+ @sa @ref is_null() -- returns whether JSON value is `null`
+ @sa @ref is_string() -- returns whether JSON value is a string
+ @sa @ref is_boolean() -- returns whether JSON value is a boolean
+ @sa @ref is_number() -- returns whether JSON value is a number
+
+ @since version 1.0.0
+ */
+ constexpr bool is_primitive() const noexcept
+ {
+ return is_null() or is_string() or is_boolean() or is_number();
+ }
+
+ /*!
+ @brief return whether type is structured
+
+ This function returns true iff the JSON type is structured (array or
+ object).
+
+ @return `true` if type is structured (array or object), `false` otherwise.
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies `is_structured()` for all JSON
+ types.,is_structured}
+
+ @sa @ref is_primitive() -- returns whether value is primitive
+ @sa @ref is_array() -- returns whether value is an array
+ @sa @ref is_object() -- returns whether value is an object
+
+ @since version 1.0.0
+ */
+ constexpr bool is_structured() const noexcept
+ {
+ return is_array() or is_object();
+ }
+
+ /*!
+ @brief return whether value is null
+
+ This function returns true iff the JSON value is null.
+
+ @return `true` if type is null, `false` otherwise.
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies `is_null()` for all JSON
+ types.,is_null}
+
+ @since version 1.0.0
+ */
+ constexpr bool is_null() const noexcept
+ {
+ return m_type == value_t::null;
+ }
+
+ /*!
+ @brief return whether value is a boolean
+
+ This function returns true iff the JSON value is a boolean.
+
+ @return `true` if type is boolean, `false` otherwise.
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies `is_boolean()` for all JSON
+ types.,is_boolean}
+
+ @since version 1.0.0
+ */
+ constexpr bool is_boolean() const noexcept
+ {
+ return m_type == value_t::boolean;
+ }
+
+ /*!
+ @brief return whether value is a number
+
+ This function returns true iff the JSON value is a number. This includes
+ both integer and floating-point values.
+
+ @return `true` if type is number (regardless whether integer, unsigned
+ integer or floating-type), `false` otherwise.
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies `is_number()` for all JSON
+ types.,is_number}
+
+ @sa @ref is_number_integer() -- check if value is an integer or unsigned
+ integer number
+ @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+ number
+ @sa @ref is_number_float() -- check if value is a floating-point number
+
+ @since version 1.0.0
+ */
+ constexpr bool is_number() const noexcept
+ {
+ return is_number_integer() or is_number_float();
+ }
+
+ /*!
+ @brief return whether value is an integer number
+
+ This function returns true iff the JSON value is an integer or unsigned
+ integer number. This excludes floating-point values.
+
+ @return `true` if type is an integer or unsigned integer number, `false`
+ otherwise.
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies `is_number_integer()` for all
+ JSON types.,is_number_integer}
+
+ @sa @ref is_number() -- check if value is a number
+ @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+ number
+ @sa @ref is_number_float() -- check if value is a floating-point number
+
+ @since version 1.0.0
+ */
+ constexpr bool is_number_integer() const noexcept
+ {
+ return m_type == value_t::number_integer or m_type == value_t::number_unsigned;
+ }
+
+ /*!
+ @brief return whether value is an unsigned integer number
+
+ This function returns true iff the JSON value is an unsigned integer
+ number. This excludes floating-point and (signed) integer values.
+
+ @return `true` if type is an unsigned integer number, `false` otherwise.
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies `is_number_unsigned()` for all
+ JSON types.,is_number_unsigned}
+
+ @sa @ref is_number() -- check if value is a number
+ @sa @ref is_number_integer() -- check if value is an integer or unsigned
+ integer number
+ @sa @ref is_number_float() -- check if value is a floating-point number
+
+ @since version 2.0.0
+ */
+ constexpr bool is_number_unsigned() const noexcept
+ {
+ return m_type == value_t::number_unsigned;
+ }
+
+ /*!
+ @brief return whether value is a floating-point number
+
+ This function returns true iff the JSON value is a floating-point number.
+ This excludes integer and unsigned integer values.
+
+ @return `true` if type is a floating-point number, `false` otherwise.
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies `is_number_float()` for all
+ JSON types.,is_number_float}
+
+ @sa @ref is_number() -- check if value is number
+ @sa @ref is_number_integer() -- check if value is an integer number
+ @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+ number
+
+ @since version 1.0.0
+ */
+ constexpr bool is_number_float() const noexcept
+ {
+ return m_type == value_t::number_float;
+ }
+
+ /*!
+ @brief return whether value is an object
+
+ This function returns true iff the JSON value is an object.
+
+ @return `true` if type is object, `false` otherwise.
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies `is_object()` for all JSON
+ types.,is_object}
+
+ @since version 1.0.0
+ */
+ constexpr bool is_object() const noexcept
+ {
+ return m_type == value_t::object;
+ }
+
+ /*!
+ @brief return whether value is an array
+
+ This function returns true iff the JSON value is an array.
+
+ @return `true` if type is array, `false` otherwise.
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies `is_array()` for all JSON
+ types.,is_array}
+
+ @since version 1.0.0
+ */
+ constexpr bool is_array() const noexcept
+ {
+ return m_type == value_t::array;
+ }
+
+ /*!
+ @brief return whether value is a string
+
+ This function returns true iff the JSON value is a string.
+
+ @return `true` if type is string, `false` otherwise.
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies `is_string()` for all JSON
+ types.,is_string}
+
+ @since version 1.0.0
+ */
+ constexpr bool is_string() const noexcept
+ {
+ return m_type == value_t::string;
+ }
+
+ /*!
+ @brief return whether value is discarded
+
+ This function returns true iff the JSON value was discarded during parsing
+ with a callback function (see @ref parser_callback_t).
+
+ @note This function will always be `false` for JSON values after parsing.
+ That is, discarded values can only occur during parsing, but will be
+ removed when inside a structured value or replaced by null in other cases.
+
+ @return `true` if type is discarded, `false` otherwise.
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies `is_discarded()` for all JSON
+ types.,is_discarded}
+
+ @since version 1.0.0
+ */
+ constexpr bool is_discarded() const noexcept
+ {
+ return m_type == value_t::discarded;
+ }
+
+ /*!
+ @brief return the type of the JSON value (implicit)
+
+ Implicitly return the type of the JSON value as a value from the @ref
+ value_t enumeration.
+
+ @return the type of the JSON value
+
+ @complexity Constant.
+
+ @exceptionsafety No-throw guarantee: this member function never throws
+ exceptions.
+
+ @liveexample{The following code exemplifies the @ref value_t operator for
+ all JSON types.,operator__value_t}
+
+ @since version 1.0.0
+ */
+ constexpr operator value_t() const noexcept
+ {
+ return m_type;
+ }
+
+ /// @}
+
+ private:
+ //////////////////
+ // value access //
+ //////////////////
+
+ /// get an object (explicit)
+ template <class T, typename
+ std::enable_if<
+ std::is_convertible<typename object_t::key_type, typename T::key_type>::value and
+ std::is_convertible<basic_json_t, typename T::mapped_type>::value
+ , int>::type = 0>
+ T get_impl(T*) const
+ {
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ return T(m_value.object->begin(), m_value.object->end());
+ }
+ else
+ {
+ throw std::domain_error("type must be object, but is " + type_name());
+ }
+ }
+
+ /// get an object (explicit)
+ object_t get_impl(object_t*) const
+ {
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ return *(m_value.object);
+ }
+ else
+ {
+ throw std::domain_error("type must be object, but is " + type_name());
+ }
+ }
+
+ /// get an array (explicit)
+ template <class T, typename
+ std::enable_if<
+ std::is_convertible<basic_json_t, typename T::value_type>::value and
+ not std::is_same<basic_json_t, typename T::value_type>::value and
+ not std::is_arithmetic<T>::value and
+ not std::is_convertible<std::string, T>::value and
+ not has_mapped_type<T>::value
+ , int>::type = 0>
+ T get_impl(T*) const
+ {
+ if (is_array())
+ {
+ T to_vector;
+ assert(m_value.array != nullptr);
+ std::transform(m_value.array->begin(), m_value.array->end(),
+ std::inserter(to_vector, to_vector.end()), [](basic_json i)
+ {
+ return i.get<typename T::value_type>();
+ });
+ return to_vector;
+ }
+ else
+ {
+ throw std::domain_error("type must be array, but is " + type_name());
+ }
+ }
+
+ /// get an array (explicit)
+ template <class T, typename
+ std::enable_if<
+ std::is_convertible<basic_json_t, T>::value and
+ not std::is_same<basic_json_t, T>::value
+ , int>::type = 0>
+ std::vector<T> get_impl(std::vector<T>*) const
+ {
+ if (is_array())
+ {
+ std::vector<T> to_vector;
+ assert(m_value.array != nullptr);
+ to_vector.reserve(m_value.array->size());
+ std::transform(m_value.array->begin(), m_value.array->end(),
+ std::inserter(to_vector, to_vector.end()), [](basic_json i)
+ {
+ return i.get<T>();
+ });
+ return to_vector;
+ }
+ else
+ {
+ throw std::domain_error("type must be array, but is " + type_name());
+ }
+ }
+
+ /// get an array (explicit)
+ template <class T, typename
+ std::enable_if<
+ std::is_same<basic_json, typename T::value_type>::value and
+ not has_mapped_type<T>::value
+ , int>::type = 0>
+ T get_impl(T*) const
+ {
+ if (is_array())
+ {
+ assert(m_value.array != nullptr);
+ return T(m_value.array->begin(), m_value.array->end());
+ }
+ else
+ {
+ throw std::domain_error("type must be array, but is " + type_name());
+ }
+ }
+
+ /// get an array (explicit)
+ array_t get_impl(array_t*) const
+ {
+ if (is_array())
+ {
+ assert(m_value.array != nullptr);
+ return *(m_value.array);
+ }
+ else
+ {
+ throw std::domain_error("type must be array, but is " + type_name());
+ }
+ }
+
+ /// get a string (explicit)
+ template <typename T, typename
+ std::enable_if<
+ std::is_convertible<string_t, T>::value
+ , int>::type = 0>
+ T get_impl(T*) const
+ {
+ if (is_string())
+ {
+ assert(m_value.string != nullptr);
+ return *m_value.string;
+ }
+ else
+ {
+ throw std::domain_error("type must be string, but is " + type_name());
+ }
+ }
+
+ /// get a number (explicit)
+ template<typename T, typename
+ std::enable_if<
+ std::is_arithmetic<T>::value
+ , int>::type = 0>
+ T get_impl(T*) const
+ {
+ switch (m_type)
+ {
+ case value_t::number_integer:
+ {
+ return static_cast<T>(m_value.number_integer);
+ }
+
+ case value_t::number_unsigned:
+ {
+ return static_cast<T>(m_value.number_unsigned);
+ }
+
+ case value_t::number_float:
+ {
+ return static_cast<T>(m_value.number_float);
+ }
+
+ default:
+ {
+ throw std::domain_error("type must be number, but is " + type_name());
+ }
+ }
+ }
+
+ /// get a boolean (explicit)
+ constexpr boolean_t get_impl(boolean_t*) const
+ {
+ return is_boolean()
+ ? m_value.boolean
+ : 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*) 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*) const noexcept
+ {
+ return is_object() ? m_value.object : nullptr;
+ }
+
+ /// get a pointer to the value (array)
+ array_t* get_impl_ptr(array_t*) 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*) const noexcept
+ {
+ return is_array() ? m_value.array : nullptr;
+ }
+
+ /// get a pointer to the value (string)
+ string_t* get_impl_ptr(string_t*) 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*) const noexcept
+ {
+ return is_string() ? m_value.string : nullptr;
+ }
+
+ /// get a pointer to the value (boolean)
+ boolean_t* get_impl_ptr(boolean_t*) 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*) 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*) 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*) 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*) 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*) 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*) 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*) const noexcept
+ {
+ return is_number_float() ? &m_value.number_float : nullptr;
+ }
+
+ /*!
+ @brief helper function to implement get_ref()
+
+ This funcion helps to implement get_ref() without code duplication for
+ const and non-const overloads
+
+ @tparam ThisType will be deduced as `basic_json` or `const basic_json`
+
+ @throw std::domain_error if ReferenceType does not match underlying value
+ type of the current JSON
+ */
+ template<typename ReferenceType, typename ThisType>
+ static ReferenceType get_ref_impl(ThisType& obj)
+ {
+ // delegate the call to get_ptr<>()
+ using PointerType = typename std::add_pointer<ReferenceType>::type;
+ auto ptr = obj.template get_ptr<PointerType>();
+
+ if (ptr != nullptr)
+ {
+ return *ptr;
+ }
+ else
+ {
+ throw std::domain_error("incompatible ReferenceType for get_ref, actual type is " +
+ obj.type_name());
+ }
+ }
+
+ public:
+
+ /// @name value access
+ /// @{
+
+ /*!
+ @brief get a value (explicit)
+
+ Explicit type conversion between the JSON value and a compatible value.
+
+ @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
+
+ @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; example: `"type must be object, but is null"`
+
+ @complexity Linear in the size of the JSON value.
+
+ @liveexample{The example below shows several conversions from JSON values
+ to other types. There a few things to note: (1) Floating-point numbers can
+ be converted to integers\, (2) A JSON array can be converted to a standard
+ `std::vector<short>`\, (3) A JSON object can be converted to C++
+ associative containers such as `std::unordered_map<std::string\,
+ json>`.,get__ValueType_const}
+
+ @internal
+ The idea of using a casted null pointer to choose the correct
+ implementation is from <http://stackoverflow.com/a/8315197/266378>.
+ @endinternal
+
+ @sa @ref operator ValueType() const for implicit conversion
+ @sa @ref get() for pointer-member access
+
+ @since version 1.0.0
+ */
+ template<typename ValueType, typename
+ std::enable_if<
+ not std::is_pointer<ValueType>::value
+ , int>::type = 0>
+ ValueType get() const
+ {
+ return get_impl(static_cast<ValueType*>(nullptr));
+ }
+
+ /*!
+ @brief get a pointer value (explicit)
+
+ Explicit pointer access to the internally stored JSON value. No copies are
+ made.
+
+ @warning The pointer becomes invalid if the underlying JSON object changes.
+
+ @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+ object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+ @ref number_unsigned_t, or @ref number_float_t.
+
+ @return pointer to the internally stored JSON value if the requested
+ pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how pointers to internal values of a
+ JSON value can be requested. Note that no type conversions are made and a
+ `nullptr` is returned if the value and the requested pointer type does not
+ match.,get__PointerType}
+
+ @sa @ref get_ptr() for explicit pointer-member access
+
+ @since version 1.0.0
+ */
+ template<typename PointerType, typename
+ std::enable_if<
+ std::is_pointer<PointerType>::value
+ , int>::type = 0>
+ PointerType get() noexcept
+ {
+ // delegate the call to get_ptr
+ return get_ptr<PointerType>();
+ }
+
+ /*!
+ @brief get a pointer value (explicit)
+ @copydoc get()
+ */
+ template<typename PointerType, typename
+ std::enable_if<
+ std::is_pointer<PointerType>::value
+ , int>::type = 0>
+ constexpr const PointerType get() const noexcept
+ {
+ // delegate the call to get_ptr
+ return get_ptr<PointerType>();
+ }
+
+ /*!
+ @brief get a pointer value (implicit)
+
+ Implicit pointer access to the internally stored JSON value. No copies are
+ made.
+
+ @warning Writing data to the pointee of the result yields an undefined
+ state.
+
+ @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+ object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+ @ref number_unsigned_t, or @ref number_float_t.
+
+ @return pointer to the internally stored JSON value if the requested
+ pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how pointers to internal values of a
+ JSON value can be requested. Note that no type conversions are made and a
+ `nullptr` is returned if the value and the requested pointer type does not
+ match.,get_ptr}
+
+ @since version 1.0.0
+ */
+ template<typename PointerType, typename
+ std::enable_if<
+ std::is_pointer<PointerType>::value
+ , int>::type = 0>
+ PointerType get_ptr() noexcept
+ {
+ // delegate the call to get_impl_ptr<>()
+ return get_impl_ptr(static_cast<PointerType>(nullptr));
+ }
+
+ /*!
+ @brief get a pointer value (implicit)
+ @copydoc get_ptr()
+ */
+ template<typename PointerType, typename
+ std::enable_if<
+ std::is_pointer<PointerType>::value
+ and std::is_const<typename std::remove_pointer<PointerType>::type>::value
+ , int>::type = 0>
+ constexpr const PointerType get_ptr() const noexcept
+ {
+ // delegate the call to get_impl_ptr<>() const
+ return get_impl_ptr(static_cast<const PointerType>(nullptr));
+ }
+
+ /*!
+ @brief get a reference value (implicit)
+
+ Implict 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.
+
+ @return reference to the internally stored JSON value if the requested
+ reference type @a ReferenceType fits to the JSON value; throws
+ std::domain_error otherwise
+
+ @throw std::domain_error in case passed type @a ReferenceType is
+ incompatible with the stored JSON value
+
+ @complexity Constant.
+
+ @liveexample{The example shows several calls to `get_ref()`.,get_ref}
+
+ @since version 1.1.0
+ */
+ template<typename ReferenceType, typename
+ std::enable_if<
+ std::is_reference<ReferenceType>::value
+ , int>::type = 0>
+ ReferenceType get_ref()
+ {
+ // delegate call to get_ref_impl
+ return get_ref_impl<ReferenceType>(*this);
+ }
+
+ /*!
+ @brief get a reference value (implicit)
+ @copydoc get_ref()
+ */
+ template<typename ReferenceType, typename
+ std::enable_if<
+ std::is_reference<ReferenceType>::value
+ and std::is_const<typename std::remove_reference<ReferenceType>::type>::value
+ , int>::type = 0>
+ ReferenceType get_ref() const
+ {
+ // delegate call to get_ref_impl
+ return get_ref_impl<ReferenceType>(*this);
+ }
+
+ /*!
+ @brief get a value (implicit)
+
+ Implicit type conversion between the JSON value and a compatible value.
+ The call is realized by calling @ref get() const.
+
+ @tparam ValueType non-pointer type compatible to the JSON value, for
+ instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+ `std::vector` types for JSON arrays. The character type of @ref string_t
+ as well as an initializer list of this type is excluded to avoid
+ ambiguities as these types implicitly convert to `std::string`.
+
+ @return copy of the JSON value, converted to type @a ValueType
+
+ @throw std::domain_error in case passed type @a ValueType is incompatible
+ to JSON, thrown by @ref get() const
+
+ @complexity Linear in the size of the JSON value.
+
+ @liveexample{The example below shows several conversions from JSON values
+ to other types. There a few things to note: (1) Floating-point numbers can
+ be converted to integers\, (2) A JSON array can be converted to a standard
+ `std::vector<short>`\, (3) A JSON object can be converted to C++
+ associative containers such as `std::unordered_map<std::string\,
+ json>`.,operator__ValueType}
+
+ @since version 1.0.0
+ */
+ template < typename ValueType, typename
+ std::enable_if <
+ not std::is_pointer<ValueType>::value
+ and not std::is_same<ValueType, typename string_t::value_type>::value
+#ifndef _MSC_VER // Fix for issue #167 operator<< abiguity under VS2015
+ and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
+#endif
+ , int >::type = 0 >
+ operator ValueType() const
+ {
+ // delegate the call to get<>() const
+ return get<ValueType>();
+ }
+
+ /// @}
+
+
+ ////////////////////
+ // element access //
+ ////////////////////
+
+ /// @name element access
+ /// @{
+
+ /*!
+ @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())
+ {
+ try
+ {
+ assert(m_value.array != nullptr);
+ return m_value.array->at(idx);
+ }
+ catch (std::out_of_range&)
+ {
+ // create better exception explanation
+ throw std::out_of_range("array index " + std::to_string(idx) + " is out of range");
+ }
+ }
+ else
+ {
+ 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())
+ {
+ try
+ {
+ assert(m_value.array != nullptr);
+ return m_value.array->at(idx);
+ }
+ catch (std::out_of_range&)
+ {
+ // create better exception explanation
+ throw std::out_of_range("array index " + std::to_string(idx) + " is out of range");
+ }
+ }
+ else
+ {
+ 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())
+ {
+ try
+ {
+ assert(m_value.object != nullptr);
+ return m_value.object->at(key);
+ }
+ catch (std::out_of_range&)
+ {
+ // create better exception explanation
+ throw std::out_of_range("key '" + key + "' not found");
+ }
+ }
+ else
+ {
+ 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())
+ {
+ try
+ {
+ assert(m_value.object != nullptr);
+ return m_value.object->at(key);
+ }
+ catch (std::out_of_range&)
+ {
+ // create better exception explanation
+ throw std::out_of_range("key '" + key + "' not found");
+ }
+ }
+ else
+ {
+ throw std::domain_error("cannot use at() with " + type_name());
+ }
+ }
+
+ /*!
+ @brief access specified array element
+
+ Returns a reference to the element at specified location @a idx.
+
+ @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),
+ then the array is silently filled up with `null` values to make `idx` a
+ valid reference to the last stored element.
+
+ @param[in] idx index of the element to access
+
+ @return reference to the element at index @a idx
+
+ @throw std::domain_error if JSON is not an array or null; example:
+ `"cannot use operator[] with string"`
+
+ @complexity Constant if @a idx is in the range of the array. Otherwise
+ linear in `idx - size()`.
+
+ @liveexample{The example below shows how array elements can be read and
+ written using `[]` operator. Note the addition of `null`
+ values.,operatorarray__size_type}
+
+ @since version 1.0.0
+ */
+ reference operator[](size_type idx)
+ {
+ // implicitly convert null value to an empty array
+ if (is_null())
+ {
+ m_type = value_t::array;
+ m_value.array = create<array_t>();
+ }
+
+ // operator[] only works for arrays
+ if (is_array())
+ {
+ // fill up array with null values until given idx is reached
+ assert(m_value.array != nullptr);
+ for (size_t i = m_value.array->size(); i <= idx; ++i)
+ {
+ m_value.array->push_back(basic_json());
+ }
+
+ return m_value.array->operator[](idx);
+ }
+ else
+ {
+ 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())
+ {
+ assert(m_value.array != nullptr);
+ return m_value.array->operator[](idx);
+ }
+ else
+ {
+ throw std::domain_error("cannot use operator[] with " + type_name());
+ }
+ }
+
+ /*!
+ @brief access specified object element
+
+ Returns a reference to the element at with specified key @a key.
+
+ @note If @a key is not found in the object, then it is silently added to
+ the object and filled with a `null` value to make `key` a valid reference.
+ In case the value was `null` before, it is converted to an object.
+
+ @param[in] key key of the element to access
+
+ @return reference to the element at key @a key
+
+ @throw std::domain_error if JSON is not an object or null; example:
+ `"cannot use operator[] with string"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be read and
+ written using the `[]` operator.,operatorarray__key_type}
+
+ @sa @ref at(const typename object_t::key_type&) for access by reference
+ with range checking
+ @sa @ref value() for access by value with a default value
+
+ @since version 1.0.0
+ */
+ reference operator[](const typename object_t::key_type& key)
+ {
+ // implicitly convert null value to an empty object
+ if (is_null())
+ {
+ m_type = value_t::object;
+ m_value.object = create<object_t>();
+ }
+
+ // operator[] only works for objects
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ return m_value.object->operator[](key);
+ }
+ else
+ {
+ 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
+
+ @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 != nullptr);
+ assert(m_value.object->find(key) != m_value.object->end());
+ return m_value.object->find(key)->second;
+ }
+ else
+ {
+ throw std::domain_error("cannot use operator[] with " + type_name());
+ }
+ }
+
+ /*!
+ @brief access specified object element
+
+ Returns a reference to the element at with specified key @a key.
+
+ @note If @a key is not found in the object, then it is silently added to
+ the object and filled with a `null` value to make `key` a valid reference.
+ In case the value was `null` before, it is converted to an object.
+
+ @param[in] key key of the element to access
+
+ @return reference to the element at key @a key
+
+ @throw std::domain_error if JSON is not an object or null; example:
+ `"cannot use operator[] with string"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be read and
+ written using the `[]` operator.,operatorarray__key_type}
+
+ @sa @ref at(const typename object_t::key_type&) for access by reference
+ with range checking
+ @sa @ref value() for access by value with a default value
+
+ @since version 1.0.0
+ */
+ template<typename T, std::size_t n>
+ reference operator[](T * (&key)[n])
+ {
+ return operator[](static_cast<const T>(key));
+ }
+
+ /*!
+ @brief read-only access specified object element
+
+ Returns a const reference to the element at with specified key @a key. No
+ bounds checking is performed.
+
+ @warning If the element with key @a key does not exist, the behavior is
+ undefined.
+
+ @note This function is required for compatibility reasons with Clang.
+
+ @param[in] key key of the element to access
+
+ @return const reference to the element at key @a key
+
+ @throw std::domain_error if JSON is not an object; example: `"cannot use
+ operator[] with null"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be read using
+ the `[]` operator.,operatorarray__key_type_const}
+
+ @sa @ref at(const typename object_t::key_type&) for access by reference
+ with range checking
+ @sa @ref value() for access by value with a default value
+
+ @since version 1.0.0
+ */
+ template<typename T, std::size_t n>
+ const_reference operator[](T * (&key)[n]) const
+ {
+ return operator[](static_cast<const T>(key));
+ }
+
+ /*!
+ @brief access specified object element
+
+ Returns a reference to the element at with specified key @a key.
+
+ @note If @a key is not found in the object, then it is silently added to
+ the object and filled with a `null` value to make `key` a valid reference.
+ In case the value was `null` before, it is converted to an object.
+
+ @param[in] key key of the element to access
+
+ @return reference to the element at key @a key
+
+ @throw std::domain_error if JSON is not an object or null; example:
+ `"cannot use operator[] with string"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be read and
+ written using the `[]` operator.,operatorarray__key_type}
+
+ @sa @ref at(const typename object_t::key_type&) for access by reference
+ with range checking
+ @sa @ref value() for access by value with a default value
+
+ @since version 1.1.0
+ */
+ template<typename T>
+ reference operator[](T* key)
+ {
+ // implicitly convert null to object
+ if (is_null())
+ {
+ m_type = value_t::object;
+ m_value = value_t::object;
+ }
+
+ // at only works for objects
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ return m_value.object->operator[](key);
+ }
+ else
+ {
+ 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
+
+ @throw std::domain_error if JSON is not an object; example: `"cannot use
+ operator[] with null"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be read using
+ the `[]` operator.,operatorarray__key_type_const}
+
+ @sa @ref at(const typename object_t::key_type&) for access by reference
+ with range checking
+ @sa @ref value() for access by value with a default value
+
+ @since version 1.1.0
+ */
+ template<typename T>
+ const_reference operator[](T* key) const
+ {
+ // at only works for objects
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ assert(m_value.object->find(key) != m_value.object->end());
+ return m_value.object->find(key)->second;
+ }
+ else
+ {
+ throw std::domain_error("cannot use operator[] with " + type_name());
+ }
+ }
+
+ /*!
+ @brief access specified object element with default value
+
+ Returns either a copy of an object's element at the specified key @a key or
+ a given default value if no element with key @a key exists.
+
+ The function is basically equivalent to executing
+ @code {.cpp}
+ try {
+ return at(key);
+ } catch(std::out_of_range) {
+ return default_value;
+ }
+ @endcode
+
+ @note Unlike @ref at(const typename object_t::key_type&), this function
+ does not throw if the given key @a key was not found.
+
+ @note Unlike @ref operator[](const typename object_t::key_type& key), this
+ function does not implicitly add an element to the position defined by @a
+ key. This function is furthermore also applicable to const objects.
+
+ @param[in] key key of the element to access
+ @param[in] default_value the value to return if @a key is not found
+
+ @tparam ValueType type compatible to JSON values, for instance `int` for
+ JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
+ JSON arrays. Note the type of the expected value at @a key and the default
+ value @a default_value must be compatible.
+
+ @return copy of the element at key @a key or @a default_value if @a key
+ is not found
+
+ @throw std::domain_error if JSON is not an object; example: `"cannot use
+ value() with null"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be queried
+ with a default value.,basic_json__value}
+
+ @sa @ref at(const typename object_t::key_type&) for access by reference
+ with range checking
+ @sa @ref operator[](const typename object_t::key_type&) for unchecked
+ access by reference
+
+ @since version 1.0.0
+ */
+ template <class ValueType, typename
+ std::enable_if<
+ std::is_convertible<basic_json_t, ValueType>::value
+ , int>::type = 0>
+ ValueType value(const typename object_t::key_type& key, ValueType default_value) const
+ {
+ // at only works for objects
+ if (is_object())
+ {
+ // if key is found, return value and given default value otherwise
+ const auto it = find(key);
+ if (it != end())
+ {
+ return *it;
+ }
+ else
+ {
+ return default_value;
+ }
+ }
+ else
+ {
+ throw std::domain_error("cannot use value() with " + type_name());
+ }
+ }
+
+ /*!
+ @brief overload for a default value of type const char*
+ @copydoc basic_json::value()
+ */
+ string_t value(const typename object_t::key_type& key, const char* default_value) const
+ {
+ return value(key, 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 cast 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 cast 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 InteratorType 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 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(InteratorType, InteratorType) -- removes the elements in
+ the given range
+ @sa @ref erase(const typename object_t::key_type&) -- removes the element
+ from an object at the given key
+ @sa @ref erase(const size_type) -- removes the element from an array at
+ the given index
+
+ @since version 1.0.0
+ */
+ template <class InteratorType, typename
+ std::enable_if<
+ std::is_same<InteratorType, typename basic_json_t::iterator>::value or
+ std::is_same<InteratorType, typename basic_json_t::const_iterator>::value
+ , int>::type
+ = 0>
+ InteratorType erase(InteratorType pos)
+ {
+ // make sure iterator fits the current value
+ if (this != pos.m_object)
+ {
+ throw std::domain_error("iterator does not fit current value");
+ }
+
+ InteratorType 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())
+ {
+ throw std::out_of_range("iterator out of range");
+ }
+
+ if (is_string())
+ {
+ delete m_value.string;
+ m_value.string = nullptr;
+ }
+
+ m_type = value_t::null;
+ break;
+ }
+
+ case value_t::object:
+ {
+ assert(m_value.object != nullptr);
+ result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
+ break;
+ }
+
+ case value_t::array:
+ {
+ assert(m_value.array != nullptr);
+ result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
+ break;
+ }
+
+ default:
+ {
+ 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 InteratorType 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(InteratorType) -- removes the element at a given position
+ @sa @ref erase(const typename object_t::key_type&) -- removes the element
+ from an object at the given key
+ @sa @ref erase(const size_type) -- removes the element from an array at
+ the given index
+
+ @since version 1.0.0
+ */
+ template <class InteratorType, typename
+ std::enable_if<
+ std::is_same<InteratorType, typename basic_json_t::iterator>::value or
+ std::is_same<InteratorType, typename basic_json_t::const_iterator>::value
+ , int>::type
+ = 0>
+ InteratorType erase(InteratorType first, InteratorType last)
+ {
+ // make sure iterator fits the current value
+ if (this != first.m_object or this != last.m_object)
+ {
+ throw std::domain_error("iterators do not fit current value");
+ }
+
+ InteratorType 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())
+ {
+ throw std::out_of_range("iterators out of range");
+ }
+
+ if (is_string())
+ {
+ delete m_value.string;
+ m_value.string = nullptr;
+ }
+
+ m_type = value_t::null;
+ break;
+ }
+
+ case value_t::object:
+ {
+ assert(m_value.object != nullptr);
+ result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
+ last.m_it.object_iterator);
+ break;
+ }
+
+ case value_t::array:
+ {
+ assert(m_value.array != nullptr);
+ result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
+ last.m_it.array_iterator);
+ break;
+ }
+
+ default:
+ {
+ 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(InteratorType) -- removes the element at a given position
+ @sa @ref erase(InteratorType, InteratorType) -- 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())
+ {
+ assert(m_value.object != nullptr);
+ return m_value.object->erase(key);
+ }
+ else
+ {
+ 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(InteratorType) -- removes the element at a given position
+ @sa @ref erase(InteratorType, InteratorType) -- 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())
+ {
+ throw std::out_of_range("array index " + std::to_string(idx) + " is out of range");
+ }
+
+ assert(m_value.array != nullptr);
+ m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
+ }
+ else
+ {
+ 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.
+
+ @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, past-the-end (see 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())
+ {
+ assert(m_value.object != nullptr);
+ 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())
+ {
+ assert(m_value.object != nullptr);
+ 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).
+
+ @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
+ assert(not is_object() or m_value.object != nullptr);
+ return is_object() ? m_value.object->count(key) : 0;
+ }
+
+ /// @}
+
+
+ ///////////////
+ // iterators //
+ ///////////////
+
+ /// @name iterators
+ /// @{
+
+ /*!
+ @brief returns an iterator to the first element
+
+ Returns an iterator to the first element.
+
+ @image html range-begin-end.svg "Illustration from cppreference.com"
+
+ @return iterator to the first element
+
+ @complexity Constant.
+
+ @requirement This function helps `basic_json` satisfying the
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)
+ requirements:
+ - The complexity is constant.
+
+ @liveexample{The following code shows an example for `begin()`.,begin}
+
+ @sa @ref cbegin() -- returns a const iterator to the beginning
+ @sa @ref end() -- returns an iterator to the end
+ @sa @ref cend() -- returns a const iterator to the end
+
+ @since version 1.0.0
+ */
+ iterator begin() noexcept
+ {
+ iterator result(this);
+ result.set_begin();
+ return result;
+ }
+
+ /*!
+ @copydoc basic_json::cbegin()
+ */
+ const_iterator begin() const noexcept
+ {
+ return cbegin();
+ }
+
+ /*!
+ @brief returns a const iterator to the first element
+
+ Returns a const iterator to the first element.
+
+ @image html range-begin-end.svg "Illustration from cppreference.com"
+
+ @return const iterator to the first element
+
+ @complexity Constant.
+
+ @requirement This function helps `basic_json` satisfying the
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)
+ requirements:
+ - The complexity is constant.
+ - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.
+
+ @liveexample{The following code shows an example for `cbegin()`.,cbegin}
+
+ @sa @ref begin() -- returns an iterator to the beginning
+ @sa @ref end() -- returns an iterator to the end
+ @sa @ref cend() -- returns a const iterator to the end
+
+ @since version 1.0.0
+ */
+ const_iterator cbegin() const noexcept
+ {
+ const_iterator result(this);
+ result.set_begin();
+ return result;
+ }
+
+ /*!
+ @brief returns an iterator to one past the last element
+
+ Returns an iterator to one past the last element.
+
+ @image html range-begin-end.svg "Illustration from cppreference.com"
+
+ @return iterator one past the last element
+
+ @complexity Constant.
+
+ @requirement This function helps `basic_json` satisfying the
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)
+ requirements:
+ - The complexity is constant.
+
+ @liveexample{The following code shows an example for `end()`.,end}
+
+ @sa @ref cend() -- returns a const iterator to the end
+ @sa @ref begin() -- returns an iterator to the beginning
+ @sa @ref cbegin() -- returns a const iterator to the beginning
+
+ @since version 1.0.0
+ */
+ iterator end() noexcept
+ {
+ iterator result(this);
+ result.set_end();
+ return result;
+ }
+
+ /*!
+ @copydoc basic_json::cend()
+ */
+ const_iterator end() const noexcept
+ {
+ return cend();
+ }
+
+ /*!
+ @brief returns a const iterator to one past the last element
+
+ Returns a const iterator to one past the last element.
+
+ @image html range-begin-end.svg "Illustration from cppreference.com"
+
+ @return const iterator one past the last element
+
+ @complexity Constant.
+
+ @requirement This function helps `basic_json` satisfying the
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)
+ requirements:
+ - The complexity is constant.
+ - Has the semantics of `const_cast<const basic_json&>(*this).end()`.
+
+ @liveexample{The following code shows an example for `cend()`.,cend}
+
+ @sa @ref end() -- returns an iterator to the end
+ @sa @ref begin() -- returns an iterator to the beginning
+ @sa @ref cbegin() -- returns a const iterator to the beginning
+
+ @since version 1.0.0
+ */
+ const_iterator cend() const noexcept
+ {
+ const_iterator result(this);
+ result.set_end();
+ return result;
+ }
+
+ /*!
+ @brief returns an iterator to the reverse-beginning
+
+ Returns an iterator to the reverse-beginning; that is, the last element.
+
+ @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+ @complexity Constant.
+
+ @requirement This function helps `basic_json` satisfying the
+ [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
+ requirements:
+ - The complexity is constant.
+ - Has the semantics of `reverse_iterator(end())`.
+
+ @liveexample{The following code shows an example for `rbegin()`.,rbegin}
+
+ @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+ @sa @ref rend() -- returns a reverse iterator to the end
+ @sa @ref crend() -- returns a const reverse iterator to the end
+
+ @since version 1.0.0
+ */
+ reverse_iterator rbegin() noexcept
+ {
+ return reverse_iterator(end());
+ }
+
+ /*!
+ @copydoc basic_json::crbegin()
+ */
+ const_reverse_iterator rbegin() const noexcept
+ {
+ return crbegin();
+ }
+
+ /*!
+ @brief returns an iterator to the reverse-end
+
+ Returns an iterator to the reverse-end; that is, one before the first
+ element.
+
+ @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+ @complexity Constant.
+
+ @requirement This function helps `basic_json` satisfying the
+ [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
+ requirements:
+ - The complexity is constant.
+ - Has the semantics of `reverse_iterator(begin())`.
+
+ @liveexample{The following code shows an example for `rend()`.,rend}
+
+ @sa @ref crend() -- returns a const reverse iterator to the end
+ @sa @ref rbegin() -- returns a reverse iterator to the beginning
+ @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+
+ @since version 1.0.0
+ */
+ reverse_iterator rend() noexcept
+ {
+ return reverse_iterator(begin());
+ }
+
+ /*!
+ @copydoc basic_json::crend()
+ */
+ const_reverse_iterator rend() const noexcept
+ {
+ return crend();
+ }
+
+ /*!
+ @brief returns a const reverse iterator to the last element
+
+ Returns a const iterator to the reverse-beginning; that is, the last
+ element.
+
+ @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+ @complexity Constant.
+
+ @requirement This function helps `basic_json` satisfying the
+ [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
+ requirements:
+ - The complexity is constant.
+ - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.
+
+ @liveexample{The following code shows an example for `crbegin()`.,crbegin}
+
+ @sa @ref rbegin() -- returns a reverse iterator to the beginning
+ @sa @ref rend() -- returns a reverse iterator to the end
+ @sa @ref crend() -- returns a const reverse iterator to the end
+
+ @since version 1.0.0
+ */
+ const_reverse_iterator crbegin() const noexcept
+ {
+ return const_reverse_iterator(cend());
+ }
+
+ /*!
+ @brief returns a const reverse iterator to one before the first
+
+ Returns a const reverse iterator to the reverse-end; that is, one before
+ the first element.
+
+ @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+ @complexity Constant.
+
+ @requirement This function helps `basic_json` satisfying the
+ [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
+ requirements:
+ - The complexity is constant.
+ - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.
+
+ @liveexample{The following code shows an example for `crend()`.,crend}
+
+ @sa @ref rend() -- returns a reverse iterator to the end
+ @sa @ref rbegin() -- returns a reverse iterator to the beginning
+ @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+
+ @since version 1.0.0
+ */
+ const_reverse_iterator crend() const noexcept
+ {
+ return const_reverse_iterator(cbegin());
+ }
+
+ private:
+ // forward declaration
+ template<typename IteratorType> class iteration_proxy;
+
+ public:
+ /*!
+ @brief wrapper to access iterator member functions in range-based for
+
+ This function allows to access @ref iterator::key() and @ref
+ iterator::value() during range-based for loops. In these loops, a
+ reference to the JSON values is returned, so there is no access to the
+ underlying iterator.
+
+ @note The name of this function is not yet final and may change in the
+ future.
+ */
+ static iteration_proxy<iterator> iterator_wrapper(reference cont)
+ {
+ return iteration_proxy<iterator>(cont);
+ }
+
+ /*!
+ @copydoc iterator_wrapper(reference)
+ */
+ static iteration_proxy<const_iterator> iterator_wrapper(const_reference cont)
+ {
+ return iteration_proxy<const_iterator>(cont);
+ }
+
+ /// @}
+
+
+ //////////////
+ // capacity //
+ //////////////
+
+ /// @name capacity
+ /// @{
+
+ /*!
+ @brief checks whether the container is empty
+
+ Checks if a JSON value has no elements.
+
+ @return The return value depends on the different types and is
+ defined as follows:
+ Value type | return value
+ ----------- | -------------
+ null | `true`
+ boolean | `false`
+ string | `false`
+ number | `false`
+ object | result of function `object_t::empty()`
+ array | result of function `array_t::empty()`
+
+ @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:
+ {
+ assert(m_value.array != nullptr);
+ return m_value.array->empty();
+ }
+
+ case value_t::object:
+ {
+ assert(m_value.object != nullptr);
+ 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()
+
+ @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:
+ {
+ assert(m_value.array != nullptr);
+ return m_value.array->size();
+ }
+
+ case value_t::object:
+ {
+ assert(m_value.object != nullptr);
+ 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:
+ {
+ assert(m_value.array != nullptr);
+ return m_value.array->max_size();
+ }
+
+ case value_t::object:
+ {
+ assert(m_value.object != nullptr);
+ 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 | `[]`
+
+ @note Floating-point numbers are set to `0.0` which will be serialized to
+ `0`. The vale type remains @ref number_float_t.
+
+ @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:
+ {
+ assert(m_value.string != nullptr);
+ m_value.string->clear();
+ break;
+ }
+
+ case value_t::array:
+ {
+ assert(m_value.array != nullptr);
+ m_value.array->clear();
+ break;
+ }
+
+ case value_t::object:
+ {
+ assert(m_value.object != nullptr);
+ 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()))
+ {
+ 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;
+ }
+
+ // add element to array (move semantics)
+ assert(m_value.array != nullptr);
+ 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()))
+ {
+ 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;
+ }
+
+ // add element to array
+ assert(m_value.array != nullptr);
+ 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()))
+ {
+ 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;
+ }
+
+ // add element to array
+ assert(m_value.object != nullptr);
+ m_value.object->insert(val);
+ }
+
+ /*!
+ @brief add an object to an object
+ @copydoc push_back(const typename object_t::value_type&)
+ */
+ reference operator+=(const typename object_t::value_type& val)
+ {
+ push_back(val);
+ return *this;
+ }
+
+ /*!
+ @brief add an object to an object
+
+ This function allows to use `push_back` with an initializer list. In case
+
+ 1. the current value is an object,
+ 2. the initializer list @a init contains only two elements, and
+ 3. the first element of @a init is a string,
+
+ @a init is converted into an object element and added using
+ @ref push_back(const typename object_t::value_type&). Otherwise, @a init
+ is converted to a JSON value and added using @ref push_back(basic_json&&).
+
+ @param init an initializer list
+
+ @complexity Linear in the size of the initializer list @a init.
+
+ @note This function is required to resolve an ambiguous overload error,
+ because pairs like `{"key", "value"}` can be both interpreted as
+ `object_t::value_type` or `std::initializer_list<basic_json>`, see
+ https://github.com/nlohmann/json/issues/235 for more information.
+
+ @liveexample{The example shows how initializer lists are treated as
+ objects when possible.,push_back__initializer_list}
+ */
+ void push_back(std::initializer_list<basic_json> init)
+ {
+ if (is_object() and init.size() == 2 and init.begin()->is_string())
+ {
+ const string_t key = *init.begin();
+ push_back(typename object_t::value_type(key, *(init.begin() + 1)));
+ }
+ else
+ {
+ push_back(basic_json(init));
+ }
+ }
+
+ /*!
+ @brief add an object to an object
+ @copydoc push_back(std::initializer_list<basic_json>)
+ */
+ reference operator+=(std::initializer_list<basic_json> init)
+ {
+ push_back(init);
+ return *this;
+ }
+
+ /*!
+ @brief 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 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)
+ {
+ throw std::domain_error("iterator does not fit current value");
+ }
+
+ // insert to array and return iterator
+ iterator result(this);
+ assert(m_value.array != nullptr);
+ result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, val);
+ return result;
+ }
+ else
+ {
+ 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)
+ {
+ throw std::domain_error("iterator does not fit current value");
+ }
+
+ // insert to array and return iterator
+ iterator result(this);
+ assert(m_value.array != nullptr);
+ result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
+ return result;
+ }
+ else
+ {
+ 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())
+ {
+ throw std::domain_error("cannot use insert() with " + type_name());
+ }
+
+ // check if iterator pos fits to this JSON value
+ if (pos.m_object != this)
+ {
+ throw std::domain_error("iterator does not fit current value");
+ }
+
+ if (first.m_object != last.m_object)
+ {
+ throw std::domain_error("iterators do not fit");
+ }
+
+ if (first.m_object == this or last.m_object == this)
+ {
+ throw std::domain_error("passed iterators may not belong to container");
+ }
+
+ // insert to array and return iterator
+ iterator result(this);
+ assert(m_value.array != nullptr);
+ result.m_it.array_iterator = m_value.array->insert(
+ pos.m_it.array_iterator,
+ first.m_it.array_iterator,
+ last.m_it.array_iterator);
+ return result;
+ }
+
+ /*!
+ @brief inserts elements
+
+ Inserts elements from initializer list @a ilist before iterator @a pos.
+
+ @param[in] pos iterator before which the content will be inserted; may be
+ the end() iterator
+ @param[in] ilist initializer list to insert the values from
+
+ @throw std::domain_error if called on JSON values other than arrays;
+ example: `"cannot use insert() with string"`
+ @throw std::domain_error if @a pos is not an iterator of *this; example:
+ `"iterator does not fit current value"`
+
+ @return iterator pointing to the first element inserted, or @a pos if
+ `ilist` is empty
+
+ @complexity Linear in `ilist.size()` plus linear in the distance between
+ @a pos and end of the container.
+
+ @liveexample{The example shows how `insert()` is used.,insert__ilist}
+
+ @since version 1.0.0
+ */
+ iterator insert(const_iterator pos, std::initializer_list<basic_json> ilist)
+ {
+ // insert only works for arrays
+ if (not is_array())
+ {
+ throw std::domain_error("cannot use insert() with " + type_name());
+ }
+
+ // check if iterator pos fits to this JSON value
+ if (pos.m_object != this)
+ {
+ throw std::domain_error("iterator does not fit current value");
+ }
+
+ // insert to array and return iterator
+ iterator result(this);
+ assert(m_value.array != nullptr);
+ result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, ilist);
+ return result;
+ }
+
+ /*!
+ @brief exchanges the values
+
+ Exchanges the contents of the JSON value with those of @a other. Does not
+ invoke any move, copy, or swap operations on individual elements. All
+ iterators and references remain valid. The past-the-end iterator is
+ invalidated.
+
+ @param[in,out] other JSON value to exchange the contents with
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how JSON values can be swapped with
+ `swap()`.,swap__reference}
+
+ @since version 1.0.0
+ */
+ void swap(reference other) noexcept (
+ std::is_nothrow_move_constructible<value_t>::value and
+ std::is_nothrow_move_assignable<value_t>::value and
+ std::is_nothrow_move_constructible<json_value>::value and
+ std::is_nothrow_move_assignable<json_value>::value
+ )
+ {
+ std::swap(m_type, other.m_type);
+ std::swap(m_value, other.m_value);
+ }
+
+ /*!
+ @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())
+ {
+ assert(m_value.array != nullptr);
+ std::swap(*(m_value.array), other);
+ }
+ else
+ {
+ 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())
+ {
+ assert(m_value.object != nullptr);
+ std::swap(*(m_value.object), other);
+ }
+ else
+ {
+ 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())
+ {
+ assert(m_value.string != nullptr);
+ std::swap(*(m_value.string), other);
+ }
+ else
+ {
+ throw std::domain_error("cannot use swap() with " + type_name());
+ }
+ }
+
+ /// @}
+
+
+ //////////////////////////////////////////
+ // lexicographical comparison operators //
+ //////////////////////////////////////////
+
+ /// @name lexicographical comparison operators
+ /// @{
+
+ private:
+ /*!
+ @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
+ */
+ friend bool operator<(const value_t lhs, const value_t rhs) noexcept
+ {
+ static constexpr std::array<uint8_t, 8> order = {{
+ 0, // null
+ 3, // object
+ 4, // array
+ 5, // string
+ 1, // boolean
+ 2, // integer
+ 2, // unsigned
+ 2, // float
+ }
+ };
+
+ // discarded values are not comparable
+ if (lhs == value_t::discarded or rhs == value_t::discarded)
+ {
+ return false;
+ }
+
+ return order[static_cast<std::size_t>(lhs)] < order[static_cast<std::size_t>(rhs)];
+ }
+
+ public:
+ /*!
+ @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:
+ {
+ assert(lhs.m_value.array != nullptr);
+ assert(rhs.m_value.array != nullptr);
+ return *lhs.m_value.array == *rhs.m_value.array;
+ }
+ case value_t::object:
+ {
+ assert(lhs.m_value.object != nullptr);
+ assert(rhs.m_value.object != nullptr);
+ return *lhs.m_value.object == *rhs.m_value.object;
+ }
+ case value_t::null:
+ {
+ return true;
+ }
+ case value_t::string:
+ {
+ assert(lhs.m_value.string != nullptr);
+ assert(rhs.m_value.string != nullptr);
+ return *lhs.m_value.string == *rhs.m_value.string;
+ }
+ case value_t::boolean:
+ {
+ return lhs.m_value.boolean == rhs.m_value.boolean;
+ }
+ case value_t::number_integer:
+ {
+ return lhs.m_value.number_integer == rhs.m_value.number_integer;
+ }
+ case value_t::number_unsigned:
+ {
+ return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
+ }
+ case value_t::number_float:
+ {
+ return lhs.m_value.number_float == rhs.m_value.number_float;
+ }
+ default:
+ {
+ return false;
+ }
+ }
+ }
+ else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+ {
+ return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
+ }
+ else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+ {
+ return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
+ }
+ else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
+ {
+ return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
+ }
+ else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
+ {
+ return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
+ }
+ else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
+ {
+ return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
+ }
+ else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
+ {
+ return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
+ }
+
+ return false;
+ }
+
+ /*!
+ @brief comparison: equal
+
+ The functions compares the given JSON value against a null pointer. As the
+ null pointer can be used to initialize a JSON value to null, a comparison
+ of JSON value @a v with a null pointer should be equivalent to call
+ `v.is_null()`.
+
+ @param[in] v JSON value to consider
+ @return whether @a v is null
+
+ @complexity Constant.
+
+ @liveexample{The example compares several JSON types to the null pointer.
+ ,operator__equal__nullptr_t}
+
+ @since version 1.0.0
+ */
+ friend bool operator==(const_reference v, std::nullptr_t) noexcept
+ {
+ return v.is_null();
+ }
+
+ /*!
+ @brief comparison: equal
+ @copydoc operator==(const_reference, std::nullptr_t)
+ */
+ friend bool operator==(std::nullptr_t, const_reference v) noexcept
+ {
+ return v.is_null();
+ }
+
+ /*!
+ @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
+
+ The functions compares the given JSON value against a null pointer. As the
+ null pointer can be used to initialize a JSON value to null, a comparison
+ of JSON value @a v with a null pointer should be equivalent to call
+ `not v.is_null()`.
+
+ @param[in] v JSON value to consider
+ @return whether @a v is not null
+
+ @complexity Constant.
+
+ @liveexample{The example compares several JSON types to the null pointer.
+ ,operator__notequal__nullptr_t}
+
+ @since version 1.0.0
+ */
+ friend bool operator!=(const_reference v, std::nullptr_t) noexcept
+ {
+ return not v.is_null();
+ }
+
+ /*!
+ @brief comparison: not equal
+ @copydoc operator!=(const_reference, std::nullptr_t)
+ */
+ friend bool operator!=(std::nullptr_t, const_reference v) noexcept
+ {
+ return not v.is_null();
+ }
+
+ /*!
+ @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:
+ {
+ assert(lhs.m_value.array != nullptr);
+ assert(rhs.m_value.array != nullptr);
+ return *lhs.m_value.array < *rhs.m_value.array;
+ }
+ case value_t::object:
+ {
+ assert(lhs.m_value.object != nullptr);
+ assert(rhs.m_value.object != nullptr);
+ return *lhs.m_value.object < *rhs.m_value.object;
+ }
+ case value_t::null:
+ {
+ return false;
+ }
+ case value_t::string:
+ {
+ assert(lhs.m_value.string != nullptr);
+ assert(rhs.m_value.string != nullptr);
+ return *lhs.m_value.string < *rhs.m_value.string;
+ }
+ case value_t::boolean:
+ {
+ return lhs.m_value.boolean < rhs.m_value.boolean;
+ }
+ case value_t::number_integer:
+ {
+ return lhs.m_value.number_integer < rhs.m_value.number_integer;
+ }
+ case value_t::number_unsigned:
+ {
+ return lhs.m_value.number_unsigned < rhs.m_value.number_unsigned;
+ }
+ case value_t::number_float:
+ {
+ return lhs.m_value.number_float < rhs.m_value.number_float;
+ }
+ default:
+ {
+ return false;
+ }
+ }
+ }
+ else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+ {
+ return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
+ }
+ else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+ {
+ return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
+ }
+ else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
+ {
+ return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
+ }
+ else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
+ {
+ return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
+ }
+ else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
+ {
+ return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
+ }
+ else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
+ {
+ return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
+ }
+
+ // We only reach this line if we cannot compare values. In that case,
+ // we compare types. Note we have to call the operator explicitly,
+ // because MSVC has problems otherwise.
+ return operator<(lhs_type, rhs_type);
+ }
+
+ /*!
+ @brief comparison: less than or equal
+
+ Compares whether one JSON value @a lhs is less than or equal to another
+ JSON value by calculating `not (rhs < lhs)`.
+
+ @param[in] lhs first JSON value to consider
+ @param[in] rhs second JSON value to consider
+ @return whether @a lhs is less than or equal to @a rhs
+
+ @complexity Linear.
+
+ @liveexample{The example demonstrates comparing several JSON
+ types.,operator__greater}
+
+ @since version 1.0.0
+ */
+ friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
+ {
+ return not (rhs < lhs);
+ }
+
+ /*!
+ @brief comparison: greater than
+
+ Compares whether one JSON value @a lhs is greater than another
+ JSON value by calculating `not (lhs <= rhs)`.
+
+ @param[in] lhs first JSON value to consider
+ @param[in] rhs second JSON value to consider
+ @return whether @a lhs is greater than to @a rhs
+
+ @complexity Linear.
+
+ @liveexample{The example demonstrates comparing several JSON
+ types.,operator__lessequal}
+
+ @since version 1.0.0
+ */
+ friend bool operator>(const_reference lhs, const_reference rhs) noexcept
+ {
+ return not (lhs <= rhs);
+ }
+
+ /*!
+ @brief comparison: greater than or equal
+
+ Compares whether one JSON value @a lhs is greater than or equal to another
+ JSON value by calculating `not (lhs < rhs)`.
+
+ @param[in] lhs first JSON value to consider
+ @param[in] rhs second JSON value to consider
+ @return whether @a lhs is greater than or equal to @a rhs
+
+ @complexity Linear.
+
+ @liveexample{The example demonstrates comparing several JSON
+ types.,operator__greaterequal}
+
+ @since version 1.0.0
+ */
+ friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
+ {
+ return not (lhs < rhs);
+ }
+
+ /// @}
+
+
+ ///////////////////
+ // serialization //
+ ///////////////////
+
+ /// @name serialization
+ /// @{
+
+ /*!
+ @brief serialize to stream
+
+ Serialize the given JSON value @a j to the output stream @a o. The JSON
+ value will be serialized using the @ref dump member function. The
+ indentation of the output can be controlled with the member variable
+ `width` of the output stream @a o. For instance, using the manipulator
+ `std::setw(4)` on @a o sets the indentation level to `4` and the
+ serialization result is the same as calling `dump(4)`.
+
+ @param[in,out] o stream to serialize to
+ @param[in] j JSON value to serialize
+
+ @return the stream @a o
+
+ @complexity Linear.
+
+ @liveexample{The example below shows the serialization with different
+ parameters to `width` to adjust the indentation level.,operator_serialize}
+
+ @since version 1.0.0
+ */
+ friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
+ {
+ // read width member and use it as indentation parameter if nonzero
+ const bool pretty_print = (o.width() > 0);
+ const auto indentation = (pretty_print ? o.width() : 0);
+
+ // reset width to 0 for subsequent calls to this stream
+ o.width(0);
+
+ // do the actual serialization
+ j.dump(o, pretty_print, static_cast<unsigned int>(indentation));
+ return o;
+ }
+
+ /*!
+ @brief serialize to stream
+ @copydoc operator<<(std::ostream&, const basic_json&)
+ */
+ friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
+ {
+ return o << j;
+ }
+
+ /// @}
+
+
+ /////////////////////
+ // deserialization //
+ /////////////////////
+
+ /// @name deserialization
+ /// @{
+
+ /*!
+ @brief deserialize from string
+
+ @param[in] s string 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__string__parser_callback_t}
+
+ @sa @ref parse(std::istream&, parser_callback_t) for a version that reads
+ from an input stream
+
+ @since version 1.0.0
+ */
+ static basic_json parse(const string_t& s, parser_callback_t cb = nullptr)
+ {
+ return parser(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 string_t&, parser_callback_t) for a version that
+ reads from a string
+
+ @since version 1.0.0
+ */
+ static basic_json parse(std::istream& i, parser_callback_t cb = nullptr)
+ {
+ return parser(i, cb).parse();
+ }
+
+ /*!
+ @copydoc parse(std::istream&, parser_callback_t)
+ */
+ static basic_json parse(std::istream&& i, parser_callback_t cb = nullptr)
+ {
+ return parser(i, cb).parse();
+ }
+
+ /*!
+ @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&, 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;
+ }
+
+ /// @}
+
+
+ private:
+ ///////////////////////////
+ // convenience functions //
+ ///////////////////////////
+
+ /// return the type as string
+ string_t 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";
+ }
+ }
+
+ /*!
+ @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
+ {
+ std::size_t result = 0;
+
+ for (const auto& c : s)
+ {
+ switch (c)
+ {
+ case '"':
+ case '\\':
+ case '\b':
+ case '\f':
+ case '\n':
+ case '\r':
+ case '\t':
+ {
+ // from c (1 byte) to \x (2 bytes)
+ result += 1;
+ break;
+ }
+
+ default:
+ {
+ if (c >= 0x00 and c <= 0x1f)
+ {
+ // from c (1 byte) to \uxxxx (6 bytes)
+ result += 5;
+ }
+ break;
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /*!
+ @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)
+ const auto hexify = [](const int v) -> char
+ {
+ return (v < 10)
+ ? ('0' + static_cast<char>(v))
+ : ('a' + static_cast<char>((v - 10) & 0x1f));
+ };
+
+ // 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 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:
+ {
+ assert(m_value.object != nullptr);
+
+ 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:
+ {
+ assert(m_value.array != nullptr);
+
+ 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:
+ {
+ assert(m_value.string != nullptr);
+ 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 << m_value.number_integer;
+ return;
+ }
+
+ case value_t::number_unsigned:
+ {
+ o << m_value.number_unsigned;
+ return;
+ }
+
+ case value_t::number_float:
+ {
+ // check if number was parsed from a string
+ if (m_type.bits.parsed)
+ {
+ // check if parsed number had an exponent given
+ if (m_type.bits.has_exp)
+ {
+ // buffer size: precision (2^8-1 = 255) + other ('-.e-xxx' = 7) + null (1)
+ char buf[263];
+ int len;
+
+ // handle capitalization of the exponent
+ if (m_type.bits.exp_cap)
+ {
+ len = snprintf(buf, sizeof(buf), "%.*E",
+ m_type.bits.precision, m_value.number_float) + 1;
+ }
+ else
+ {
+ len = snprintf(buf, sizeof(buf), "%.*e",
+ m_type.bits.precision, m_value.number_float) + 1;
+ }
+
+ // remove '+' sign from the exponent if necessary
+ if (not m_type.bits.exp_plus)
+ {
+ if (len > static_cast<int>(sizeof(buf)))
+ {
+ len = sizeof(buf);
+ }
+ for (int i = 0; i < len; i++)
+ {
+ if (buf[i] == '+')
+ {
+ for (; i + 1 < len; i++)
+ {
+ buf[i] = buf[i + 1];
+ }
+ }
+ }
+ }
+
+ o << buf;
+ }
+ else
+ {
+ // no exponent - output as a decimal
+ std::stringstream ss;
+ ss.imbue(std::locale(std::locale(), new DecimalSeparator)); // fix locale problems
+ ss << std::setprecision(m_type.bits.precision)
+ << std::fixed << m_value.number_float;
+ o << ss.str();
+ }
+ }
+ else
+ {
+ if (m_value.number_float == 0)
+ {
+ // special case for zero to get "0.0"/"-0.0"
+ o << (std::signbit(m_value.number_float) ? "-0.0" : "0.0");
+ }
+ else
+ {
+ // Otherwise 6, 15 or 16 digits of precision allows
+ // round-trip IEEE 754 string->float->string,
+ // string->double->string or string->long
+ // double->string; to be safe, we read this value from
+ // std::numeric_limits<number_float_t>::digits10
+ std::stringstream ss;
+ ss.imbue(std::locale(std::locale(), new DecimalSeparator)); // fix locale problems
+ ss << std::setprecision(std::numeric_limits<double>::digits10)
+ << m_value.number_float;
+ o << ss.str();
+ }
+ }
+ return;
+ }
+
+ case value_t::discarded:
+ {
+ o << "<discarded>";
+ return;
+ }
+
+ case value_t::null:
+ {
+ o << "null";
+ return;
+ }
+ }
+ }
+
+ private:
+ //////////////////////
+ // member variables //
+ //////////////////////
+
+ /// the type of the current element
+ type_data_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:
+ /// 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);
+ }
+
+ /// return reference to the value to change and compare
+ operator difference_type& () noexcept
+ {
+ return m_it;
+ }
+
+ /// return value to compare
+ constexpr operator difference_type () const noexcept
+ {
+ return m_it;
+ }
+
+ private:
+ static constexpr difference_type begin_value = 0;
+ static constexpr difference_type end_value = begin_value + 1;
+
+ /// iterator as signed integer type
+ difference_type m_it = std::numeric_limits<std::ptrdiff_t>::denorm_min();
+ };
+
+ /*!
+ @brief an iterator value
+
+ @note This structure could easily be a union, but MSVC currently does not
+ allow unions members with complex constructors, see
+ https://github.com/nlohmann/json/pull/105.
+ */
+ struct internal_iterator
+ {
+ /// iterator for JSON objects
+ typename object_t::iterator object_iterator;
+ /// iterator for JSON arrays
+ typename array_t::iterator array_iterator;
+ /// generic iterator for all other types
+ primitive_iterator_t primitive_iterator;
+
+ /// create an uninitialized internal_iterator
+ internal_iterator() noexcept
+ : object_iterator(), array_iterator(), primitive_iterator()
+ {}
+ };
+
+ /// proxy class for the iterator_wrapper functions
+ template<typename IteratorType>
+ class iteration_proxy
+ {
+ private:
+ /// helper class for iteration
+ class iteration_proxy_internal
+ {
+ private:
+ /// the iterator
+ IteratorType anchor;
+ /// an index for arrays (used to create key names)
+ size_t array_index = 0;
+
+ public:
+ explicit iteration_proxy_internal(IteratorType it) noexcept
+ : anchor(it)
+ {}
+
+ /// dereference operator (needed for range-based for)
+ iteration_proxy_internal& operator*()
+ {
+ return *this;
+ }
+
+ /// increment operator (needed for range-based for)
+ iteration_proxy_internal& operator++()
+ {
+ ++anchor;
+ ++array_index;
+
+ return *this;
+ }
+
+ /// inequality operator (needed for range-based for)
+ bool operator!= (const iteration_proxy_internal& o) const
+ {
+ return anchor != o.anchor;
+ }
+
+ /// return key of the iterator
+ typename basic_json::string_t key() const
+ {
+ assert(anchor.m_object != nullptr);
+
+ switch (anchor.m_object->type())
+ {
+ // use integer array index as key
+ case value_t::array:
+ {
+ return std::to_string(array_index);
+ }
+
+ // use key from the object
+ case value_t::object:
+ {
+ return anchor.key();
+ }
+
+ // use an empty key for all primitive types
+ default:
+ {
+ return "";
+ }
+ }
+ }
+
+ /// return value of the iterator
+ typename IteratorType::reference value() const
+ {
+ return anchor.value();
+ }
+ };
+
+ /// the container to iterate
+ typename IteratorType::reference container;
+
+ public:
+ /// construct iteration proxy from a container
+ explicit iteration_proxy(typename IteratorType::reference cont)
+ : container(cont)
+ {}
+
+ /// return iterator begin (needed for range-based for)
+ iteration_proxy_internal begin() noexcept
+ {
+ return iteration_proxy_internal(container.begin());
+ }
+
+ /// return iterator end (needed for range-based for)
+ iteration_proxy_internal end() noexcept
+ {
+ return iteration_proxy_internal(container.end());
+ }
+ };
+
+ public:
+ /*!
+ @brief a const random access iterator for the @ref basic_json class
+
+ This class implements a const iterator for the @ref basic_json class. From
+ this class, the @ref iterator class is derived.
+
+ @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
+ */
+ class const_iterator : public std::iterator<std::random_access_iterator_tag, const basic_json>
+ {
+ /// allow basic_json to access private members
+ friend class 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 basic_json::const_pointer;
+ /// defines a reference to the type iterated over (value_type)
+ using reference = typename basic_json::const_reference;
+ /// the category of the iterator
+ using iterator_category = std::bidirectional_iterator_tag;
+
+ /// default constructor
+ const_iterator() = default;
+
+ /// constructor for a given JSON instance
+ explicit const_iterator(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;
+ }
+ }
+ }
+
+ /// copy constructor given a nonconst iterator
+ explicit const_iterator(const iterator& other) noexcept
+ : m_object(other.m_object)
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ m_it.object_iterator = other.m_it.object_iterator;
+ break;
+ }
+
+ case basic_json::value_t::array:
+ {
+ m_it.array_iterator = other.m_it.array_iterator;
+ break;
+ }
+
+ default:
+ {
+ m_it.primitive_iterator = other.m_it.primitive_iterator;
+ break;
+ }
+ }
+ }
+
+ /// copy constructor
+ const_iterator(const const_iterator& other) noexcept
+ : m_object(other.m_object), m_it(other.m_it)
+ {}
+
+ /// copy assignment
+ const_iterator& operator=(const_iterator other) noexcept(
+ std::is_nothrow_move_constructible<pointer>::value and
+ std::is_nothrow_move_assignable<pointer>::value and
+ std::is_nothrow_move_constructible<internal_iterator>::value and
+ std::is_nothrow_move_assignable<internal_iterator>::value
+ )
+ {
+ std::swap(m_object, other.m_object);
+ std::swap(m_it, other.m_it);
+ return *this;
+ }
+
+ private:
+ /// set the iterator to the first value
+ void set_begin() noexcept
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ assert(m_object->m_value.object != nullptr);
+ m_it.object_iterator = m_object->m_value.object->begin();
+ break;
+ }
+
+ case basic_json::value_t::array:
+ {
+ assert(m_object->m_value.array != nullptr);
+ 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;
+ }
+ }
+ }
+
+ /// set the iterator past the last value
+ void set_end() noexcept
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ assert(m_object->m_value.object != nullptr);
+ m_it.object_iterator = m_object->m_value.object->end();
+ break;
+ }
+
+ case basic_json::value_t::array:
+ {
+ assert(m_object->m_value.array != nullptr);
+ m_it.array_iterator = m_object->m_value.array->end();
+ break;
+ }
+
+ default:
+ {
+ m_it.primitive_iterator.set_end();
+ break;
+ }
+ }
+ }
+
+ public:
+ /// return a reference to the value pointed to by the iterator
+ reference operator*() const
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ assert(m_object->m_value.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_object->m_value.array);
+ assert(m_it.array_iterator != m_object->m_value.array->end());
+ return *m_it.array_iterator;
+ }
+
+ case basic_json::value_t::null:
+ {
+ throw std::out_of_range("cannot get value");
+ }
+
+ default:
+ {
+ if (m_it.primitive_iterator.is_begin())
+ {
+ return *m_object;
+ }
+ else
+ {
+ throw std::out_of_range("cannot get value");
+ }
+ }
+ }
+ }
+
+ /// dereference the iterator
+ pointer operator->() const
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ assert(m_object->m_value.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_object->m_value.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;
+ }
+ else
+ {
+ throw std::out_of_range("cannot get value");
+ }
+ }
+ }
+ }
+
+ /// post-increment (it++)
+ const_iterator operator++(int)
+ {
+ auto result = *this;
+ ++(*this);
+ return result;
+ }
+
+ /// pre-increment (++it)
+ const_iterator& operator++()
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ ++m_it.object_iterator;
+ break;
+ }
+
+ case basic_json::value_t::array:
+ {
+ ++m_it.array_iterator;
+ break;
+ }
+
+ default:
+ {
+ ++m_it.primitive_iterator;
+ break;
+ }
+ }
+
+ return *this;
+ }
+
+ /// post-decrement (it--)
+ const_iterator operator--(int)
+ {
+ auto result = *this;
+ --(*this);
+ return result;
+ }
+
+ /// pre-decrement (--it)
+ const_iterator& operator--()
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ --m_it.object_iterator;
+ break;
+ }
+
+ case basic_json::value_t::array:
+ {
+ --m_it.array_iterator;
+ break;
+ }
+
+ default:
+ {
+ --m_it.primitive_iterator;
+ break;
+ }
+ }
+
+ return *this;
+ }
+
+ /// comparison: equal
+ bool operator==(const const_iterator& other) const
+ {
+ // if objects are not the same, the comparison is undefined
+ if (m_object != other.m_object)
+ {
+ 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);
+ }
+ }
+ }
+
+ /// comparison: not equal
+ bool operator!=(const const_iterator& other) const
+ {
+ return not operator==(other);
+ }
+
+ /// comparison: smaller
+ bool operator<(const const_iterator& other) const
+ {
+ // if objects are not the same, the comparison is undefined
+ if (m_object != other.m_object)
+ {
+ 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:
+ {
+ 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);
+ }
+ }
+ }
+
+ /// comparison: less than or equal
+ bool operator<=(const const_iterator& other) const
+ {
+ return not other.operator < (*this);
+ }
+
+ /// comparison: greater than
+ bool operator>(const const_iterator& other) const
+ {
+ return not operator<=(other);
+ }
+
+ /// comparison: greater than or equal
+ bool operator>=(const const_iterator& other) const
+ {
+ return not operator<(other);
+ }
+
+ /// add to iterator
+ const_iterator& operator+=(difference_type i)
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ throw std::domain_error("cannot use offsets with object iterators");
+ }
+
+ case basic_json::value_t::array:
+ {
+ m_it.array_iterator += i;
+ break;
+ }
+
+ default:
+ {
+ m_it.primitive_iterator += i;
+ break;
+ }
+ }
+
+ return *this;
+ }
+
+ /// subtract from iterator
+ const_iterator& operator-=(difference_type i)
+ {
+ return operator+=(-i);
+ }
+
+ /// add to iterator
+ const_iterator operator+(difference_type i)
+ {
+ auto result = *this;
+ result += i;
+ return result;
+ }
+
+ /// subtract from iterator
+ const_iterator operator-(difference_type i)
+ {
+ auto result = *this;
+ result -= i;
+ return result;
+ }
+
+ /// return difference
+ difference_type operator-(const const_iterator& other) const
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ 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;
+ }
+ }
+ }
+
+ /// access to successor
+ reference operator[](difference_type n) const
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ throw std::domain_error("cannot use operator[] for object iterators");
+ }
+
+ case basic_json::value_t::array:
+ {
+ return *(m_it.array_iterator + n);
+ }
+
+ case basic_json::value_t::null:
+ {
+ throw std::out_of_range("cannot get value");
+ }
+
+ default:
+ {
+ if (m_it.primitive_iterator == -n)
+ {
+ return *m_object;
+ }
+ else
+ {
+ throw std::out_of_range("cannot get value");
+ }
+ }
+ }
+ }
+
+ /// return the key of an object iterator
+ typename object_t::key_type key() const
+ {
+ assert(m_object != nullptr);
+
+ if (m_object->is_object())
+ {
+ return m_it.object_iterator->first;
+ }
+ else
+ {
+ throw std::domain_error("cannot use key() for non-object iterators");
+ }
+ }
+
+ /// return the value of an iterator
+ 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 mutable random access iterator for the @ref basic_json class
+
+ @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.
+
+ @since version 1.0.0
+ */
+ class iterator : public const_iterator
+ {
+ public:
+ using base_iterator = const_iterator;
+ using pointer = typename basic_json::pointer;
+ using reference = typename basic_json::reference;
+
+ /// default constructor
+ iterator() = default;
+
+ /// constructor for a given JSON instance
+ explicit iterator(pointer object) noexcept
+ : base_iterator(object)
+ {}
+
+ /// copy constructor
+ iterator(const iterator& other) noexcept
+ : base_iterator(other)
+ {}
+
+ /// copy assignment
+ iterator& operator=(iterator other) noexcept(
+ std::is_nothrow_move_constructible<pointer>::value and
+ std::is_nothrow_move_assignable<pointer>::value and
+ std::is_nothrow_move_constructible<internal_iterator>::value and
+ std::is_nothrow_move_assignable<internal_iterator>::value
+ )
+ {
+ base_iterator::operator=(other);
+ return *this;
+ }
+
+ /// return a reference to the value pointed to by the iterator
+ reference operator*() const
+ {
+ return const_cast<reference>(base_iterator::operator*());
+ }
+
+ /// dereference the iterator
+ pointer operator->() const
+ {
+ return const_cast<pointer>(base_iterator::operator->());
+ }
+
+ /// post-increment (it++)
+ iterator operator++(int)
+ {
+ iterator result = *this;
+ base_iterator::operator++();
+ return result;
+ }
+
+ /// pre-increment (++it)
+ iterator& operator++()
+ {
+ base_iterator::operator++();
+ return *this;
+ }
+
+ /// post-decrement (it--)
+ iterator operator--(int)
+ {
+ iterator result = *this;
+ base_iterator::operator--();
+ return result;
+ }
+
+ /// pre-decrement (--it)
+ iterator& operator--()
+ {
+ base_iterator::operator--();
+ return *this;
+ }
+
+ /// add to iterator
+ iterator& operator+=(difference_type i)
+ {
+ base_iterator::operator+=(i);
+ return *this;
+ }
+
+ /// subtract from iterator
+ iterator& operator-=(difference_type i)
+ {
+ base_iterator::operator-=(i);
+ return *this;
+ }
+
+ /// add to iterator
+ iterator operator+(difference_type i)
+ {
+ auto result = *this;
+ result += i;
+ return result;
+ }
+
+ /// subtract from iterator
+ iterator operator-(difference_type i)
+ {
+ auto result = *this;
+ result -= i;
+ return result;
+ }
+
+ /// return difference
+ difference_type operator-(const iterator& other) const
+ {
+ return base_iterator::operator-(other);
+ }
+
+ /// access to successor
+ reference operator[](difference_type n) const
+ {
+ return const_cast<reference>(base_iterator::operator[](n));
+ }
+
+ /// return the value of an iterator
+ reference value() const
+ {
+ return const_cast<reference>(base_iterator::value());
+ }
+ };
+
+ /*!
+ @brief a template for a reverse iterator class
+
+ @tparam Base the base iterator type to reverse. Valid types are @ref
+ iterator (to create @ref reverse_iterator) and @ref const_iterator (to
+ create @ref const_reverse_iterator).
+
+ @requirement The class satisfies the following concept requirements:
+ - [RandomAccessIterator](http://en.cppreference.com/w/cpp/concept/RandomAccessIterator):
+ The iterator that can be moved to point (forward and backward) to any
+ element in constant time.
+ - [OutputIterator](http://en.cppreference.com/w/cpp/concept/OutputIterator):
+ It is possible to write to the pointed-to element (only if @a Base is
+ @ref iterator).
+
+ @since version 1.0.0
+ */
+ template<typename Base>
+ class json_reverse_iterator : public std::reverse_iterator<Base>
+ {
+ public:
+ /// shortcut to the reverse iterator adaptor
+ using base_iterator = std::reverse_iterator<Base>;
+ /// the reference type for the pointed-to element
+ using reference = typename Base::reference;
+
+ /// create reverse iterator from iterator
+ json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
+ : base_iterator(it)
+ {}
+
+ /// create reverse iterator from base class
+ json_reverse_iterator(const base_iterator& it) noexcept
+ : base_iterator(it)
+ {}
+
+ /// post-increment (it++)
+ json_reverse_iterator operator++(int)
+ {
+ return base_iterator::operator++(1);
+ }
+
+ /// pre-increment (++it)
+ json_reverse_iterator& operator++()
+ {
+ base_iterator::operator++();
+ return *this;
+ }
+
+ /// post-decrement (it--)
+ json_reverse_iterator operator--(int)
+ {
+ return base_iterator::operator--(1);
+ }
+
+ /// pre-decrement (--it)
+ json_reverse_iterator& operator--()
+ {
+ base_iterator::operator--();
+ return *this;
+ }
+
+ /// add to iterator
+ json_reverse_iterator& operator+=(difference_type i)
+ {
+ base_iterator::operator+=(i);
+ return *this;
+ }
+
+ /// add to iterator
+ json_reverse_iterator operator+(difference_type i) const
+ {
+ auto result = *this;
+ result += i;
+ return result;
+ }
+
+ /// subtract from iterator
+ json_reverse_iterator operator-(difference_type i) const
+ {
+ auto result = *this;
+ result -= i;
+ return result;
+ }
+
+ /// return difference
+ difference_type operator-(const json_reverse_iterator& other) const
+ {
+ return this->base() - other.base();
+ }
+
+ /// access to successor
+ reference operator[](difference_type n) const
+ {
+ return *(this->operator+(n));
+ }
+
+ /// return the key of an object iterator
+ typename object_t::key_type key() const
+ {
+ auto it = --this->base();
+ return it.key();
+ }
+
+ /// return the value of an iterator
+ reference value() const
+ {
+ auto it = --this->base();
+ return it.operator * ();
+ }
+ };
+
+
+ private:
+ //////////////////////
+ // lexer and parser //
+ //////////////////////
+
+ /*!
+ @brief lexical analysis
+
+ This class organizes the lexical analysis during JSON deserialization. The
+ core of it is a scanner generated by [re2c](http://re2c.org) that
+ processes a buffer and recognizes tokens according to RFC 7159.
+ */
+ class lexer
+ {
+ public:
+ /// token types for the parser
+ enum class token_type
+ {
+ uninitialized, ///< indicating the scanner is uninitialized
+ literal_true, ///< the "true" literal
+ literal_false, ///< the "false" literal
+ literal_null, ///< the "null" literal
+ value_string, ///< a string -- use get_string() for actual value
+ value_number, ///< a 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;
+
+ /// constructor with a given buffer
+ explicit lexer(const string_t& s) noexcept
+ : m_stream(nullptr), m_buffer(s)
+ {
+ m_content = reinterpret_cast<const lexer_char_t*>(s.c_str());
+ assert(m_content != nullptr);
+ m_start = m_cursor = m_content;
+ m_limit = m_content + s.size();
+ }
+
+ /// constructor with a given stream
+ explicit lexer(std::istream* s) noexcept
+ : m_stream(s), m_buffer()
+ {
+ assert(m_stream != nullptr);
+ getline(*m_stream, m_buffer);
+ m_content = reinterpret_cast<const lexer_char_t*>(m_buffer.c_str());
+ assert(m_content != nullptr);
+ m_start = m_cursor = m_content;
+ m_limit = m_content + m_buffer.size();
+ }
+
+ /// default constructor
+ lexer() = default;
+
+ // switch off unwanted functions
+ lexer(const lexer&) = delete;
+ lexer operator=(const lexer&) = delete;
+
+ /*!
+ @brief create a string from a Unicode code point
+
+ @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
+
+ @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""`
+
+ @see <http://en.wikipedia.org/wiki/UTF-8#Sample_code>
+ */
+ static string_t to_unicode(const std::size_t codepoint1,
+ const std::size_t codepoint2 = 0)
+ {
+ // calculate the codepoint 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
+ {
+ throw std::invalid_argument("missing or wrong low surrogate");
+ }
+ }
+
+ string_t result;
+
+ if (codepoint < 0x80)
+ {
+ // 1-byte characters: 0xxxxxxx (ASCII)
+ result.append(1, static_cast<typename string_t::value_type>(codepoint));
+ }
+ else if (codepoint <= 0x7ff)
+ {
+ // 2-byte characters: 110xxxxx 10xxxxxx
+ result.append(1, static_cast<typename string_t::value_type>(0xC0 | ((codepoint >> 6) & 0x1F)));
+ result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
+ }
+ else if (codepoint <= 0xffff)
+ {
+ // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+ result.append(1, static_cast<typename string_t::value_type>(0xE0 | ((codepoint >> 12) & 0x0F)));
+ result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
+ result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
+ }
+ else if (codepoint <= 0x10ffff)
+ {
+ // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ result.append(1, static_cast<typename string_t::value_type>(0xF0 | ((codepoint >> 18) & 0x07)));
+ result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 12) & 0x3F)));
+ result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
+ result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
+ }
+ else
+ {
+ 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(token_type t)
+ {
+ switch (t)
+ {
+ case token_type::uninitialized:
+ return "<uninitialized>";
+ case token_type::literal_true:
+ return "true literal";
+ case token_type::literal_false:
+ return "false literal";
+ case token_type::literal_null:
+ return "null literal";
+ case token_type::value_string:
+ return "string literal";
+ case token_type::value_number:
+ return "number literal";
+ case token_type::begin_array:
+ return "'['";
+ case token_type::begin_object:
+ return "'{'";
+ case token_type::end_array:
+ return "']'";
+ case token_type::end_object:
+ return "'}'";
+ case token_type::name_separator:
+ return "':'";
+ case token_type::value_separator:
+ return "','";
+ case token_type::parse_error:
+ return "<parse error>";
+ case token_type::end_of_input:
+ return "end of input";
+ default:
+ {
+ // catch non-enum values
+ return "unknown token"; // LCOV_EXCL_LINE
+ }
+ }
+ }
+
+ /*!
+ This function implements a scanner for JSON. It is specified using
+ regular expressions that try to follow RFC 7159 as close as possible.
+ These regular expressions are then translated into a minimized
+ deterministic finite automaton (DFA) by the tool
+ [re2c](http://re2c.org). As a result, the translated code for this
+ function consists of a large block of code with `goto` jumps.
+
+ @return the class of the next token read from the buffer
+ */
+ token_type scan() noexcept
+ {
+ // 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,
+ 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128,
+ 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,
+ 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, 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, 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, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128,
+ };
+ if ((m_limit - m_cursor) < 5)
+ {
+ yyfill(); // 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 == '[')
+ {
+ goto basic_json_parser_19;
+ }
+ goto basic_json_parser_4;
+ }
+ }
+ }
+ else
+ {
+ if (yych <= 't')
+ {
+ if (yych <= 'f')
+ {
+ if (yych <= ']')
+ {
+ goto basic_json_parser_21;
+ }
+ if (yych <= 'e')
+ {
+ goto basic_json_parser_4;
+ }
+ goto basic_json_parser_23;
+ }
+ else
+ {
+ if (yych == 'n')
+ {
+ goto basic_json_parser_24;
+ }
+ if (yych <= 's')
+ {
+ goto basic_json_parser_4;
+ }
+ goto basic_json_parser_25;
+ }
+ }
+ else
+ {
+ if (yych <= '|')
+ {
+ if (yych == '{')
+ {
+ goto basic_json_parser_26;
+ }
+ goto basic_json_parser_4;
+ }
+ else
+ {
+ if (yych <= '}')
+ {
+ goto basic_json_parser_28;
+ }
+ if (yych == 0xEF)
+ {
+ goto basic_json_parser_30;
+ }
+ goto basic_json_parser_4;
+ }
+ }
+ }
+basic_json_parser_2:
+ ++m_cursor;
+ {
+ return token_type::end_of_input;
+ }
+basic_json_parser_4:
+ ++m_cursor;
+basic_json_parser_5:
+ {
+ return token_type::parse_error;
+ }
+basic_json_parser_6:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yybm[0 + yych] & 32)
+ {
+ goto basic_json_parser_6;
+ }
+ {
+ return scan();
+ }
+basic_json_parser_9:
+ yyaccept = 0;
+ yych = *(m_marker = ++m_cursor);
+ if (yych <= 0x0F)
+ {
+ goto basic_json_parser_5;
+ }
+ goto basic_json_parser_32;
+basic_json_parser_10:
+ ++m_cursor;
+ {
+ return token_type::value_separator;
+ }
+basic_json_parser_12:
+ yych = *++m_cursor;
+ if (yych <= '/')
+ {
+ goto basic_json_parser_5;
+ }
+ if (yych <= '0')
+ {
+ goto basic_json_parser_13;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_15;
+ }
+ goto basic_json_parser_5;
+basic_json_parser_13:
+ yyaccept = 1;
+ yych = *(m_marker = ++m_cursor);
+ if (yych <= 'D')
+ {
+ if (yych == '.')
+ {
+ goto basic_json_parser_37;
+ }
+ }
+ else
+ {
+ if (yych <= 'E')
+ {
+ goto basic_json_parser_38;
+ }
+ if (yych == 'e')
+ {
+ goto basic_json_parser_38;
+ }
+ }
+basic_json_parser_14:
+ {
+ return token_type::value_number;
+ }
+basic_json_parser_15:
+ yyaccept = 1;
+ m_marker = ++m_cursor;
+ if ((m_limit - m_cursor) < 3)
+ {
+ yyfill(); // 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_37;
+ }
+ goto basic_json_parser_14;
+ }
+ else
+ {
+ if (yych <= 'E')
+ {
+ goto basic_json_parser_38;
+ }
+ if (yych == 'e')
+ {
+ goto basic_json_parser_38;
+ }
+ goto basic_json_parser_14;
+ }
+basic_json_parser_17:
+ ++m_cursor;
+ {
+ return token_type::name_separator;
+ }
+basic_json_parser_19:
+ ++m_cursor;
+ {
+ return token_type::begin_array;
+ }
+basic_json_parser_21:
+ ++m_cursor;
+ {
+ return token_type::end_array;
+ }
+basic_json_parser_23:
+ yyaccept = 0;
+ yych = *(m_marker = ++m_cursor);
+ if (yych == 'a')
+ {
+ goto basic_json_parser_39;
+ }
+ goto basic_json_parser_5;
+basic_json_parser_24:
+ yyaccept = 0;
+ yych = *(m_marker = ++m_cursor);
+ if (yych == 'u')
+ {
+ goto basic_json_parser_40;
+ }
+ goto basic_json_parser_5;
+basic_json_parser_25:
+ yyaccept = 0;
+ yych = *(m_marker = ++m_cursor);
+ if (yych == 'r')
+ {
+ goto basic_json_parser_41;
+ }
+ goto basic_json_parser_5;
+basic_json_parser_26:
+ ++m_cursor;
+ {
+ return token_type::begin_object;
+ }
+basic_json_parser_28:
+ ++m_cursor;
+ {
+ return token_type::end_object;
+ }
+basic_json_parser_30:
+ yyaccept = 0;
+ yych = *(m_marker = ++m_cursor);
+ if (yych == 0xBB)
+ {
+ goto basic_json_parser_42;
+ }
+ goto basic_json_parser_5;
+basic_json_parser_31:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+basic_json_parser_32:
+ if (yybm[0 + yych] & 128)
+ {
+ goto basic_json_parser_31;
+ }
+ if (yych <= 0x0F)
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= '"')
+ {
+ goto basic_json_parser_34;
+ }
+ goto basic_json_parser_36;
+basic_json_parser_33:
+ m_cursor = m_marker;
+ if (yyaccept == 0)
+ {
+ goto basic_json_parser_5;
+ }
+ else
+ {
+ goto basic_json_parser_14;
+ }
+basic_json_parser_34:
+ ++m_cursor;
+ {
+ return token_type::value_string;
+ }
+basic_json_parser_36:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= 'e')
+ {
+ if (yych <= '/')
+ {
+ if (yych == '"')
+ {
+ goto basic_json_parser_31;
+ }
+ if (yych <= '.')
+ {
+ goto basic_json_parser_33;
+ }
+ goto basic_json_parser_31;
+ }
+ else
+ {
+ if (yych <= '\\')
+ {
+ if (yych <= '[')
+ {
+ goto basic_json_parser_33;
+ }
+ goto basic_json_parser_31;
+ }
+ else
+ {
+ if (yych == 'b')
+ {
+ goto basic_json_parser_31;
+ }
+ goto basic_json_parser_33;
+ }
+ }
+ }
+ else
+ {
+ if (yych <= 'q')
+ {
+ if (yych <= 'f')
+ {
+ goto basic_json_parser_31;
+ }
+ if (yych == 'n')
+ {
+ goto basic_json_parser_31;
+ }
+ goto basic_json_parser_33;
+ }
+ else
+ {
+ if (yych <= 's')
+ {
+ if (yych <= 'r')
+ {
+ goto basic_json_parser_31;
+ }
+ goto basic_json_parser_33;
+ }
+ else
+ {
+ if (yych <= 't')
+ {
+ goto basic_json_parser_31;
+ }
+ if (yych <= 'u')
+ {
+ goto basic_json_parser_43;
+ }
+ goto basic_json_parser_33;
+ }
+ }
+ }
+basic_json_parser_37:
+ yych = *++m_cursor;
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_44;
+ }
+ goto basic_json_parser_33;
+basic_json_parser_38:
+ yych = *++m_cursor;
+ if (yych <= ',')
+ {
+ if (yych == '+')
+ {
+ goto basic_json_parser_46;
+ }
+ goto basic_json_parser_33;
+ }
+ else
+ {
+ if (yych <= '-')
+ {
+ goto basic_json_parser_46;
+ }
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_47;
+ }
+ goto basic_json_parser_33;
+ }
+basic_json_parser_39:
+ yych = *++m_cursor;
+ if (yych == 'l')
+ {
+ goto basic_json_parser_49;
+ }
+ goto basic_json_parser_33;
+basic_json_parser_40:
+ yych = *++m_cursor;
+ if (yych == 'l')
+ {
+ goto basic_json_parser_50;
+ }
+ goto basic_json_parser_33;
+basic_json_parser_41:
+ yych = *++m_cursor;
+ if (yych == 'u')
+ {
+ goto basic_json_parser_51;
+ }
+ goto basic_json_parser_33;
+basic_json_parser_42:
+ yych = *++m_cursor;
+ if (yych == 0xBF)
+ {
+ goto basic_json_parser_52;
+ }
+ goto basic_json_parser_33;
+basic_json_parser_43:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= '@')
+ {
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_54;
+ }
+ goto basic_json_parser_33;
+ }
+ else
+ {
+ if (yych <= 'F')
+ {
+ goto basic_json_parser_54;
+ }
+ if (yych <= '`')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= 'f')
+ {
+ goto basic_json_parser_54;
+ }
+ goto basic_json_parser_33;
+ }
+basic_json_parser_44:
+ yyaccept = 1;
+ m_marker = ++m_cursor;
+ if ((m_limit - m_cursor) < 3)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= 'D')
+ {
+ if (yych <= '/')
+ {
+ goto basic_json_parser_14;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_44;
+ }
+ goto basic_json_parser_14;
+ }
+ else
+ {
+ if (yych <= 'E')
+ {
+ goto basic_json_parser_38;
+ }
+ if (yych == 'e')
+ {
+ goto basic_json_parser_38;
+ }
+ goto basic_json_parser_14;
+ }
+basic_json_parser_46:
+ yych = *++m_cursor;
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych >= ':')
+ {
+ goto basic_json_parser_33;
+ }
+basic_json_parser_47:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= '/')
+ {
+ goto basic_json_parser_14;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_47;
+ }
+ goto basic_json_parser_14;
+basic_json_parser_49:
+ yych = *++m_cursor;
+ if (yych == 's')
+ {
+ goto basic_json_parser_55;
+ }
+ goto basic_json_parser_33;
+basic_json_parser_50:
+ yych = *++m_cursor;
+ if (yych == 'l')
+ {
+ goto basic_json_parser_56;
+ }
+ goto basic_json_parser_33;
+basic_json_parser_51:
+ yych = *++m_cursor;
+ if (yych == 'e')
+ {
+ goto basic_json_parser_58;
+ }
+ goto basic_json_parser_33;
+basic_json_parser_52:
+ ++m_cursor;
+ {
+ return scan();
+ }
+basic_json_parser_54:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= '@')
+ {
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_60;
+ }
+ goto basic_json_parser_33;
+ }
+ else
+ {
+ if (yych <= 'F')
+ {
+ goto basic_json_parser_60;
+ }
+ if (yych <= '`')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= 'f')
+ {
+ goto basic_json_parser_60;
+ }
+ goto basic_json_parser_33;
+ }
+basic_json_parser_55:
+ yych = *++m_cursor;
+ if (yych == 'e')
+ {
+ goto basic_json_parser_61;
+ }
+ goto basic_json_parser_33;
+basic_json_parser_56:
+ ++m_cursor;
+ {
+ return token_type::literal_null;
+ }
+basic_json_parser_58:
+ ++m_cursor;
+ {
+ return token_type::literal_true;
+ }
+basic_json_parser_60:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= '@')
+ {
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_63;
+ }
+ goto basic_json_parser_33;
+ }
+ else
+ {
+ if (yych <= 'F')
+ {
+ goto basic_json_parser_63;
+ }
+ if (yych <= '`')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= 'f')
+ {
+ goto basic_json_parser_63;
+ }
+ goto basic_json_parser_33;
+ }
+basic_json_parser_61:
+ ++m_cursor;
+ {
+ return token_type::literal_false;
+ }
+basic_json_parser_63:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= '@')
+ {
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_31;
+ }
+ goto basic_json_parser_33;
+ }
+ else
+ {
+ if (yych <= 'F')
+ {
+ goto basic_json_parser_31;
+ }
+ if (yych <= '`')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= 'f')
+ {
+ goto basic_json_parser_31;
+ }
+ goto basic_json_parser_33;
+ }
+ }
+
+ }
+
+ /// append data from the stream to the internal buffer
+ void yyfill() noexcept
+ {
+ if (m_stream == nullptr or not * m_stream)
+ {
+ return;
+ }
+
+ const auto offset_start = m_start - m_content;
+ const auto offset_marker = m_marker - m_start;
+ const auto offset_cursor = m_cursor - m_start;
+
+ m_buffer.erase(0, static_cast<size_t>(offset_start));
+ std::string line;
+ assert(m_stream != nullptr);
+ std::getline(*m_stream, line);
+ m_buffer += "\n" + line; // add line with newline symbol
+
+ m_content = reinterpret_cast<const lexer_char_t*>(m_buffer.c_str());
+ 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_buffer.size() - 1;
+ }
+
+ /// return string representation of last read token
+ string_t get_token() const
+ {
+ assert(m_start != nullptr);
+ return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),
+ static_cast<size_t>(m_cursor - m_start));
+ }
+
+ /*!
+ @brief return string value for string tokens
+
+ The function iterates the characters between the opening and closing
+ quotes of the string value. The complete string is the range
+ [m_start,m_cursor). Consequently, we iterate from m_start+1 to
+ m_cursor-1.
+
+ We differentiate two cases:
+
+ 1. Escaped characters. In this case, a new character is constructed
+ according to the nature of the escape. Some escapes create new
+ characters (e.g., `"\\n"` is replaced by `"\n"`), some are copied
+ as is (e.g., `"\\\\"`). Furthermore, Unicode escapes of the shape
+ `"\\uxxxx"` need special care. In this case, to_unicode takes care
+ of the construction of the values.
+ 2. Unescaped characters are copied as is.
+
+ @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
+ {
+ string_t result;
+ result.reserve(static_cast<size_t>(m_cursor - m_start - 2));
+
+ // iterate the result between the quotes
+ for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
+ {
+ // process escaped characters
+ if (*i == '\\')
+ {
+ // read next character
+ ++i;
+
+ switch (*i)
+ {
+ // the default escapes
+ case 't':
+ {
+ result += "\t";
+ break;
+ }
+ case 'b':
+ {
+ result += "\b";
+ break;
+ }
+ case 'f':
+ {
+ result += "\f";
+ break;
+ }
+ case 'n':
+ {
+ result += "\n";
+ break;
+ }
+ case 'r':
+ {
+ result += "\r";
+ break;
+ }
+ case '\\':
+ {
+ result += "\\";
+ break;
+ }
+ case '/':
+ {
+ result += "/";
+ break;
+ }
+ case '"':
+ {
+ result += "\"";
+ break;
+ }
+
+ // unicode
+ case 'u':
+ {
+ // get code xxxx from uxxxx
+ auto codepoint = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>(i + 1),
+ 4).c_str(), nullptr, 16);
+
+ // check if codepoint is a high surrogate
+ if (codepoint >= 0xD800 and codepoint <= 0xDBFF)
+ {
+ // make sure there is a subsequent unicode
+ if ((i + 6 >= m_limit) or * (i + 5) != '\\' or * (i + 6) != 'u')
+ {
+ throw std::invalid_argument("missing low surrogate");
+ }
+
+ // get code yyyy from uxxxx\uyyyy
+ auto codepoint2 = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>
+ (i + 7), 4).c_str(), nullptr, 16);
+ result += to_unicode(codepoint, codepoint2);
+ // skip the next 10 characters (xxxx\uyyyy)
+ i += 10;
+ }
+ else
+ {
+ // add unicode character(s)
+ result += to_unicode(codepoint);
+ // skip the next four characters (xxxx)
+ i += 4;
+ }
+ break;
+ }
+ }
+ }
+ else
+ {
+ // all other characters are just copied to the end of the
+ // string
+ result.append(1, static_cast<typename string_t::value_type>(*i));
+ }
+ }
+
+ return result;
+ }
+
+ /*!
+ @brief parse floating point number
+
+ This function (and its overloads) serves to select the most approprate
+ standard floating point number parsing function based on the type
+ supplied via the first parameter. Set this to @a
+ static_cast<number_float_t*>(nullptr).
+
+ @param[in] type the @ref number_float_t in use
+
+ @param[in,out] endptr recieves a pointer to the first character after
+ the number
+
+ @return the floating point number
+
+ @bug This function uses `std::strtof`, `std::strtod`, or `std::strtold`
+ which use the current C locale to determine which character is used as
+ decimal point character. This may yield to parse errors if the locale
+ does not used `.`.
+ */
+ long double str_to_float_t(long double* /* type */, char** endptr) const
+ {
+ return std::strtold(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
+ }
+
+ /*!
+ @brief parse floating point number
+
+ This function (and its overloads) serves to select the most approprate
+ standard floating point number parsing function based on the type
+ supplied via the first parameter. Set this to @a
+ static_cast<number_float_t*>(nullptr).
+
+ @param[in] type the @ref number_float_t in use
+
+ @param[in,out] endptr recieves a pointer to the first character after
+ the number
+
+ @return the floating point number
+ */
+ double str_to_float_t(double* /* type */, char** endptr) const
+ {
+ return std::strtod(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
+ }
+
+ /*!
+ @brief parse floating point number
+
+ This function (and its overloads) serves to select the most approprate
+ standard floating point number parsing function based on the type
+ supplied via the first parameter. Set this to @a
+ static_cast<number_float_t*>(nullptr).
+
+ @param[in] type the @ref number_float_t in use
+
+ @param[in,out] endptr recieves a pointer to the first character after
+ the number
+
+ @return the floating point number
+ */
+ float str_to_float_t(float* /* type */, char** endptr) const
+ {
+ return std::strtof(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
+ }
+
+ /*!
+ @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.
+
+ This function parses the integer component up to the radix point or
+ exponent while collecting information about the 'floating point
+ representation', which it stores in the result parameter. If there is
+ no radix point or exponent, and the number can fit into a @ref
+ number_integer_t or @ref number_unsigned_t then it sets the result
+ parameter accordingly.
+
+ The 'floating point representation' includes the number of significant
+ figures after the radix point, whether the number is in exponential or
+ decimal form, the capitalization of the exponent marker, and if the
+ optional '+' is present in the exponent. This information is necessary
+ to perform accurate round trips of floating point numbers.
+
+ If the number is a floating point number the number is then parsed
+ using @a std:strtod (or @a std:strtof or @a std::strtold).
+
+ @param[out] result @ref basic_json object to receive the number, or
+ NAN if the conversion read past the current token. The latter case
+ needs to be treated by the caller function.
+ */
+ void get_number(basic_json& result) const
+ {
+ assert(m_start != nullptr);
+
+ const lexer::lexer_char_t* curptr = m_start;
+
+ // remember this number was parsed (for later serialization)
+ result.m_type.bits.parsed = true;
+
+ // 'found_radix_point' will be set to 0xFF upon finding a radix
+ // point and later used to mask in/out the precision depending
+ // whether a radix is found i.e. 'precision &= found_radix_point'
+ uint8_t found_radix_point = 0;
+ uint8_t precision = 0;
+
+ // accumulate the integer conversion result (unsigned for now)
+ number_unsigned_t value = 0;
+
+ // maximum absolute value of the relevant integer type
+ number_unsigned_t max;
+
+ // temporarily store the type to avoid unecessary bitfield access
+ value_t type;
+
+ // look for sign
+ if (*curptr == '-')
+ {
+ type = value_t::number_integer;
+ max = static_cast<uint64_t>(std::numeric_limits<number_integer_t>::max()) + 1;
+ curptr++;
+ }
+ else
+ {
+ type = value_t::number_unsigned;
+ max = static_cast<uint64_t>(std::numeric_limits<number_unsigned_t>::max());
+ }
+
+ // count the significant figures
+ for (; curptr < m_cursor; curptr++)
+ {
+ // quickly skip tests if a digit
+ if (*curptr < '0' || *curptr > '9')
+ {
+ if (*curptr == '.')
+ {
+ // don't count '.' but change to float
+ type = value_t::number_float;
+
+ // reset precision count
+ precision = 0;
+ found_radix_point = 0xFF;
+ continue;
+ }
+ // assume exponent (if not then will fail parse): change to
+ // float, stop counting and record exponent details
+ type = value_t::number_float;
+ result.m_type.bits.has_exp = true;
+
+ // exponent capitalization
+ result.m_type.bits.exp_cap = (*curptr == 'E');
+
+ // exponent '+' sign
+ result.m_type.bits.exp_plus = (*(++curptr) == '+');
+ break;
+ }
+
+ // skip if definitely not an integer
+ if (type != value_t::number_float)
+ {
+ // multiply last value by ten and add the new digit
+ auto temp = value * 10 + *curptr - 0x30;
+
+ // test for overflow
+ if (temp < value || temp > max)
+ {
+ // overflow
+ type = value_t::number_float;
+ }
+ else
+ {
+ // no overflow - save it
+ value = temp;
+ }
+ }
+ ++precision;
+ }
+
+ // If no radix point was found then precision would now be set to
+ // the number of digits, which is wrong - clear it.
+ result.m_type.bits.precision = precision & found_radix_point;
+
+ // save the value (if not a float)
+ if (type == value_t::number_unsigned)
+ {
+ result.m_value.number_unsigned = value;
+ }
+ else if (type == value_t::number_integer)
+ {
+ result.m_value.number_integer = -static_cast<number_integer_t>(value);
+ }
+ else
+ {
+ // parse with strtod
+ result.m_value.number_float = str_to_float_t(static_cast<number_float_t*>(nullptr), NULL);
+ }
+
+ // save the type
+ result.m_type = type;
+ }
+
+ private:
+ /// optional input stream
+ std::istream* m_stream = nullptr;
+ /// the buffer
+ string_t m_buffer;
+ /// 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;
+ };
+
+ /*!
+ @brief syntax analysis
+
+ This class implements a recursive decent parser.
+ */
+ class parser
+ {
+ public:
+ /// constructor for strings
+ parser(const string_t& s, parser_callback_t cb = nullptr) noexcept
+ : callback(cb), m_lexer(s)
+ {
+ // read first token
+ get_token();
+ }
+
+ /// a parser reading from an input stream
+ parser(std::istream& _is, parser_callback_t cb = nullptr) noexcept
+ : callback(cb), m_lexer(&_is)
+ {
+ // read first token
+ get_token();
+ }
+
+ /// public parser interface
+ basic_json parse()
+ {
+ basic_json result = parse_internal(true);
+
+ 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() : 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))))
+ {
+ // explicitly set result to object to cope with {}
+ result.m_type = value_t::object;
+ result.m_value = json_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))))
+ {
+ // explicitly set result to object to cope with []
+ result.m_type = value_t::array;
+ result.m_value = json_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_number:
+ {
+ m_lexer.get_number(result);
+ 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() noexcept
+ {
+ 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() + "'") :
+ lexer::token_type_name(last_token));
+ error_msg += "; expected " + lexer::token_type_name(t);
+ 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() + "'") :
+ lexer::token_type_name(last_token));
+ throw std::invalid_argument(error_msg);
+ }
+ }
+
+ private:
+ /// current level of recursion
+ int depth = 0;
+ /// callback function
+ parser_callback_t callback;
+ /// 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
+ {
+ std::string result;
+
+ for (const auto& reference_token : reference_tokens)
+ {
+ result += "/" + escape(reference_token);
+ }
+
+ return result;
+ }
+
+ /// @copydoc to_string()
+ operator std::string() const
+ {
+ return to_string();
+ }
+
+ private:
+ /// remove and return last reference pointer
+ std::string pop_back()
+ {
+ if (is_root())
+ {
+ 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())
+ {
+ 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
+ */
+ reference get_and_create(reference j) const
+ {
+ pointer result = &j;
+
+ // in case no reference tokens exist, return a reference to the
+ // JSON value j which will be overwritten by a primitive value
+ for (const auto& reference_token : reference_tokens)
+ {
+ switch (result->m_type)
+ {
+ case value_t::null:
+ {
+ if (reference_token == "0")
+ {
+ // start a new array if reference token is 0
+ result = &result->operator[](0);
+ }
+ else
+ {
+ // start a new object otherwise
+ result = &result->operator[](reference_token);
+ }
+ break;
+ }
+
+ case value_t::object:
+ {
+ // create an entry in the object
+ result = &result->operator[](reference_token);
+ break;
+ }
+
+ case value_t::array:
+ {
+ // create an entry in the array
+ result = &result->operator[](static_cast<size_type>(std::stoi(reference_token)));
+ break;
+ }
+
+ /*
+ The following code is only reached if there exists a
+ reference token _and_ the current value is primitive. In
+ this case, we have an error situation, because primitive
+ values may only occur as single value; that is, with an
+ empty list of reference tokens.
+ */
+ default:
+ {
+ throw std::domain_error("invalid value to unflatten");
+ }
+ }
+ }
+
+ return *result;
+ }
+
+ /*!
+ @brief return a reference to the pointed to value
+
+ @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)
+ {
+ 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')
+ {
+ throw std::domain_error("array index must not begin with '0'");
+ }
+
+ if (reference_token == "-")
+ {
+ // explicityly treat "-" as index beyond the end
+ ptr = &ptr->operator[](ptr->m_value.array->size());
+ }
+ else
+ {
+ // convert array index to number; unchecked access
+ ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
+ }
+ break;
+ }
+
+ default:
+ {
+ 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
+ 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')
+ {
+ throw std::domain_error("array index must not begin with '0'");
+ }
+
+ // note: at performs range check
+ ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
+ break;
+ }
+
+ default:
+ {
+ 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
+ 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')
+ {
+ throw std::domain_error("array index must not begin with '0'");
+ }
+
+ // use unchecked array access
+ ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
+ break;
+ }
+
+ default:
+ {
+ 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
+ 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')
+ {
+ throw std::domain_error("array index must not begin with '0'");
+ }
+
+ // note: at performs range check
+ ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
+ break;
+ }
+
+ default:
+ {
+ throw std::out_of_range("unresolved reference token '" + reference_token + "'");
+ }
+ }
+ }
+
+ return *ptr;
+ }
+
+ /// split the string input to reference tokens
+ static std::vector<std::string> split(std::string reference_string)
+ {
+ std::vector<std::string> result;
+
+ // special case: empty reference string -> no reference tokens
+ if (reference_string.empty())
+ {
+ return result;
+ }
+
+ // check if nonempty reference string begins with slash
+ if (reference_string[0] != '/')
+ {
+ 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'))
+ {
+ 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
+ @param[in] f the substring to replace with @a t
+ @param[out] t the string to replace @a f
+
+ @return The string @a s where all occurrences of @a f are replaced
+ with @a t.
+
+ @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())
+ {
+ 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())
+ {
+ 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:
+ /// the reference tokens
+ std::vector<std::string> reference_tokens {};
+ };
+
+ //////////////////////////
+ // JSON Pointer support //
+ //////////////////////////
+
+ /// @name JSON Pointer functions
+ /// @{
+
+ /*!
+ @brief access specified element via JSON Pointer
+
+ Uses a JSON pointer to retrieve a reference to the respective JSON value.
+ No bound checking is performed. Similar to @ref operator[](const typename
+ object_t::key_type&), `null` values are created in arrays and objects if
+ necessary.
+
+ In particular:
+ - If the JSON pointer points to an object key that does not exist, it
+ is created an filled with a `null` value before a reference to it
+ is returned.
+ - If the JSON pointer points to an array index that does not exist, it
+ is created an filled with a `null` value before a reference to it
+ is returned. All indices between the current maximum and the given
+ index are also filled with `null`.
+ - The special value `-` is treated as a synonym for the index past the
+ end.
+
+ @param[in] ptr a JSON pointer
+
+ @return reference to the element pointed to by @a ptr
+
+ @complexity Constant.
+
+ @throw std::out_of_range if the JSON pointer can not be resolved
+ @throw std::domain_error if an array index begins with '0'
+ @throw std::invalid_argument if an array index was not a number
+
+ @liveexample{The behavior is shown in the example.,operatorjson_pointer}
+
+ @since version 2.0.0
+ */
+ reference operator[](const json_pointer& ptr)
+ {
+ return ptr.get_unchecked(this);
+ }
+
+ /*!
+ @brief access specified element via JSON Pointer
+
+ Uses a JSON pointer to retrieve a reference to the respective JSON value.
+ No bound checking is performed. The function does not change the JSON
+ value; no `null` values are created. In particular, the the special value
+ `-` yields an exception.
+
+ @param[in] ptr JSON pointer to the desired element
+
+ @return const reference to the element pointed to by @a ptr
+
+ @complexity Constant.
+
+ @throw std::out_of_range if the JSON pointer can not be resolved
+ @throw std::domain_error if an array index begins with '0'
+ @throw std::invalid_argument if an array index was not a number
+
+ @liveexample{The behavior is shown in the example.,operatorjson_pointer_const}
+
+ @since version 2.0.0
+ */
+ const_reference operator[](const json_pointer& ptr) const
+ {
+ return ptr.get_unchecked(this);
+ }
+
+ /*!
+ @brief access specified element via JSON Pointer
+
+ Returns a reference to the element at with specified JSON pointer @a ptr,
+ with bounds checking.
+
+ @param[in] ptr JSON pointer to the desired element
+
+ @return reference to the element pointed to by @a ptr
+
+ @complexity Constant.
+
+ @throw std::out_of_range if the JSON pointer can not be resolved
+ @throw std::domain_error if an array index begins with '0'
+ @throw std::invalid_argument if an array index was not a number
+
+ @liveexample{The behavior is shown in the example.,at_json_pointer}
+
+ @since version 2.0.0
+ */
+ reference at(const json_pointer& ptr)
+ {
+ return ptr.get_checked(this);
+ }
+
+ /*!
+ @brief access specified element via JSON Pointer
+
+ Returns a const reference to the element at with specified JSON pointer @a
+ ptr, with bounds checking.
+
+ @param[in] ptr JSON pointer to the desired element
+
+ @return reference to the element pointed to by @a ptr
+
+ @complexity Constant.
+
+ @throw std::out_of_range if the JSON pointer can not be resolved
+ @throw std::domain_error if an array index begins with '0'
+ @throw std::invalid_argument if an array index was not a number
+
+ @liveexample{The behavior is shown in the example.,at_json_pointer_const}
+
+ @since version 2.0.0
+ */
+ const_reference at(const json_pointer& ptr) const
+ {
+ return ptr.get_checked(this);
+ }
+
+ /*!
+ @brief return flattened JSON value
+
+ The function creates a JSON object whose keys are JSON pointers (see [RFC
+ 6901](https://tools.ietf.org/html/rfc6901)) and whose values are all
+ primitive. The original JSON value can be restored using the @ref
+ unflatten() function.
+
+ @return an object that maps JSON pointers to primitve 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 funcion, 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)
+ {
+ basic_json& x = result.at(top_pointer);
+ }
+
+ // get reference to parent of JSON pointer ptr
+ const auto last_path = ptr.pop_back();
+ basic_json& parent = result[ptr];
+
+ switch (parent.m_type)
+ {
+ case value_t::null:
+ case value_t::object:
+ {
+ // use operator[] to add value
+ parent[last_path] = val;
+ break;
+ }
+
+ case value_t::array:
+ {
+ if (last_path == "-")
+ {
+ // special case: append to back
+ parent.push_back(val);
+ }
+ else
+ {
+ const auto idx = std::stoi(last_path);
+ if (static_cast<size_type>(idx) > parent.size())
+ {
+ // avoid undefined behavior
+ throw std::out_of_range("array index " + std::to_string(idx) + " is out of range");
+ }
+ else
+ {
+ // default case: insert add offset
+ parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
+ }
+ }
+ break;
+ }
+
+ default:
+ {
+ // if there exists a parent it cannot be primitive
+ assert(false); // LCOV_EXCL_LINE
+ }
+ }
+ }
+ };
+
+ // wrapper for "remove" operation; remove value at ptr
+ const auto operation_remove = [&result](json_pointer & ptr)
+ {
+ // get reference to parent of JSON pointer ptr
+ const auto last_path = ptr.pop_back();
+ basic_json& parent = result.at(ptr);
+
+ // remove child
+ if (parent.is_object())
+ {
+ // perform range check
+ auto it = parent.find(last_path);
+ if (it != parent.end())
+ {
+ parent.erase(it);
+ }
+ else
+ {
+ throw std::out_of_range("key '" + last_path + "' not found");
+ }
+ }
+ else if (parent.is_array())
+ {
+ // note erase performs range check
+ parent.erase(static_cast<size_type>(std::stoi(last_path)));
+ }
+ };
+
+ // type check
+ if (not json_patch.is_array())
+ {
+ // a JSON patch must be an array of objects
+ throw std::invalid_argument("JSON patch must be an array of objects");
+ }
+
+ // iterate and apply th eoperations
+ 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())
+ {
+ 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())
+ {
+ 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())
+ {
+ 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;
+ 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));
+ }
+ catch (std::out_of_range&)
+ {
+ // ignore out of range errors: success remains false
+ }
+
+ // throw an exception if test fails
+ if (not success)
+ {
+ throw std::domain_error("unsuccessful: " + val.dump());
+ }
+
+ break;
+ }
+
+ case patch_operations::invalid:
+ {
+ // op must be "add", "remove", "replace", "move", "copy", or
+ // "test"
+ 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 copare from
+ @param[in] target JSON value to copare 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,
+ 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
+ while (i < source.size())
+ {
+ result.push_back(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 //
+/////////////
+
+/*!
+ at brief default JSON class
+
+This type is the default specialization of the @ref basic_json class which
+uses the standard template types.
+
+ at since version 1.0.0
+*/
+using json = basic_json<>;
+}
+
+
+///////////////////////
+// nonmember support //
+///////////////////////
+
+// specialization of std::swap, and std::hash
+namespace std
+{
+/*!
+ at brief exchanges the values of two JSON objects
+
+ at since version 1.0.0
+*/
+template <>
+inline void swap(nlohmann::json& j1,
+ nlohmann::json& j2) noexcept(
+ is_nothrow_move_constructible<nlohmann::json>::value and
+ is_nothrow_move_assignable<nlohmann::json>::value
+ )
+{
+ j1.swap(j2);
+}
+
+/// hash value for JSON objects
+template <>
+struct hash<nlohmann::json>
+{
+ /*!
+ @brief return a hash value for a JSON object
+
+ @since version 1.0.0
+ */
+ std::size_t operator()(const nlohmann::json& j) const
+ {
+ // a naive hashing via the string representation
+ const auto& h = hash<nlohmann::json::string_t>();
+ return h(j.dump());
+ }
+};
+}
+
+/*!
+ at 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 \p "_json" to a string literal and returns a JSON object
+if no parse error occurred.
+
+ at param[in] s a string representation of a JSON object
+ at return a JSON object
+
+ at since version 1.0.0
+*/
+inline nlohmann::json operator "" _json(const char* s, std::size_t)
+{
+ return nlohmann::json::parse(reinterpret_cast<const nlohmann::json::string_t::value_type*>(s));
+}
+
+/*!
+ at brief user-defined string literal for JSON pointer
+
+ at since version 2.0.0
+*/
+inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t)
+{
+ return nlohmann::json::json_pointer(s);
+}
+
+// restore GCC/clang diagnostic settings
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+ #pragma GCC diagnostic pop
+#endif
+
+#endif
diff --git a/include/pbcopper/logging/Logging.h b/include/pbcopper/logging/Logging.h
new file mode 100644
index 0000000..e1d712a
--- /dev/null
+++ b/include/pbcopper/logging/Logging.h
@@ -0,0 +1,156 @@
+#ifndef PBCOPPER_LOGGING_LOGGING_H
+#define PBCOPPER_LOGGING_LOGGING_H
+
+#include "pbcopper/Config.h"
+
+#include <condition_variable>
+#include <functional>
+#include <iosfwd>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+namespace PacBio {
+namespace Logging {
+
+class LogLevel
+{
+public:
+ enum : unsigned char
+ {
+ TRACE = 0,
+ DEBUG = 1,
+ INFO = 2,
+ NOTICE = 3,
+ WARN = 4,
+ ERROR = 5,
+ CRITICAL = 6,
+ FATAL = 7,
+
+ MAX_LOG_LEVEL = 8
+ };
+
+public:
+ LogLevel(const unsigned char value);
+ LogLevel(const std::string& value);
+
+public:
+ operator unsigned char(void) const;
+
+private:
+ unsigned char value_;
+};
+
+typedef std::reference_wrapper<std::ostream> OStreamWrapper;
+typedef std::vector<OStreamWrapper> OStreams;
+
+class LoggerConfig : public std::map<LogLevel, OStreams>
+{
+public:
+ LoggerConfig(const std::map<LogLevel, OStreams>& cfg);
+ LoggerConfig(const std::map<std::string, OStreams>& cfg);
+ LoggerConfig(std::ostream& os, const LogLevel level = LogLevel::INFO);
+ LoggerConfig(std::ostream& os, const std::string& level);
+};
+
+class LogMessage;
+
+class Logger
+{
+private:
+ typedef std::pair<LogLevel, std::ostringstream> LogLevelStream;
+
+public:
+ static Logger& Default(Logger* logger = nullptr);
+
+public:
+ template<typename... Args>
+ Logger(Args&&... args);
+
+ Logger(const Logger& other) = delete;
+ ~Logger(void);
+
+private:
+ LoggerConfig cfg_;
+ std::mutex m_;
+ std::condition_variable popped_;
+ std::condition_variable pushed_;
+ std::queue<std::unique_ptr<LogLevelStream>> queue_;
+ std::thread writer_;
+ friend class LogMessage;
+
+private:
+ Logger& operator<<(std::unique_ptr<LogLevelStream>&& ptr);
+ bool Handles(const LogLevel level) const;
+ void MessageWriter(void);
+};
+
+class LogMessage
+{
+public:
+ LogMessage(const char* file,
+ const char* function,
+ unsigned int line,
+ const LogLevel level,
+ Logger& logger);
+ LogMessage(const LogMessage& msg) = delete;
+ ~LogMessage(void);
+
+public:
+ template <typename T>
+ LogMessage& operator<<(const T& t);
+
+private:
+ std::unique_ptr<Logger::LogLevelStream> ptr_;
+ Logger& logger_;
+};
+
+// trace is disabled under Release builds (-DNDEBUG)
+#ifdef NDEBUG
+#define PBLOGGER_LEVEL(lg, lvl) \
+ if (PacBio::Logging::lvl != PacBio::Logging::LogLevel::TRACE) \
+ PacBio::Logging::LogMessage(__FILE__, __func__, __LINE__, PacBio::Logging::lvl, (lg))
+#else
+#define PBLOGGER_LEVEL(lg, lvl) \
+ PacBio::Logging::LogMessage(__FILE__, __func__, __LINE__, PacBio::Logging::lvl, (lg))
+#endif
+
+//
+// Log message with desired log level & provided logger
+//
+#define PBLOGGER_TRACE(lg) PBLOGGER_LEVEL(lg, LogLevel::TRACE)
+#define PBLOGGER_DEBUG(lg) PBLOGGER_LEVEL(lg, LogLevel::DEBUG)
+#define PBLOGGER_INFO(lg) PBLOGGER_LEVEL(lg, LogLevel::INFO)
+#define PBLOGGER_NOTICE(lg) PBLOGGER_LEVEL(lg, LogLevel::NOTICE)
+#define PBLOGGER_WARN(lg) PBLOGGER_LEVEL(lg, LogLevel::WARN)
+#define PBLOGGER_ERROR(lg) PBLOGGER_LEVEL(lg, LogLevel::ERROR)
+#define PBLOGGER_CRITICAL(lg) PBLOGGER_LEVEL(lg, LogLevel::CRITICAL)
+#define PBLOGGER_FATAL(lg) PBLOGGER_LEVEL(lg, LogLevel::FATAL)
+
+//
+// Log message with desired log level & default logger
+//
+#define PBLOG_LEVEL(lvl) PBLOGGER_LEVEL(PacBio::Logging::Logger::Default(), lvl)
+
+#define PBLOG_TRACE PBLOG_LEVEL(LogLevel::TRACE)
+#define PBLOG_DEBUG PBLOG_LEVEL(LogLevel::DEBUG)
+#define PBLOG_INFO PBLOG_LEVEL(LogLevel::INFO)
+#define PBLOG_NOTICE PBLOG_LEVEL(LogLevel::NOTICE)
+#define PBLOG_WARN PBLOG_LEVEL(LogLevel::WARN)
+#define PBLOG_ERROR PBLOG_LEVEL(LogLevel::ERROR)
+#define PBLOG_CRITICAL PBLOG_LEVEL(LogLevel::CRITICAL)
+#define PBLOG_FATAL PBLOG_LEVEL(LogLevel::FATAL)
+
+extern void InstallSignalHandlers(Logger& logger = Logger::Default());
+
+} // namespace Logging
+} // namespace PacBio
+
+#include "internal/Logging-inl.h"
+
+#endif // PBCOPPER_LOGGING_LOGGING_H
diff --git a/include/pbcopper/logging/internal/Logging-inl.h b/include/pbcopper/logging/internal/Logging-inl.h
new file mode 100644
index 0000000..ab2cfaf
--- /dev/null
+++ b/include/pbcopper/logging/internal/Logging-inl.h
@@ -0,0 +1,86 @@
+#ifndef PBCOPPER_LOGGING_LOGGING_INL_H
+#define PBCOPPER_LOGGING_LOGGING_INL_H
+
+#include "pbcopper/logging/Logging.h"
+#include <stdexcept>
+#include <sstream>
+
+namespace PacBio {
+namespace Logging {
+
+// ----------
+// LogLevel
+// ----------
+
+inline LogLevel::LogLevel(const unsigned char value)
+ : value_{ value }
+{ }
+
+inline LogLevel::operator unsigned char(void) const
+{ return value_; }
+
+// --------------
+// LoggerConfig
+// --------------
+
+inline LoggerConfig::LoggerConfig(const std::map<LogLevel, OStreams>& cfg)
+ : std::map<LogLevel, OStreams>(cfg)
+{ }
+
+inline LoggerConfig::LoggerConfig(const std::map<std::string, OStreams>& cfg)
+ : std::map<LogLevel, OStreams>()
+{
+ for (const auto& kv : cfg)
+ (*this)[kv.first] = kv.second;
+}
+
+inline LoggerConfig::LoggerConfig(std::ostream& os, const LogLevel level)
+{
+ for (size_t i = static_cast<size_t>(level); i < LogLevel::MAX_LOG_LEVEL; ++i)
+ (*this)[static_cast<LogLevel>(i)].push_back(os);
+}
+
+inline LoggerConfig::LoggerConfig(std::ostream& os,
+ const std::string& level)
+ : LoggerConfig(os, LogLevel(level))
+{ }
+
+// ---------
+// Logger
+// ---------
+
+template<typename... Args>
+Logger::Logger(Args&&... args)
+ : cfg_(std::forward<Args>(args)...)
+ , writer_(&Logger::MessageWriter, this)
+{
+#ifdef NDEBUG
+ if (Handles(LogLevel::TRACE))
+ throw std::invalid_argument("one cannot simply log TRACE messages in release builds!");
+#endif
+}
+
+inline bool Logger::Handles(const LogLevel level) const
+{ return cfg_.find(level) != cfg_.end() && !cfg_.at(level).empty(); }
+
+// ------------
+// LogMessage
+// ------------
+
+inline LogMessage::~LogMessage(void)
+{
+ if (ptr_)
+ logger_ << std::move(ptr_);
+}
+
+template <typename T>
+inline LogMessage& LogMessage::operator<<(const T& t)
+{
+ if (ptr_) std::get<1>(*ptr_) << t;
+ return *this;
+}
+
+} // namespace Logging
+} // namespace PacBio
+
+#endif // PBCOPPER_LOGGING_LOGGING_INL_H
diff --git a/include/pbcopper/stream/Stream.h b/include/pbcopper/stream/Stream.h
new file mode 100644
index 0000000..716f9c2
--- /dev/null
+++ b/include/pbcopper/stream/Stream.h
@@ -0,0 +1,190 @@
+#ifndef PBCOPPER_STREAM_STREAM_H
+#define PBCOPPER_STREAM_STREAM_H
+
+#include "pbcopper/Config.h"
+#include <functional>
+
+namespace PacBio {
+namespace Stream {
+
+/// \brief Sink function type for data streams.
+///
+/// A sink function takes a data value and does some 'final' action on it, such
+/// as printing.
+///
+/// Example:
+/// \code{.cpp}
+/// auto printToConsole = [](const int x) { std::cout << x; };
+/// \endcode
+///
+template<typename T>
+using Sink = std::function<void (const T&)>;
+
+/// \brief Source function type for data streams.
+///
+/// A source function writes data to the sink provided.
+///
+/// Example:
+/// \code{.cpp}
+/// auto intList = [](Sink<std::int> out)
+/// {
+/// const std::vector<int> v = { 1,2,3,4,5 };
+/// for (auto e : v)
+/// out(e);
+/// };
+/// \endcode
+///
+template<typename T>
+using Source = std::function<void (Sink<T>)>;
+
+/// \brief Source function type for data streams.
+///
+/// A transform function takes a value, (likely) does some modification and
+/// writes to the sink provided. Input & output types are allowed to differ.
+///
+/// Example:
+/// \code{.cpp}
+/// auto splitLines = [](Sink<std::string> out, std::string s)
+/// {
+/// auto stream = std::stringstream{ s };
+/// auto token = std::string{ };
+/// while (std::getline(stream, token)
+/// out(token);
+/// };
+///
+/// auto intToString = [](Sink<std::string> out, int x)
+/// {
+/// out( std::to_string(x) );
+/// };
+/// \endcode
+///
+template<typename T, typename U>
+using Transform = std::function<void (Sink<U>, T)>;
+
+/// \brief This method connects a Source to a Sink, in that order.
+///
+/// \param source data source
+/// \param sink data sink
+///
+template<typename T>
+void sourceToSink(Source<T> source, Sink<T> sink)
+{
+ source(sink);
+}
+
+/// \brief This method connects a Transform to a Sink, in that order.
+///
+/// \param transform data transform
+/// \param sink data sink
+///
+/// \returns a Sink function, which can transform data before the final action
+///
+template<typename T, typename U>
+Sink<T> transformToSink (Transform<T,U> transform, Sink<U> sink)
+{
+ return [transform, sink](const T& value) {
+ transform(sink, value);
+ };
+}
+
+/// \brief This method connects a Source to a Transform, in that order.
+///
+/// \param source data source
+/// \param transform data transform
+///
+/// \returns a Source function, which provides transformed data
+///
+template<typename T, typename U>
+Source<U> sourceToTransform (Transform<T,U> transform, Source<T> source)
+{
+ return [transform, source](Sink<U> sink)
+ {
+ auto intermediateSink = [transform, sink](const T& value)
+ {
+ transform(sink, value);
+ };
+ source(intermediateSink);
+ };
+}
+
+/// \brief This method connects a Transform to another Transform.
+///
+/// \param t1 upstream data transform
+/// \param t2 downstream data transform
+///
+/// \returns a Transform function representing the composite operation
+///
+template<typename T, typename Intermediate, typename U>
+Transform<T,U> transformToTransform(Transform<T, Intermediate> t1,
+ Transform<Intermediate, U> t2)
+{
+ return [t1, t2](Sink<U> finalSink, T originalValue)
+ {
+ auto intermediateSink = [t2,finalSink](const Intermediate& value)
+ {
+ t2(finalSink, value);
+ };
+ t1(intermediateSink, originalValue);
+ };
+}
+
+/// \brief Overloaded stream operator for chaining (source >> sink).
+///
+/// \param source data source
+/// \param sink data sink
+///
+/// \sa sourceToSink
+///
+template<typename T, typename U>
+void operator>>(Source<T> source, Sink<U> sink)
+{
+ sourceToSink(source, sink);
+}
+
+/// \brief Overloaded stream operator for chaining (source >> transform).
+///
+/// \param source data source
+/// \param transform data transform
+///
+/// \returns a Source function, which provides transformed data
+/// \sa sourceToTransform
+///
+template<typename T, typename U>
+Source<U> operator>>(Source<T> source, Transform<T,U> transform)
+{
+ return sourceToTransform(transform, source);
+}
+
+/// \brief Overloaded stream operator for chaining (transform >> sink).
+///
+/// \param transform data transform
+/// \param sink data sink
+///
+/// \returns a Sink function, which can transform data before the final action
+/// \sa transformToSink
+///
+template<typename T, typename U>
+Sink<T> operator>>(Transform<T,U> transform, Sink<U> sink)
+{
+ return transformToSink(transform, sink);
+}
+
+/// \brief Overloaded stream operator for chaining (transform >> transform).
+///
+/// \param t1 upstream data transform
+/// \param t2 downstream data transform
+///
+/// \returns a Transform function representing the composite operation
+/// \sa transformToTransform
+///
+template<typename T, typename Intermediate, typename U>
+Transform<T,U> operator>>(Transform<T, Intermediate> t1,
+ Transform<Intermediate, U> t2)
+{
+ return transformToTransform(t1, t2);
+}
+
+} // namespace Stream
+} // namespace PacBio
+
+#endif // PBCOPPER_CLI_FXNCLI_H
diff --git a/include/pbcopper/utility/CallbackTimer.h b/include/pbcopper/utility/CallbackTimer.h
new file mode 100644
index 0000000..7a271e8
--- /dev/null
+++ b/include/pbcopper/utility/CallbackTimer.h
@@ -0,0 +1,62 @@
+#ifndef PBCOPPER_UTILITY_CALLBACKTIMER_H
+#define PBCOPPER_UTILITY_CALLBACKTIMER_H
+
+#include "pbcopper/Config.h"
+#include <functional>
+#include <memory>
+
+namespace PacBio {
+namespace Utility {
+
+namespace internal { class CallbackTimerPrivate; }
+
+/// \brief The CallbackTimer class provides repetitive and single-shot timers
+/// for scheduling asynchronous tasks.
+///
+/// This class is used to schedule one or more callbacks to fire at some point
+/// number of milliseconds in the future, and optionally fire again every so
+/// many milliseconds.
+///
+/// As it stands, the callback function must be of the signature:
+///
+/// void foo(void);
+///
+/// whether a free function, member function, or lambda.
+///
+class CallbackTimer
+{
+public:
+ typedef uint64_t JobId;
+ typedef std::function<void()> HandlerFn;
+
+public:
+ static void SingleShot(uint64_t when, const HandlerFn& handler);
+ static void SingleShot(uint64_t when, HandlerFn&& handler);
+
+public:
+ CallbackTimer(void);
+ ~CallbackTimer(void);
+
+public:
+ JobId Schedule(const uint64_t when,
+ const uint64_t period,
+ const HandlerFn& handler);
+
+ JobId Schedule(const uint64_t when,
+ const uint64_t period,
+ HandlerFn&& handler);
+
+public:
+ bool Cancel(const JobId id);
+ bool IsActive(const JobId id);
+
+private:
+ std::unique_ptr<internal::CallbackTimerPrivate> d_;
+};
+
+} // namespace Utility
+} // namespace PacBio
+
+#include "internal/CallbackTimer-inl.h"
+
+#endif // PBCOPPER_UTILITY_CALLBACKTIMER_H
diff --git a/include/pbcopper/utility/EnumClassHash.h b/include/pbcopper/utility/EnumClassHash.h
new file mode 100644
index 0000000..8bd246d
--- /dev/null
+++ b/include/pbcopper/utility/EnumClassHash.h
@@ -0,0 +1,36 @@
+#ifndef PBCOPPER_UTILITY_ENUMCLASSHASH_H
+#define PBCOPPER_UTILITY_ENUMCLASSHASH_H
+
+#include <cstddef>
+
+namespace PacBio {
+namespace Utility {
+
+///
+/// \brief The EnumClassHash struct enables the use of enum class types as keys
+/// for std::unordered_map.
+///
+/// Allows something like:
+///
+/// \code{.cpp}
+/// std::unordered_map<Key_t, Value_t, EnumClassHash> myLookup;
+/// \endcode
+///
+/// where Key_t is an enum class. Without this sort of extra hand-holding to
+/// provide a 'manual' hash value, enum classes as keys will fail to compile.
+///
+/// \note This approach might be unnecessary in C++14, if I understand some of
+/// the changes correctly. But this works for C++11 and should continue beyond.
+///
+/// \sa http://stackoverflow.com/questions/18837857/cant-use-enum-class-as-unordered-map-key
+///
+struct EnumClassHash
+{
+ template<typename T> size_t operator()(const T t) const
+ { return static_cast<size_t>(t); }
+};
+
+} // namespace Utility
+} // namespace PacBio
+
+#endif // PBCOPPER_UTILITY_ENUMCLASSHASH_H
diff --git a/include/pbcopper/utility/Stopwatch.h b/include/pbcopper/utility/Stopwatch.h
new file mode 100644
index 0000000..5ac0d72
--- /dev/null
+++ b/include/pbcopper/utility/Stopwatch.h
@@ -0,0 +1,51 @@
+#ifndef PBCOPPER_UTILITY_STOPWATCH_H
+#define PBCOPPER_UTILITY_STOPWATCH_H
+
+#include "pbcopper/Config.h"
+#include <chrono>
+
+namespace PacBio {
+namespace Utility {
+
+class Stopwatch
+{
+public:
+ /// \name Constructors & Related Methods
+ /// \{
+
+ /// Creates a stopwatch and begins timing.
+ Stopwatch(void);
+
+ Stopwatch(const Stopwatch& other) = default;
+ Stopwatch(Stopwatch&& other) = default;
+ Stopwatch& operator=(const Stopwatch& other) = default;
+ Stopwatch& operator=(Stopwatch& other) = default;
+ ~Stopwatch(void) = default;
+
+ /// \}
+
+public:
+
+ /// \returns the elapsed time (in milliseconds) since timing began.
+ float ElapsedMilliseconds(void) const;
+
+ /// \returns the elapsed time (in seconds) since timing began.
+ float ElapsedSeconds(void) const;
+
+ /// \returns the elapsed time (in user-provided units) since timing began.
+ template<typename TimeUnit>
+ float Elapsed(void) const;
+
+ // resets internal values
+ void Reset(void);
+
+private:
+ std::chrono::steady_clock::time_point start_;
+};
+
+} // namespace Utility
+} // namespace PacBio
+
+#include "internal/Stopwatch-inl.h"
+
+#endif // PBCOPPER_UTILITY_STOPWATCH_H
diff --git a/include/pbcopper/utility/StringUtils.h b/include/pbcopper/utility/StringUtils.h
new file mode 100644
index 0000000..bc03564
--- /dev/null
+++ b/include/pbcopper/utility/StringUtils.h
@@ -0,0 +1,24 @@
+#ifndef PBCOPPER_UTILITY_STRINGUTILS_H
+#define PBCOPPER_UTILITY_STRINGUTILS_H
+
+#include <string>
+#include <vector>
+
+namespace PacBio {
+namespace Utility {
+
+std::string Join(const std::vector<std::string>& input,
+ const std::string& delim);
+
+std::string Join(const std::vector<std::string>& input,
+ const char delim);
+
+std::vector<std::string> Split(const std::string& line,
+ const char delim = '\t');
+
+} // namespace Utility
+} // namespace PacBio
+
+#include "internal/StringUtils-inl.h"
+
+#endif // PBCOPPER_UTILITY_STRINGUTILS_H
diff --git a/include/pbcopper/utility/SystemInfo.h b/include/pbcopper/utility/SystemInfo.h
new file mode 100644
index 0000000..f5a6633
--- /dev/null
+++ b/include/pbcopper/utility/SystemInfo.h
@@ -0,0 +1,29 @@
+#ifndef PBCOPPER_UTILITY_SYSTEMINFO_H
+#define PBCOPPER_UTILITY_SYSTEMINFO_H
+
+#include "pbcopper/Config.h"
+
+namespace PacBio {
+namespace Utility {
+
+class SystemInfo
+{
+public:
+ enum Endian
+ {
+ BigEndian,
+ LittleEndian
+ };
+
+public:
+ static constexpr SystemInfo::Endian ByteOrder(void);
+ static constexpr bool IsBigEndian(void);
+ static constexpr bool IsLittleEndian(void);
+};
+
+} // namespace Utility
+} // namespace PacBio
+
+#include "internal/SystemInfo-inl.h"
+
+#endif // PBCOPPER_UTILITY_SYSTEMINFO_H
diff --git a/include/pbcopper/utility/Version.h.in b/include/pbcopper/utility/Version.h.in
new file mode 100644
index 0000000..07e5447
--- /dev/null
+++ b/include/pbcopper/utility/Version.h.in
@@ -0,0 +1,57 @@
+// Copyright (c) 2016, Pacific Biosciences of California, Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted (subject to the limitations in the
+// disclaimer below) 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 Pacific Biosciences nor the names of its
+// contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission.
+//
+// NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
+// GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY PACIFIC
+// BIOSCIENCES AND ITS 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 PACIFIC BIOSCIENCES OR ITS
+// 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.
+
+// Author: Armin Töpfer
+
+#pragma once
+
+#include <string>
+
+namespace PacBio {
+namespace Utility {
+
+constexpr auto LibraryVersion = "@pbcopper_VERSION@";
+constexpr auto LibraryGitSha1 = "@COPPER_GIT_SHA1@";
+constexpr size_t LibraryMajor = @pbcopper_VERSION_MAJOR@;
+constexpr size_t LibraryMinor = @pbcopper_VERSION_MINOR@;
+constexpr size_t LibraryPatch = @pbcopper_VERSION_PATCH@;
+
+std::string LibraryVersionString()
+{ return LibraryVersion; }
+
+std::string LibraryGitSha1String()
+{ return LibraryGitSha1; }
+
+}} // ::PacBio::Utility
diff --git a/include/pbcopper/utility/internal/CallbackTimer-inl.h b/include/pbcopper/utility/internal/CallbackTimer-inl.h
new file mode 100644
index 0000000..b15e2d2
--- /dev/null
+++ b/include/pbcopper/utility/internal/CallbackTimer-inl.h
@@ -0,0 +1,198 @@
+#ifndef PBCOPPER_UTILITY_CALLBACKTIMER_INL_H
+#define PBCOPPER_UTILITY_CALLBACKTIMER_INL_H
+
+#include "pbcopper/utility/CallbackTimer.h"
+
+#include <algorithm>
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <set>
+#include <thread>
+#include <unordered_map>
+
+namespace PacBio {
+namespace Utility {
+namespace internal {
+
+typedef std::chrono::steady_clock CallbackTimerClock;
+typedef std::chrono::time_point<CallbackTimerClock> CallbackTimerTimePoint;
+typedef std::chrono::milliseconds CallbackTimerDuration;
+typedef std::unique_lock<std::mutex> CallbackTimerMutexLocker;
+
+struct CallbackTimerJob
+{
+public:
+ CallbackTimer::JobId id;
+ CallbackTimerTimePoint next;
+ CallbackTimerDuration period;
+ CallbackTimer::HandlerFn handler;
+ bool running;
+
+public:
+ CallbackTimerJob(CallbackTimer::JobId id = 0)
+ : id(id)
+ , running(false)
+ { }
+
+ template<typename CallbackType>
+ CallbackTimerJob(CallbackTimer::JobId id,
+ CallbackTimerTimePoint next,
+ CallbackTimerDuration period,
+ CallbackType&& handler) noexcept
+ : id(id)
+ , next(next)
+ , period(period)
+ , handler(std::forward<CallbackType>(handler))
+ , running(false)
+ { }
+
+ CallbackTimerJob(CallbackTimerJob&& r) noexcept
+ : id(r.id)
+ , next(r.next)
+ , period(r.period)
+ , handler(std::move(r.handler))
+ , running(r.running)
+ { }
+
+ CallbackTimerJob& operator=(CallbackTimerJob&& r)
+ {
+ if (this != &r) {
+ id = r.id;
+ next = r.next;
+ period = r.period;
+ handler = std::move(r.handler);
+ running = r.running;
+ }
+ return *this;
+ }
+
+ CallbackTimerJob(CallbackTimerJob const& r) = delete;
+ CallbackTimerJob& operator=(CallbackTimerJob const& r) = delete;
+};
+
+struct NextActive
+{
+ bool operator()(const CallbackTimerJob& a,
+ const CallbackTimerJob& b) const
+ { return a.next < b.next; }
+};
+
+class CallbackTimerPrivate
+{
+ typedef CallbackTimer::JobId JobId;
+ typedef CallbackTimer::HandlerFn HandlerFn;
+ typedef std::unordered_map<JobId, CallbackTimerJob> JobMap;
+ typedef std::reference_wrapper<CallbackTimerJob> QueueValue;
+ typedef std::multiset<QueueValue, NextActive> JobQueue;
+
+public:
+ CallbackTimerPrivate(void)
+ : nextId(1)
+ , queue(NextActive())
+ , worker(std::bind(&CallbackTimerPrivate::Run, this))
+ , done(false)
+ { }
+
+ ~CallbackTimerPrivate(void)
+ {
+ CallbackTimerMutexLocker lock(sync);
+
+ // mark ourselves as 'done' & wait for thread to wrap up
+ done = true;
+ wakeUp.notify_all();
+ lock.unlock();
+ worker.join();
+ }
+
+public:
+ JobId Schedule(const uint64_t msFromNow,
+ const uint64_t msPeriod,
+ const HandlerFn& handler)
+ {
+ return ScheduleImpl(
+ CallbackTimerJob{
+ 0,
+ CallbackTimerClock::now() + CallbackTimerDuration(msFromNow),
+ CallbackTimerDuration(msPeriod),
+ handler
+ }
+ );
+ }
+
+ JobId Schedule(const uint64_t msFromNow,
+ const uint64_t msPeriod,
+ HandlerFn&& handler)
+ {
+ return ScheduleImpl(
+ CallbackTimerJob{
+ 0,
+ CallbackTimerClock::now() + CallbackTimerDuration(msFromNow),
+ CallbackTimerDuration(msPeriod),
+ std::move(handler)
+ }
+ );
+ }
+
+
+ bool IsActive(const JobId id)
+ {
+ CallbackTimerMutexLocker lock(sync);
+ return activeJobs.find(id) != activeJobs.end();
+ }
+
+ bool Cancel(const JobId id);
+
+private:
+ // job storage
+ JobId nextId;
+ JobMap activeJobs;
+ JobQueue queue;
+
+ // job scheduling
+ std::mutex sync;
+ std::condition_variable wakeUp;
+ std::thread worker;
+ bool done;
+
+private:
+ void Run(void);
+ JobId ScheduleImpl(CallbackTimerJob&& item);
+};
+
+} // namespace internal
+
+inline CallbackTimer::CallbackTimer(void)
+ : d_(new internal::CallbackTimerPrivate)
+{ }
+
+inline CallbackTimer::~CallbackTimer(void) { }
+
+inline bool CallbackTimer::Cancel(const JobId id)
+{
+ return d_->Cancel(id);
+}
+
+inline bool CallbackTimer::IsActive(const JobId id)
+{
+ return d_->IsActive(id);
+}
+
+inline CallbackTimer::JobId CallbackTimer::Schedule(const uint64_t msFromNow,
+ const uint64_t msPeriod,
+ const HandlerFn &handler)
+{
+ return d_->Schedule(msFromNow, msPeriod, handler);
+}
+
+inline CallbackTimer::JobId CallbackTimer::Schedule(const uint64_t msFromNow,
+ const uint64_t msPeriod,
+ HandlerFn &&handler)
+{
+ return d_->Schedule(msFromNow, msPeriod, std::move(handler));
+}
+
+} // namespace Utility
+} // namespace PacBio
+
+#endif // PBCOPPER_UTILITY_CALLBACKTIMER_INL_H
diff --git a/include/pbcopper/utility/internal/Stopwatch-inl.h b/include/pbcopper/utility/internal/Stopwatch-inl.h
new file mode 100644
index 0000000..48c8eba
--- /dev/null
+++ b/include/pbcopper/utility/internal/Stopwatch-inl.h
@@ -0,0 +1,39 @@
+#ifndef PBCOPPER_UTILITY_STOPWATCH_INL_H
+#define PBCOPPER_UTILITY_STOPWATCH_INL_H
+
+#include "pbcopper/utility/Stopwatch.h"
+
+namespace PacBio {
+namespace Utility {
+
+inline Stopwatch::Stopwatch(void)
+{
+ Reset();
+}
+
+template<typename TimeUnit>
+float Stopwatch::Elapsed(void) const
+{
+ const auto now = std::chrono::steady_clock::now();
+ return std::chrono::duration_cast<TimeUnit>(now - start_).count();
+}
+
+inline float Stopwatch::ElapsedMilliseconds(void) const
+{
+ return Elapsed<std::chrono::milliseconds>();
+}
+
+inline float Stopwatch::ElapsedSeconds(void) const
+{
+ return Elapsed<std::chrono::seconds>();
+}
+
+void Stopwatch::Reset(void)
+{
+ start_ = std::chrono::steady_clock::now();
+}
+
+} // namespace Utility
+} // namespace PacBio
+
+#endif // PBCOPPER_UTILITY_STOPWATCH_INL_H
diff --git a/include/pbcopper/utility/internal/StringUtils-inl.h b/include/pbcopper/utility/internal/StringUtils-inl.h
new file mode 100644
index 0000000..3672063
--- /dev/null
+++ b/include/pbcopper/utility/internal/StringUtils-inl.h
@@ -0,0 +1,51 @@
+#ifndef PBCOPPER_UTILITY_STRINGUTILS_INL_H
+#define PBCOPPER_UTILITY_STRINGUTILS_INL_H
+
+#include "pbcopper/utility/StringUtils.h"
+#include <sstream>
+
+namespace PacBio {
+namespace Utility {
+
+inline std::string Join(const std::vector<std::string>& input,
+ const std::string& delim)
+{
+ // determine total joined length
+ size_t totalLen = 0;
+ for (const auto& s : input)
+ totalLen += s.size();
+ if (!input.empty())
+ totalLen += delim.size() * (input.size()-1); // no delim after last string
+
+ // join input strings
+ std::string result;
+ result.reserve(totalLen);
+ for (size_t i = 0; i < input.size(); ++i) {
+ if (i != 0)
+ result += delim;
+ result += input.at(i);
+ }
+ return result;
+}
+
+inline std::string Join(const std::vector<std::string>& input,
+ const char delim)
+{
+ return Join(input, std::string(1, delim));
+}
+
+inline std::vector<std::string> Split(const std::string& line,
+ const char delim)
+{
+ std::vector<std::string> tokens;
+ std::stringstream lineStream{ line };
+ std::string token;
+ while (std::getline(lineStream, token, delim))
+ tokens.push_back(token);
+ return tokens;
+}
+
+} // namespace Utility
+} // namespace PacBio
+
+#endif // PBCOPPER_UTILITY_STRINGUTILS_INL_H
diff --git a/include/pbcopper/utility/internal/SystemInfo-inl.h b/include/pbcopper/utility/internal/SystemInfo-inl.h
new file mode 100644
index 0000000..d2333b7
--- /dev/null
+++ b/include/pbcopper/utility/internal/SystemInfo-inl.h
@@ -0,0 +1,54 @@
+#ifndef PBCOPPER_UTILITY_SYSTEMINFO_INL_H
+#define PBCOPPER_UTILITY_SYSTEMINFO_INL_H
+
+#include "pbcopper/utility/SystemInfo.h"
+#include <boost/detail/endian.hpp>
+
+namespace PacBio {
+namespace Utility {
+
+//
+// if something funky with Boost detection, do this 'manual' compile-time check
+// as fallback
+//
+#if !defined(BOOST_LITTLE_ENDIAN) && !defined(BOOST_BIG_ENDIAN)
+
+namespace internal {
+
+class EndianHelper
+{
+private:
+ static constexpr uint32_t num_ = 0x01020304;
+ static constexpr uint8_t check_ = static_cast<const uint8_t&>(num_);
+public:
+ static constexpr bool little = (check_ == 0x04);
+ static constexpr bool big = (check_ == 0x01);
+ static_assert(little || big, "cannot determine endianness");
+};
+
+} // namespace internal
+
+#endif // no Boost endian
+
+inline constexpr SystemInfo::Endian SystemInfo::ByteOrder(void)
+{
+#if defined(BOOST_LITTLE_ENDIAN)
+ return SystemInfo::LittleEndian;
+#elif defined(BOOST_BIG_ENDIAN)
+ return SystemInfo::BigEndian;
+#else
+ return internal::EndianHelper::little ? SystemInfo::LittleEndian
+ : SystemInfo::BigEndian;
+#endif
+}
+
+inline constexpr bool SystemInfo::IsBigEndian(void)
+{ return SystemInfo::ByteOrder() == SystemInfo::BigEndian; }
+
+inline constexpr bool SystemInfo::IsLittleEndian(void)
+{ return SystemInfo::ByteOrder() == SystemInfo::LittleEndian; }
+
+} // namespace Utility
+} // namespace PacBio
+
+#endif // PBCOPPER_UTILITY_SYSTEMINFO_H
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
new file mode 100644
index 0000000..bf1c736
--- /dev/null
+++ b/src/CMakeLists.txt
@@ -0,0 +1,54 @@
+
+# define pbcopper library dependencies
+set(pbcopper_DependencyIncludes
+ ${Boost_INCLUDE_DIRS}
+)
+set(pbcopper_DependencyLibraries
+ ${CMAKE_THREAD_LIBS_INIT}
+)
+
+# set up library include dirs
+include_directories(SYSTEM ${pbcopper_DependencyIncludes})
+include_directories(${pbcopper_IncludeDir})
+
+# grab library source files
+include(files.cmake)
+set(SOURCES
+ ${pbcopper_H}
+ ${pbcopper_CPP}
+)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${pbcopper_CXX_FLAGS}")
+
+# define pbcopper library
+add_definitions(-DPBCOPPER_LIBRARY)
+add_library(pbcopper ${SOURCES})
+set_target_properties(pbcopper
+ PROPERTIES
+ ARCHIVE_OUTPUT_DIRECTORY ${pbcopper_LibDir}
+ RUNTIME_OUTPUT_DIRECTORY ${pbcopper_LibDir}
+ LIBRARY_OUTPUT_DIRECTORY ${pbcopper_LibDir}
+)
+
+# link dependency libs
+target_link_libraries(pbcopper ${pbcopper_DependencyLibraries})
+target_include_directories(pbcopper
+ PUBLIC
+ ${pbcopper_IncludeDir}
+ ${pbcopper_DependencyIncludes}
+ ${CMAKE_BINARY_DIR}/generated
+)
+
+# export variables for projects that use pbcopper
+set(pbcopper_INCLUDE_DIRS
+ ${pbcopper_IncludeDir} ${pbcopper_DependencyIncludes} ${CMAKE_BINARY_DIR}/generated
+ CACHE INTERNAL
+ "${PROJECT_NAME}: Include Directories"
+ FORCE
+)
+
+set(pbcopper_LIBRARIES
+ pbcopper ${pbcopper_DependencyLibraries}
+ CACHE INTERNAL
+ "${PROJECT_NAME}: Libraries"
+ FORCE
+)
diff --git a/src/cli/CLI.cpp b/src/cli/CLI.cpp
new file mode 100644
index 0000000..50d220e
--- /dev/null
+++ b/src/cli/CLI.cpp
@@ -0,0 +1,95 @@
+#include "pbcopper/cli/CLI.h"
+
+#include "pbcopper/cli/HelpPrinter.h"
+#include "pbcopper/cli/Parser.h"
+#include "pbcopper/cli/VersionPrinter.h"
+#include "pbcopper/cli/toolcontract/JsonPrinter.h"
+#include "pbcopper/cli/toolcontract/ResolvedToolContract.h"
+#include <fstream>
+#include <iostream>
+#include <cstdlib>
+
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace std;
+
+namespace PacBio {
+namespace CLI {
+
+int Run(int argc, char *argv[],
+ const Interface& interface,
+ const ResultsHandler& handler)
+{
+ return Run(vector<string>{argv, argv + argc},
+ interface,
+ handler);
+}
+
+int Run(const vector<string>& args,
+ const Interface& interface,
+ const ResultsHandler& handler)
+{
+ // parse command line args
+ Parser parser(interface);
+ const auto results = parser.Parse(args);
+
+ // check for help option (enabled & requested)
+ if (interface.HasHelpOptionRegistered()) {
+ const auto helpOptionId = interface.HelpOption().Id();
+ const bool helpRequested = results[helpOptionId];
+ if (helpRequested) {
+ HelpPrinter::Print(interface, std::cout);
+ return EXIT_SUCCESS;
+ }
+ }
+
+ // check for version option (enabled & requested)
+ if (interface.HasVersionOptionRegistered()) {
+ const auto versionOptionId = interface.VersionOption().Id();
+ const bool versionRequested = results[versionOptionId];
+ if (versionRequested) {
+ VersionPrinter::Print(interface, std::cout);
+ return EXIT_SUCCESS;
+ }
+ }
+
+ // tool contract support
+ if (interface.IsToolContractEnabled()) {
+
+ // check for emit-tool-contract requested
+ const bool emitTcRequested = results["emit_tc"];
+ if (emitTcRequested) {
+ ToolContract::JsonPrinter::Print(interface, std::cout);
+ return EXIT_SUCCESS;
+ }
+
+ // check for resolved tool contract cmdline input
+ const string& rtcFn = results["rtc_provided"];
+ if (!rtcFn.empty()) {
+
+ // invoke app callback with results parsed from RTC
+ ToolContract::ResolvedToolContract rtc(interface);
+ ifstream in(rtcFn);
+ if (in) {
+ const auto rtcResults = rtc.Parse(in);
+ return handler(rtcResults);
+ }
+ }
+ }
+
+ // otherwise invoke app callback with results parsed from command line
+ return handler(results);
+}
+
+void PrintHelp(const Interface& interface, ostream& out)
+{
+ HelpPrinter::Print(interface, out);
+}
+
+void PrintVersion(const Interface& interface, ostream& out)
+{
+ VersionPrinter::Print(interface, out);
+}
+
+} // namespace CLI
+} // namespace PacBio
diff --git a/src/cli/HelpPrinter.cpp b/src/cli/HelpPrinter.cpp
new file mode 100644
index 0000000..09cb050
--- /dev/null
+++ b/src/cli/HelpPrinter.cpp
@@ -0,0 +1,209 @@
+#include "pbcopper/cli/HelpPrinter.h"
+#include "pbcopper/cli/Interface.h"
+#include "pbcopper/json/JSON.h"
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <algorithm>
+#include <sstream>
+#include <string>
+#include <vector>
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace PacBio::JSON;
+using namespace std;
+
+namespace PacBio {
+namespace CLI {
+namespace internal {
+
+static
+bool shouldIncludeDefaultValue(const Json& defaultValue)
+{
+ // omit if switch OR null
+ if (defaultValue.is_boolean() || defaultValue.is_null())
+ return false;
+
+ // omit if empty string default on string-type option
+ if (defaultValue.is_string()) {
+ const string val = defaultValue;
+ if (val.empty())
+ return false;
+ }
+
+ // otherwise include default value
+ return true;
+}
+
+static
+string formatOption(string optionOutput,
+ size_t longestOptionLength,
+ string description,
+ Json defaultValue)
+{
+ struct winsize ws;
+ ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws);
+ const size_t ncol = (ws.ws_col < 2) ? 79 : ws.ws_col - 1;
+
+ stringstream result("");
+ auto fullDescription = description;
+
+ // maybe add default value to description
+ if (shouldIncludeDefaultValue(defaultValue)) {
+ fullDescription += " [";
+ fullDescription += defaultValue.dump();
+ fullDescription += "]";
+ }
+
+ // option names
+ optionOutput.resize(longestOptionLength, ' ');
+ result << " " << optionOutput << " ";
+
+ // maybe wrap description
+ const auto indent = result.str().length();
+ auto lineStart = size_t{ 0 };
+ auto lastBreakable = string::npos;
+ const auto max = size_t{ ncol - indent };
+ auto x = size_t{ 0 };
+ const auto len = fullDescription.length();
+
+ for (size_t i = 0; i < len; ++i) {
+ ++x;
+ const auto c = fullDescription.at(i);
+ if (isspace(c))
+ lastBreakable = i;
+
+ auto breakAt = string::npos;
+ auto nextLineStart = string::npos;
+
+ if (x > max && lastBreakable != string::npos) {
+ breakAt = lastBreakable;
+ nextLineStart = lastBreakable + 1;
+ } else if ( (x > max-1 && lastBreakable == string::npos) || i == len-1) {
+ breakAt = i + 1;
+ nextLineStart = breakAt;
+ } else if (c == '\n') {
+ breakAt = i;
+ nextLineStart = i+1;
+ }
+
+ if (breakAt != string::npos) {
+ const auto numChars = breakAt - lineStart;
+ if (lineStart > 0)
+ result << string(indent, ' ');
+ result << fullDescription.substr(lineStart, numChars) << endl;
+ x = 0;
+ lastBreakable = string::npos;
+ lineStart = nextLineStart;
+ if (lineStart < len && isspace(fullDescription.at(lineStart)))
+ ++lineStart;
+ i = lineStart;
+ }
+ }
+ return result.str();
+}
+
+static
+string formatOptionNames(const Option& option)
+{
+ stringstream optionOutput("");
+ auto first = true;
+ for(const auto& name : option.Names()) {
+ if (first)
+ first = false;
+ else
+ optionOutput << ",";
+
+ if (name.size() == 1)
+ optionOutput << "-";
+ else
+ optionOutput << "--";
+
+ optionOutput << name;
+ }
+
+ if (!option.ValueName().empty())
+ optionOutput << " <" << option.ValueName() << ">";
+
+ return optionOutput.str();
+}
+
+static
+string makeHelpText(const Interface& interface)
+{
+ stringstream result("");
+
+ const auto options = interface.RegisteredOptions();
+ const auto posArgs = interface.RegisteredPositionalArgs();
+
+ // setup usage output
+ {
+ stringstream usage("");
+ usage << interface.ApplicationName();
+ if (!options.empty())
+ usage << " [options]";
+ for (const auto& posArg : posArgs)
+ usage << " " << posArg.syntax_;
+ result << "Usage: " << usage.str() << endl;
+ }
+
+ // description
+ const auto appDescription = interface.ApplicationDescription();
+ if (!appDescription.empty())
+ result << appDescription << endl;
+
+ // empty line
+ result << endl;
+
+ // options
+ if (!options.empty())
+ result << "Options: " << endl;
+
+ auto optionOutputList = vector<string>{ };
+ auto longestOptionOutputLength = size_t{ 0 };
+
+ // registered options
+ for(const auto& option : options) {
+ const auto optionOutputString = formatOptionNames(option);
+ optionOutputList.push_back(optionOutputString);
+ longestOptionOutputLength = std::max(longestOptionOutputLength,
+ optionOutputString.size());
+ }
+
+ // spacer
+ ++longestOptionOutputLength;
+
+ // registered options
+ for (size_t i = 0; i < options.size(); ++i) {
+ const auto& option = options.at(i);
+ if (option.IsHidden())
+ continue;
+ result << formatOption(optionOutputList.at(i),
+ longestOptionOutputLength,
+ option.Description(),
+ option.DefaultValue());
+ }
+
+ // positional args
+ if (!posArgs.empty()) {
+ if (!options.empty())
+ result << endl;
+ result << "Arguments: " << endl;
+ for (const auto& posArg : posArgs) {
+ result << formatOption(posArg.name_,
+ longestOptionOutputLength,
+ posArg.description_,
+ Json());
+ }
+ }
+
+ return result.str();
+}
+
+} // namespace internal
+} // namespace CLI
+} // namespace PacBio
+
+void HelpPrinter::Print(const Interface& interface, ostream& out)
+{
+ out << internal::makeHelpText(interface) << endl;
+}
diff --git a/src/cli/Interface.cpp b/src/cli/Interface.cpp
new file mode 100644
index 0000000..16549a4
--- /dev/null
+++ b/src/cli/Interface.cpp
@@ -0,0 +1,273 @@
+#include "pbcopper/cli/Interface.h"
+#include <boost/optional.hpp>
+#include <unordered_map>
+#include <cassert>
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace std;
+
+namespace PacBio {
+namespace CLI {
+namespace internal {
+
+class InterfacePrivate
+{
+ typedef unordered_map<string, size_t> NameLookup;
+
+public:
+ // application info
+ string appName_;
+ string appDescription_;
+ string appVersion_;
+ string alternativeToolContractName_;
+
+ // parsing mode/status
+ SingleDashMode singleDashMode_;
+ bool isParsed_;
+ string errorString_;
+
+ // registered options
+ vector<Option> options_;
+ vector<PositionalArg> positionalArgs_;
+ NameLookup optionNameLookup_;
+
+ boost::optional<ToolContract::Config> tcConfig_;
+
+ boost::optional<Option> helpOption_;
+ boost::optional<Option> logLevelOption_;
+ boost::optional<Option> verboseOption_;
+ boost::optional<Option> versionOption_;
+
+public:
+ InterfacePrivate(const string& appName,
+ const string& appDescription,
+ const string& appVersion)
+ : appName_(appName)
+ , appDescription_(appDescription)
+ , appVersion_(appVersion)
+ , singleDashMode_(SingleDashMode::ParseAsShortOptions)
+ , isParsed_(false)
+ , tcConfig_(boost::none)
+ , helpOption_(boost::none)
+ , logLevelOption_(boost::none)
+ , verboseOption_(boost::none)
+ , versionOption_(boost::none)
+ {
+ if (appName_.empty())
+ throw runtime_error("CLI::Interface - application name must not be empty");
+ }
+
+ InterfacePrivate(const InterfacePrivate& other) = default;
+
+public:
+ void AddOption(const Option& option);
+ void AddPositionalArgument(PositionalArg posArg);
+};
+
+void InterfacePrivate::AddOption(const Option& option)
+{
+ auto optionNames = option.Names();
+ assert(!optionNames.empty());
+
+ // ensure unique
+ for (const auto& name : optionNames) {
+ if (optionNameLookup_.find(name) != optionNameLookup_.cend())
+ throw std::runtime_error("CLI::Interface - duplicate option name:"+name);
+ }
+
+ // store option
+ options_.push_back(option);
+
+ // store names in lookup
+ const auto optionIndex = options_.size() - 1;
+ for (const auto& name : optionNames)
+ optionNameLookup_.insert(std::make_pair(name, optionIndex));
+}
+
+void InterfacePrivate::AddPositionalArgument(PositionalArg posArg)
+{
+ if (posArg.syntax_.empty())
+ posArg.syntax_ = posArg.name_;
+ positionalArgs_.push_back(posArg);
+}
+
+} // namespace internal
+} // namespace CLI
+} // namespace PacBio
+
+// ------------------------
+// PacBio::CLI::Interface
+// ------------------------
+
+Interface::Interface(const string& appName,
+ const string& appDescription,
+ const string& appVersion)
+ : d_(new internal::InterfacePrivate{appName, appDescription, appVersion})
+{ }
+
+Interface::Interface(const Interface& other)
+ : d_(new internal::InterfacePrivate{*other.d_.get()})
+{ }
+
+Interface::~Interface(void) { }
+
+Interface& Interface::AddHelpOption(const Option& option)
+{
+ d_->helpOption_ = option;
+ d_->AddOption(option);
+ return *this;
+}
+
+Interface& Interface::AddLogLevelOption(const Option& option)
+{
+ d_->logLevelOption_ = option;
+ d_->AddOption(option);
+ return *this;
+}
+
+Interface& Interface::AddOption(const Option& option)
+{ return AddOptions( vector<Option>{ option }); }
+
+Interface& Interface::AddOptions(const vector<Option>& options)
+{
+ for (const auto& opt : options)
+ d_->AddOption(opt);
+ return *this;
+}
+
+Interface& Interface::AddPositionalArgument(const PositionalArg& posArg)
+{ return AddPositionalArguments(vector<PositionalArg>{ posArg }); }
+
+Interface& Interface::AddPositionalArguments(const vector<PositionalArg>& posArgs)
+{
+ for (const auto& posArg : posArgs)
+ d_->AddPositionalArgument(posArg);
+ return *this;
+}
+
+Interface& Interface::AddVerboseOption(const Option& option)
+{
+ d_->verboseOption_ = option;
+ d_->AddOption(option);
+ return *this;
+}
+
+Interface& Interface::AddVersionOption(const Option& option)
+{
+ d_->versionOption_ = option;
+ d_->AddOption(option);
+ return *this;
+}
+
+string Interface::ApplicationDescription(void) const
+{ return d_->appDescription_; }
+
+Interface& Interface::ApplicationDescription(const string& description)
+{ d_->appDescription_ = description; return *this; }
+
+string Interface::ApplicationName(void) const
+{ return d_->appName_; }
+
+Interface& Interface::ApplicationName(const string& name)
+{ d_->appName_ = name; return *this; }
+
+string Interface::ApplicationVersion(void) const
+{ return d_->appVersion_; }
+
+Interface& Interface::ApplicationVersion(const string& version)
+{ d_->appVersion_ = version; return *this; }
+
+string Interface::AlternativeToolContractName(void) const
+{ return d_->alternativeToolContractName_; }
+
+Interface& Interface::AlternativeToolContractName(const string& version)
+{ d_->alternativeToolContractName_ = version; return *this; }
+
+Interface& Interface::EnableToolContract(const ToolContract::Config& tcConfig)
+{
+ d_->AddOption(Option{"emit_tc", "emit-tool-contract", "Emit tool contract."});
+ d_->AddOption(Option{"rtc_provided", "resolved-tool-contract", "Use args from resolved tool contract.", Option::StringType("")});
+ d_->tcConfig_ = tcConfig;
+ return *this;
+}
+
+bool Interface::ExpectsValue(const std::string& optionName) const
+{
+ const auto nameLookupIter = d_->optionNameLookup_.find(optionName);
+ if (nameLookupIter == d_->optionNameLookup_.cend())
+ throw std::runtime_error("CLI::Interface - unknown option name: "+optionName);
+ const auto offset = nameLookupIter->second;
+ const JSON::Json& defaultValue = d_->options_.at(offset).DefaultValue();
+ return !defaultValue.is_boolean();
+}
+
+bool Interface::HasHelpOptionRegistered(void) const
+{ return d_->helpOption_.is_initialized(); }
+
+bool Interface::HasLogLevelOptionRegistered(void) const
+{ return d_->logLevelOption_.is_initialized(); }
+
+bool Interface::HasVerboseOptionRegistered(void) const
+{ return d_->verboseOption_.is_initialized(); }
+
+bool Interface::HasVersionOptionRegistered(void) const
+{ return d_->versionOption_.is_initialized(); }
+
+bool Interface::HasOptionRegistered(const std::string& optionName) const
+{
+ return d_->optionNameLookup_.find(optionName) !=
+ d_->optionNameLookup_.cend();
+}
+
+const Option& Interface::HelpOption(void) const
+{
+ if (!HasHelpOptionRegistered())
+ throw std::runtime_error("CLI::Interface - help option requested, but not registered");
+ return d_->helpOption_.get();
+}
+
+std::string Interface::IdForOptionName(const std::string& optionName) const
+{
+ const auto nameLookupIter = d_->optionNameLookup_.find(optionName);
+ if (nameLookupIter == d_->optionNameLookup_.cend())
+ throw std::runtime_error("CLI::Interface - unknown option name: "+optionName);
+ const auto offset = nameLookupIter->second;
+ return d_->options_.at(offset).Id();
+}
+
+bool Interface::IsToolContractEnabled(void) const
+{ return d_->tcConfig_.is_initialized(); }
+
+const Option& Interface::LogLevelOption(void) const
+{
+ if (!HasLogLevelOptionRegistered())
+ throw std::runtime_error("CLI::Interface - log level option requested, but not registered");
+ return d_->logLevelOption_.get();
+}
+
+vector<Option> Interface::RegisteredOptions(void) const
+{ return d_->options_; }
+
+vector<PositionalArg> Interface::RegisteredPositionalArgs(void) const
+{ return d_->positionalArgs_; }
+
+const ToolContract::Config& Interface::ToolContract(void) const
+{
+ if (!d_->tcConfig_)
+ throw std::runtime_error("CLI::Interface - requesting tool contract config for an interface that has not enabled this feature.");
+ return d_->tcConfig_.get();
+}
+
+const Option& Interface::VerboseOption(void) const
+{
+ if (!HasVerboseOptionRegistered())
+ throw std::runtime_error("CLI::Interface - verbose option requested, but not registered");
+ return d_->verboseOption_.get();
+}
+
+const Option& Interface::VersionOption(void) const
+{
+ if (!HasVersionOptionRegistered())
+ throw std::runtime_error("CLI::Interface - version option requested, but not registered");
+ return d_->versionOption_.get();
+}
diff --git a/src/cli/Option.cpp b/src/cli/Option.cpp
new file mode 100644
index 0000000..6bec1c3
--- /dev/null
+++ b/src/cli/Option.cpp
@@ -0,0 +1,50 @@
+
+#include "pbcopper/cli/Option.h"
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace std;
+
+namespace PacBio {
+namespace CLI {
+namespace internal {
+
+static const Option defaultHelpOption {
+ "help",
+ {"h", "help"},
+ "Output this help."
+};
+
+static const Option defaultLogLevelOption {
+ "log_level",
+ {"log-level", "logLevel"},
+ "Set log level.",
+ Option::StringType("INFO")
+};
+
+static const Option defaultVerboseOption {
+ "verbose",
+ {"v", "verbose"},
+ "Use verbose output."
+};
+
+static const Option defaultVersionOption {
+ "version",
+ "version",
+ "Output version info."
+};
+
+} // namespace internal
+} // namespace CLI
+} // namespace PacBio
+
+const Option& Option::DefaultHelpOption(void)
+{ return internal::defaultHelpOption; }
+
+const Option& Option::DefaultLogLevelOption(void)
+{ return internal::defaultLogLevelOption; }
+
+const Option& Option::DefaultVerboseOption(void)
+{ return internal::defaultVerboseOption; }
+
+const Option& Option::DefaultVersionOption(void)
+{ return internal::defaultVersionOption; }
diff --git a/src/cli/Parser.cpp b/src/cli/Parser.cpp
new file mode 100644
index 0000000..ed9de04
--- /dev/null
+++ b/src/cli/Parser.cpp
@@ -0,0 +1,200 @@
+#include "pbcopper/cli/Parser.h"
+#include "pbcopper/cli/Interface.h"
+#include <unordered_map>
+#include <cassert>
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace std;
+
+namespace PacBio {
+namespace CLI {
+namespace internal {
+
+class ParserPrivate
+{
+public:
+ typedef unordered_map<string, size_t> NameLookup;
+ typedef unordered_map<size_t, vector<string> > ValueLookup;
+
+public:
+ // registered interface
+ PacBio::CLI::Interface interface_;
+ PacBio::CLI::Results results_;
+
+ vector<string> observedOptions_; // consider a set
+ ValueLookup observedOptionValues_;
+
+public:
+ ParserPrivate(const Interface& interface)
+ : interface_(interface)
+ , results_(interface)
+ { }
+
+ ParserPrivate(const ParserPrivate& other) = default;
+
+ void Parse(const vector<string>& args);
+ void ParseOptionValue(const string& optionName,
+ const string& argument,
+ vector<string>::const_iterator* argumentIterator,
+ vector<string>::const_iterator argsEnd);
+};
+
+void ParserPrivate::Parse(const vector<string>& args)
+{
+ results_ = Results{ interface_, args };
+
+ const auto doubleDash = "--";
+ const auto dash = '-';
+ const auto equal = '=';
+ auto forcePositional = false;
+
+ SingleDashMode singleDashMode_ = SingleDashMode::ParseAsShortOptions;
+
+ // skip app name
+ if (args.empty())
+ throw std::runtime_error("CLI::Parser - received an empty argument list (should have at least the program name)");
+ auto argIter = args.cbegin();
+ auto argEnd = args.cend();
+ ++argIter;
+
+ // loop over args
+ for (; argIter != argEnd; ++argIter) {
+ const auto& arg = *argIter;
+
+ // definitely positional
+ if (forcePositional)
+ results_.RegisterPositionalArg(arg);
+
+ // long option
+ else if (arg.find(doubleDash) == 0) {
+ if (arg.length() > 2) {
+
+ // pull option name from arg
+ auto optionName = arg.substr(2); // strip '--'
+ const auto equalOffset = optionName.find(equal);
+ if (equalOffset != string::npos)
+ optionName = optionName.substr(0, equalOffset);
+
+ // register found & parse value
+ const auto& optionId = interface_.IdForOptionName(optionName);
+ results_.RegisterObservedOption(optionId);
+ ParseOptionValue(optionName, arg, &argIter, argEnd);
+
+ }
+ else forcePositional = true;
+ }
+
+ // short option
+ else if (arg.find(dash) == 0) {
+
+ // single dash only (probably indicating 'stdin')
+ if (arg.length() == 1) {
+ results_.RegisterPositionalArg(arg);
+ continue;
+ }
+
+ switch (singleDashMode_)
+ {
+ case SingleDashMode::ParseAsShortOptions :
+ {
+ auto optionName = string{ };
+ auto valueFound = false;
+
+ for (size_t i = 1; i < arg.size(); ++i) {
+ optionName = arg.substr(i, 1);
+
+ const auto& optionId = interface_.IdForOptionName(optionName);
+ results_.RegisterObservedOption(optionId);
+ const auto expectsValue = interface_.ExpectsValue(optionName);
+ if (expectsValue) {
+ if (i+1 < arg.size()) {
+ if (arg.at(i+1) == equal)
+ ++i;
+ results_.RegisterOptionValue(optionName, arg.substr(i+1));
+ valueFound = true;
+ }
+ break;
+ }
+ if (i+1 < arg.size() && arg.at(i+1) == equal)
+ break;
+ }
+
+ if (!valueFound)
+ ParseOptionValue(optionName, arg, &argIter, argEnd);
+ break;
+ }
+
+ case SingleDashMode::ParseAsLongOptions :
+ {
+ auto optionName = string{ "" }; // strip -, get up to "="
+ const auto& optionId = interface_.IdForOptionName(optionName);
+ results_.RegisterObservedOption(optionId);
+ ParseOptionValue(optionName, arg, &argIter, argEnd);
+ break;
+ }
+ }
+ }
+
+ // positional argument
+ else
+ results_.RegisterPositionalArg(arg);
+
+ // make sure we get out at end
+ if (argIter == argEnd)
+ break;
+ }
+}
+
+void ParserPrivate::ParseOptionValue(const string& optionName,
+ const string& argument,
+ vector<string>::const_iterator* argumentIterator,
+ vector<string>::const_iterator argsEnd)
+{
+ if (!interface_.HasOptionRegistered(optionName))
+ throw std::runtime_error("CLI::Parser - unexpected argument " + argument);
+
+ const auto equal = '=';
+ const auto equalPos = argument.find(equal);
+
+ const auto expectsValue = interface_.ExpectsValue(optionName);
+ if (expectsValue) {
+ const auto& optionId = interface_.IdForOptionName(optionName);
+ if (equalPos == string::npos) {
+ ++(*argumentIterator);
+ if (*argumentIterator == argsEnd)
+ throw std::runtime_error("CLI::Parser - missing value after " + argument);
+ results_.RegisterOptionValueString(optionId, *(*argumentIterator));
+ } else
+ results_.RegisterOptionValueString(optionId, argument.substr(equalPos+1));
+ } else {
+ if (equalPos != string::npos)
+ throw std::runtime_error("CLI::Parser - unexpected value after "+argument.substr(0, equalPos));
+ }
+}
+
+} // namespace internal
+} // namespace CLI
+} // namespace PacBio
+
+// ------------------------
+// PacBio::CLI::Parser
+// ------------------------
+
+Parser::Parser(const Interface &interface)
+ : d_(new internal::ParserPrivate{ interface })
+{ }
+
+Parser::Parser(const Parser& other)
+ : d_(new internal::ParserPrivate{*other.d_.get()})
+{ }
+
+Parser::~Parser(void) { }
+
+Results Parser::Parse(const vector<string>& args)
+{
+ d_->Parse(args);
+ return d_->results_;
+}
+
+Results Parser::Parse(int argc, char *argv[])
+{ return Parse(vector<string>{argv, argv + argc}); }
diff --git a/src/cli/Results.cpp b/src/cli/Results.cpp
new file mode 100644
index 0000000..e165f17
--- /dev/null
+++ b/src/cli/Results.cpp
@@ -0,0 +1,197 @@
+#include "pbcopper/cli/Results.h"
+#include "pbcopper/json/JSON.h"
+#include "pbcopper/utility/StringUtils.h"
+#include <unordered_map>
+#include <set>
+#include <vector>
+#include <cassert>
+#include <cstdlib>
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace PacBio::JSON;
+using namespace std;
+
+namespace PacBio {
+namespace CLI {
+namespace internal {
+
+class ResultsPrivate
+{
+public:
+ PacBio::CLI::Interface interface_;
+ vector<string> inputCommandLine_;
+ Json options_;
+ vector<string> positionalArgs_;
+ PacBio::Logging::LogLevel logLevel_;
+ bool isFromRtc_;
+ uint16_t nproc_;
+
+public:
+ ResultsPrivate(const Interface& interface,
+ const vector<string>& inputCommandLine)
+ : interface_(interface)
+ , inputCommandLine_(inputCommandLine)
+ , logLevel_(PacBio::Logging::LogLevel::INFO)
+ , isFromRtc_(false)
+ , nproc_(1)
+ {
+ // init with default values
+ const auto& registeredOptions = interface_.RegisteredOptions();
+ for (const Option& opt : registeredOptions)
+ options_[opt.Id()] = opt.DefaultValue();
+ }
+
+ ResultsPrivate(const ResultsPrivate& other) = default;
+ ~ResultsPrivate(void) = default;
+};
+
+} // namespace internal
+} // namespace CLI
+} // namespace PacBio
+
+// ------------------------
+// PacBio::CLI::Results
+// ------------------------
+
+Results::Results(const Interface& interface)
+ : d_(new internal::ResultsPrivate{ interface, vector<string>() })
+{ }
+
+Results::Results(const Interface& interface,
+ const vector<string>& inputCommandLine)
+ : d_(new internal::ResultsPrivate{ interface, inputCommandLine })
+{ }
+
+Results::Results(const Results& other)
+ : d_(new internal::ResultsPrivate{*other.d_.get()})
+{ }
+
+Results& Results::operator=(const Results& other)
+{
+ d_.reset(new internal::ResultsPrivate{*other.d_.get()});
+ return *this;
+}
+
+Results::~Results(void) { }
+
+string Results::InputCommandLine(void) const
+{
+ return Utility::Join(d_->inputCommandLine_, " ");
+}
+
+bool Results::IsFromRTC(void) const
+{ return d_->isFromRtc_; }
+
+Results& Results::LogLevel(const PacBio::Logging::LogLevel logLevel)
+{
+ d_->logLevel_ = logLevel;
+ return *this;
+}
+
+PacBio::Logging::LogLevel Results::LogLevel(void) const
+{ return d_->logLevel_; }
+
+uint16_t Results::NumProcessors(void) const
+{
+ if (!IsFromRTC()) {
+ throw std::runtime_error("PacBio::CLI::Results - NumProcessors() "
+ "available from resolved tool contract only. "
+ "Use IsFromRTC() to check before calling this "
+ "method.");
+ }
+ return d_->nproc_;
+}
+
+Results& Results::NumProcessors(const uint16_t nproc)
+{ d_->nproc_ = nproc; return *this; }
+
+Results& Results::RegisterOptionValue(const string& optionId,
+ const Json& optionValue)
+{
+ // TODO: make safe access
+ d_->options_[optionId] = optionValue;
+
+ // check user-supplied log level
+ if (d_->interface_.HasLogLevelOptionRegistered()) {
+ const auto logLevelOptionId = d_->interface_.LogLevelOption().Id();
+ if (logLevelOptionId == optionId) {
+ const string logLevelString = optionValue;
+ d_->logLevel_ = PacBio::Logging::LogLevel(logLevelString);
+ }
+ }
+
+ return *this;
+}
+
+Results& Results::RegisterOptionValueString(const string& optionId,
+ const string& optionValue)
+{
+ // TODO: make safe access
+ Json& opt = d_->options_[optionId];
+ switch(opt.type())
+ {
+ case Json::value_t::number_integer : opt = std::strtol(optionValue.c_str(), nullptr, 10); break;
+ case Json::value_t::number_unsigned : opt = std::strtoul(optionValue.c_str(), nullptr, 10); break;
+ case Json::value_t::number_float : opt = std::strtof(optionValue.c_str(), nullptr); break;
+ case Json::value_t::string : opt = optionValue; break;
+ case Json::value_t::boolean : opt = (optionValue == "true"); break;
+ default:
+ throw std::runtime_error("PacBio::CLI::Results - unknown type for option: "+optionId);
+ }
+
+ // check user-supplied log level
+ if (d_->interface_.HasLogLevelOptionRegistered()) {
+ const auto logLevelOptionId = d_->interface_.LogLevelOption().Id();
+ if (logLevelOptionId == optionId) {
+ const string logLevelString = optionValue;
+ d_->logLevel_ = PacBio::Logging::LogLevel(logLevelString);
+ }
+ }
+
+ return *this;
+}
+
+Results& Results::RegisterPositionalArg(const string& posArg)
+{ d_->positionalArgs_.push_back(posArg); return *this; }
+
+Results& Results::SetFromRTC(const bool ok)
+{ d_->isFromRtc_ = ok; return *this; }
+
+const Interface& Results::ApplicationInterface(void) const
+{ return d_->interface_; }
+
+//std::string Results::PositionalArgument(const std::string& posArgName) const
+//{
+// const auto& registeredPosArgs = d_->interface_.RegisteredPositionalArgs();
+// size_t index = 0;
+// for (const PositionalArg& registeredArg : registeredPosArgs) {
+// if (posArgName == registeredArg.name_)
+// return d_->positionalArgs_.at(index);
+// ++index;
+// }
+// throw std::runtime_error("PacBio::CLI::Results - unknown positional arg name: "+posArgName);
+//}
+
+vector<string> Results::PositionalArguments(void) const
+{ return d_->positionalArgs_; }
+
+Results& Results::RegisterObservedOption(const std::string& optionId)
+{
+ // TODO: make safe access
+ Json& opt = d_->options_[optionId];
+ if (opt.is_boolean())
+ opt = true;
+ return *this;
+}
+
+const Results::Result& Results::operator[](const std::string& optionId) const
+{
+ // TODO: make safe access
+ return d_->options_[optionId];
+}
+
+Results::Result& Results::operator[](const std::string& optionId)
+{
+ // TODO: make safe access
+ return d_->options_[optionId];
+}
diff --git a/src/cli/VersionPrinter.cpp b/src/cli/VersionPrinter.cpp
new file mode 100644
index 0000000..c042291
--- /dev/null
+++ b/src/cli/VersionPrinter.cpp
@@ -0,0 +1,12 @@
+#include "pbcopper/cli/VersionPrinter.h"
+#include "pbcopper/cli/Interface.h"
+#include <ostream>
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace std;
+
+void VersionPrinter::Print(const Interface& interface, ostream& out)
+{
+ out << interface.ApplicationName() << " "
+ << interface.ApplicationVersion() << endl;
+}
diff --git a/src/cli/toolcontract/JsonPrinter.cpp b/src/cli/toolcontract/JsonPrinter.cpp
new file mode 100644
index 0000000..aeb6da1
--- /dev/null
+++ b/src/cli/toolcontract/JsonPrinter.cpp
@@ -0,0 +1,242 @@
+#include "pbcopper/cli/toolcontract/JsonPrinter.h"
+#include "pbcopper/cli/Interface.h"
+#include "pbcopper/json/JSON.h"
+#include "pbcopper/utility/EnumClassHash.h"
+#include "pbcopper/utility/Version.h"
+#include <stdexcept>
+#include <unordered_map>
+
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace PacBio::CLI::ToolContract;
+using namespace PacBio::JSON;
+using namespace std;
+
+namespace PacBio {
+
+namespace CLI {
+
+Option RegisteredOption(const Interface& interface, const string& optionId)
+{
+ const auto registeredOptions = interface.RegisteredOptions();
+ for (const Option& opt : registeredOptions) {
+ if (opt.Id() == optionId)
+ return opt;
+ }
+ throw std::runtime_error("PacBio::CLI - could not find option with id: " + optionId);
+}
+
+namespace ToolContract {
+namespace internal {
+
+static Json makeDriverJson(const Interface& interface)
+{
+ const auto& driver = interface.ToolContract().Driver();
+
+ Json driverJson;
+
+ Json envJson = Json::object();
+ const auto env = driver.Env();
+ auto envIter = env.cbegin();
+ const auto envEnd = env.cend();
+ for ( ; envIter != envEnd; ++envIter) {
+ const auto& key = envIter->first;
+ const auto& value = envIter->second;
+ envJson[key] = value;
+ }
+ driverJson["env"] = envJson;
+
+ auto exe = driver.Exe();
+ if (exe.empty())
+ exe = interface.ApplicationName() + " --resolved-tool-contract";
+ driverJson["exe"] = exe;
+
+ auto serialization = driver.Serialization();
+ if (serialization.empty())
+ serialization = "json";
+ driverJson["serialization"] = serialization;
+
+ return driverJson;
+}
+
+static Json makeInputTypesJson(const Interface& interface)
+{
+ Json inputTypesJson = Json::array();
+
+ const auto& task = interface.ToolContract().Task();
+ const auto& inputFileTypes = task.InputFileTypes();
+ for (const InputFileType& file : inputFileTypes) {
+ Json entry = Json::object();
+ entry["title"] = file.Title();
+ entry["id"] = file.Id();
+ entry["file_type_id"] = file.Type();
+ entry["description"] = file.Description();
+ inputTypesJson.push_back(entry);
+ }
+
+ return inputTypesJson;
+}
+
+static Json makeOutputTypesJson(const Interface& interface)
+{
+ Json outputTypesJson = Json::array();
+
+ const auto& task = interface.ToolContract().Task();
+ const auto& outputFileTypes = task.OutputFileTypes();
+ for (const OutputFileType& file : outputFileTypes) {
+ Json entry = Json::object();
+ entry["title"] = file.Title();
+ entry["id"] = file.Id();
+ entry["file_type_id"] = file.Type();
+ entry["default_name"] = file.DefaultName();
+ entry["description"] = file.Description();
+ outputTypesJson.push_back(entry);
+ }
+
+ return outputTypesJson;
+}
+
+static Json makeResourceTypesJson(const ToolContract::Task& task)
+{
+ const unordered_map<ResourceType, string, Utility::EnumClassHash> lookup =
+ {
+ { ResourceType::LOG_FILE, "$logfile" },
+ { ResourceType::TMP_FILE, "$tmpfile" },
+ { ResourceType::TMP_DIR, "$tmpdir" },
+ { ResourceType::OUTPUT_DIR, "$outputdir" }
+ };
+
+ Json resourceTypesJson = Json::array();
+
+ const auto& taskResourceTypes = task.ResourceTypes();
+ for (const auto& t : taskResourceTypes)
+ {
+ const auto found = lookup.find(t);
+ if (found == lookup.cend())
+ throw std::runtime_error("CLI::ToolContract::JsonPrinter - unknown resource type");
+ resourceTypesJson.push_back(found->second);
+ }
+
+ return resourceTypesJson;
+}
+
+static Json makeSchemaOptionsJson(const Interface& interface)
+{
+ Json schemaOptions = Json::array();
+
+ const auto& task = interface.ToolContract().Task();
+ const auto& taskOptions = task.Options();
+
+ const auto optionPrefix = interface.AlternativeToolContractName().empty()
+ ? interface.ApplicationName()
+ : interface.AlternativeToolContractName();
+
+ for (const auto& taskOption : taskOptions) {
+
+ const std::string& optionId = taskOption.first;
+ const std::string& optionDisplayName = taskOption.second;
+ const std::string fullOptionId = optionPrefix + ".task_options." + optionId;
+
+ const Option registeredOption = RegisteredOption(interface, optionId);
+ const std::string optionDescription = registeredOption.Description();
+ const JSON::Json optionDefaultValue = registeredOption.DefaultValue();
+
+ string optionType;
+ switch(optionDefaultValue.type())
+ {
+ case Json::value_t::number_integer : // fall through
+ case Json::value_t::number_unsigned : optionType = "integer"; break;
+ case Json::value_t::number_float : optionType = "number"; break;
+ case Json::value_t::string : optionType = "string"; break;
+ case Json::value_t::boolean : optionType = "boolean"; break;
+ default:
+ throw std::runtime_error("PacBio::CLI::ToolContract::JsonPrinter - unknown type for option: "+optionId);
+ }
+
+ Json pbOption;
+ pbOption["default"] = optionDefaultValue;
+ pbOption["option_id"] = fullOptionId;
+ pbOption["name"] = optionDisplayName;
+ pbOption["description"] = optionDescription;
+ pbOption["type"] = optionType;
+
+ Json schemaOption = Json::object();
+ schemaOption["$schema"] = "http://json-schema.org/draft-04/schema#";
+ schemaOption["type"] = "object";
+ schemaOption["title"] = "JSON Schema for " + fullOptionId;
+
+ schemaOption["pb_option"] = pbOption;
+
+ schemaOption["required"] = Json::array();
+ schemaOption["required"].push_back(fullOptionId);
+
+ schemaOption["properties"] = Json::object();
+ schemaOption["properties"][fullOptionId] = Json::object();
+ schemaOption["properties"][fullOptionId]["default"] = optionDefaultValue;
+ schemaOption["properties"][fullOptionId]["type"] = optionType;
+ schemaOption["properties"][fullOptionId]["description"] = optionDescription;
+ schemaOption["properties"][fullOptionId]["title"] = optionDisplayName;
+
+ schemaOptions.push_back(schemaOption);
+ }
+
+ return schemaOptions;
+}
+
+static std::string makeTaskType(const TaskType& type)
+{
+ switch(type)
+ {
+ case TaskType::STANDARD : return "pbsmrtpipe.task_types.standard";
+ case TaskType::GATHERED : return "pbsmrtpipe.task_types.gathered";
+ case TaskType::SCATTERED : return "pbsmrtpipe.task_types.scattered";
+ default:
+ throw std::runtime_error("CLI::ToolContract::JsonPrinter - unknown task type");
+ }
+}
+
+static Json makeTaskJson(const Interface& interface)
+{
+ const auto& task = interface.ToolContract().Task();
+
+ Json tcJson;
+ tcJson["_comment"] = "Created by v" + Utility::LibraryVersionString();
+ tcJson["description"] = interface.ApplicationDescription();
+ tcJson["name"] = interface.ApplicationName();
+
+ const auto numProcessors = task.NumProcessors();
+ if (numProcessors == Task::MAX_NPROC)
+ tcJson["nproc"] = "$max_nproc";
+ else
+ tcJson["nproc"] = numProcessors;
+
+ tcJson["is_distributed"] = task.IsDistributed();
+ tcJson["tool_contract_id"] = task.TaskId();
+
+ tcJson["task_type"] = internal::makeTaskType(task.Type());
+ tcJson["input_types"] = internal::makeInputTypesJson(interface);
+ tcJson["output_types"] = internal::makeOutputTypesJson(interface);
+ tcJson["resource_types"] = internal::makeResourceTypesJson(task);
+ tcJson["schema_options"] = internal::makeSchemaOptionsJson(interface);
+
+ return tcJson;
+}
+
+} // namespace internal
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+void JsonPrinter::Print(const Interface& interface,
+ ostream& out,
+ const int indent)
+{
+ // build up JSON object from @interface
+ Json result;
+ result["driver"] = internal::makeDriverJson(interface);
+ result["tool_contract"] = internal::makeTaskJson(interface);
+ result["tool_contract_id"] = interface.ToolContract().Task().TaskId();
+ result["version"] = interface.ApplicationVersion();
+
+ out << result.dump(indent);
+}
diff --git a/src/cli/toolcontract/ResolvedToolContract.cpp b/src/cli/toolcontract/ResolvedToolContract.cpp
new file mode 100644
index 0000000..d4e8ddb
--- /dev/null
+++ b/src/cli/toolcontract/ResolvedToolContract.cpp
@@ -0,0 +1,107 @@
+#include "pbcopper/cli/toolcontract/ResolvedToolContract.h"
+
+#include "pbcopper/json/JSON.h"
+#include "pbcopper/utility/StringUtils.h"
+
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace PacBio::CLI::ToolContract;
+using namespace PacBio::JSON;
+using namespace std;
+
+namespace PacBio {
+namespace CLI {
+namespace ToolContract {
+namespace internal {
+
+class RtcPrivate
+{
+
+public:
+ const Interface interface_;
+
+public:
+ RtcPrivate(const Interface& interface)
+ : interface_(interface)
+ { }
+};
+
+
+} // namespace internal
+} // namespace ToolContract
+} // namespace CLI
+} // namespace PacBio
+
+ResolvedToolContract::ResolvedToolContract(const Interface& interface)
+ : d_(new internal::RtcPrivate{ interface })
+{ }
+
+ResolvedToolContract::~ResolvedToolContract(void) { }
+
+Results ResolvedToolContract::Parse(istream& in)
+{
+ const auto& interface = d_->interface_;
+ const auto& task = interface.ToolContract().Task();
+
+ Results results{ d_->interface_ };
+ results.SetFromRTC(true);
+
+ Json root(in);
+ Json rtc = root["resolved_tool_contract"];
+
+ // options (object)
+ const Json options = rtc["options"];
+ for (auto iter = options.cbegin(); iter != options.cend(); ++iter) {
+
+ const auto& fullId = iter.key();
+ const Json& value = iter.value();
+
+ const auto idFields = PacBio::Utility::Split(fullId, '.');
+ if (idFields.size() != 3)
+ throw std::runtime_error("PacBio::CLI - unexpected option ID format: "+fullId);
+ const auto optionId = idFields.at(2);
+
+ results.RegisterOptionValue(optionId, value);
+ }
+
+ // log_level
+ const Json log_level = rtc["log_level"];
+ const string logLevelString = log_level;
+ results.LogLevel(PacBio::Logging::LogLevel{logLevelString});
+
+ // nproc
+ const Json nproc = rtc["nproc"];
+ results.NumProcessors(nproc);
+
+ // input file (array)
+ const Json inputFiles = rtc["input_files"];
+ const auto inputFilesToOptions = task.InputFilesToOptions();
+ const auto inputFilesToOptionsEnd = inputFilesToOptions.cend();
+ for (size_t i = 0; i < inputFiles.size(); ++i) {
+ const auto inputFile = inputFiles.at(i);
+ const auto inputFilesToOptionsIter = inputFilesToOptions.find(i);
+ if (inputFilesToOptionsIter == inputFilesToOptionsEnd)
+ results.RegisterPositionalArg(inputFile);
+ else {
+ const auto optionId = inputFilesToOptionsIter->second;
+ results.RegisterOptionValue(optionId, inputFile);
+ }
+ }
+
+ // output file (array)
+ const Json outputFiles = rtc["output_files"];
+ const auto outputFilesToOptions = task.OutputFilesToOptions();
+ const auto outputFilesToOptionsEnd = outputFilesToOptions.cend();
+ for (size_t i = 0; i < outputFiles.size(); ++i) {
+ const auto outputFile = outputFiles.at(i);
+ const auto outputFilesToOptionsIter = outputFilesToOptions.find(i);
+ if (outputFilesToOptionsIter == outputFilesToOptionsEnd)
+ results.RegisterPositionalArg(outputFile);
+ else {
+ const auto optionId = outputFilesToOptionsIter->second;
+ results.RegisterOptionValue(optionId, outputFile);
+ }
+ }
+
+ return results;
+}
diff --git a/src/data/MovieName.cpp b/src/data/MovieName.cpp
new file mode 100644
index 0000000..93a048e
--- /dev/null
+++ b/src/data/MovieName.cpp
@@ -0,0 +1,51 @@
+#include "pbcopper/data/MovieName.h"
+using namespace PacBio;
+using namespace PacBio::Data;
+using namespace std;
+
+MovieName::MovieName(const std::string& instrumentName,
+ const std::string& runStartTime)
+ : partsCache_(nullptr)
+{
+ // construct name from parts
+ auto result = string{ };
+ result.reserve(128);
+ result += "m";
+ result += instrumentName;
+ result += "_";
+ result += runStartTime;
+ movieName_ = result;
+ // don't update cache until actually requested
+}
+
+void MovieName::UpdatePartsCache(void) const
+{
+ // sanity checks
+ assert(partsCache_ == nullptr);
+ if (movieName_.empty())
+ return;
+
+ // calculate name parts
+ const char underscore = '_';
+ const size_t firstUnderscore = movieName_.find(underscore);
+
+ const char* movieCStr = movieName_.c_str();
+ const char* nameStart = movieCStr + 1;
+ const char* rstStart = movieCStr + firstUnderscore + 1; // skip '_'
+ const size_t nameSize = (firstUnderscore - 1);
+ const size_t rstSize = (movieName_.size() - firstUnderscore) - 1; // skip '\0 '
+
+ // cache name parts
+ partsCache_.reset(new PartsCache
+ {
+ boost::string_ref{ nameStart, nameSize }, // instrumentName
+ boost::string_ref{ rstStart, rstSize } // runStartTime
+ });
+
+ // checks - here? or elsewhere?
+ if (partsCache_->instrumentName_.empty())
+ throw runtime_error("MovieName: instrument name must not be empty");
+ if (partsCache_->runStartTime_.empty())
+ throw runtime_error("MovieName: run start time must not be empty");
+
+}
diff --git a/src/data/RSMovieName.cpp b/src/data/RSMovieName.cpp
new file mode 100644
index 0000000..288a65b
--- /dev/null
+++ b/src/data/RSMovieName.cpp
@@ -0,0 +1,79 @@
+#include "pbcopper/data/RSMovieName.h"
+using namespace PacBio;
+using namespace PacBio::Data;
+using namespace std;
+
+RSMovieName::RSMovieName(const std::string& runStartTime,
+ const std::string& instrumentSerialNumber,
+ const std::string& smrtCellBarcode,
+ const std::string& setNumber,
+ const std::string& partNumber)
+ : partsCache_(nullptr)
+{
+ // construct name from parts
+ auto result = string{ };
+ result.reserve(128);
+ result += "m";
+ result += runStartTime;
+ result += "_";
+ result += instrumentSerialNumber;
+ result += "_";
+ result += smrtCellBarcode;
+ result += "_";
+ result += setNumber;
+ result += "_";
+ result += partNumber;
+ movieName_ = result;
+
+ // don't update cache until actually requested
+}
+
+void RSMovieName::UpdatePartsCache(void) const
+{
+ // sanity checks
+ assert(partsCache_ == nullptr);
+ if (movieName_.empty())
+ return;
+
+ // calculate name parts
+ const char underscore = '_';
+ const size_t firstUnderscore = movieName_.find(underscore);
+ const size_t secondUnderscore = movieName_.find(underscore, firstUnderscore+1);
+ const size_t thirdUnderscore = movieName_.find(underscore, secondUnderscore+1);
+ const size_t fourthUnderscore = movieName_.find(underscore, thirdUnderscore+1);
+ const size_t fifthUnderscore = movieName_.find(underscore, fourthUnderscore+1);
+
+ const char* movieCStr = movieName_.c_str();
+ const char* rstStart = movieCStr + 1; // skip 'm' and include first '_'
+ const char* serialNumStart = movieCStr + secondUnderscore + 1; // skip '_'
+ const char* scbStart = movieCStr + thirdUnderscore + 1; // skip '_'
+ const char* setNumStart = movieCStr + fourthUnderscore + 1; // skip '_'
+ const char* partNumStart = movieCStr + fifthUnderscore + 1; // skip '_'
+ const size_t rstSize = (secondUnderscore - 1);
+ const size_t serialNumSize = (thirdUnderscore - secondUnderscore) - 1; // skip '_'
+ const size_t scbSize = (fourthUnderscore - thirdUnderscore) - 1; // skip '_'
+ const size_t setNumSize = (fifthUnderscore - fourthUnderscore) - 1; // skip '_'
+ const size_t partNumSize = (movieName_.size() - fifthUnderscore) - 1; // skip '\0 '
+
+ // cache name parts
+ partsCache_.reset(new RSMovieName::PartsCache
+ {
+ boost::string_ref{ rstStart, rstSize }, // runStartTime
+ boost::string_ref{ serialNumStart, serialNumSize }, // serialNumber
+ boost::string_ref{ scbStart, scbSize }, // smrtCellBarcode
+ boost::string_ref{ setNumStart, setNumSize }, // setNumber
+ boost::string_ref{ partNumStart, partNumSize }, // partNumber
+ });
+
+ // checks - here? or elsewhere?
+ if (partsCache_->runStartTime_.empty())
+ throw runtime_error("RSMovieName: run start time must not be empty");
+ if (partsCache_->serialNumber_.empty())
+ throw runtime_error("RSMovieName: instrument serial number must not be empty");
+ if (partsCache_->smrtCellBarcode_.empty())
+ throw runtime_error("RSMovieName: SMRT cell barcode must not be empty");
+ if (partsCache_->setNumber_.empty())
+ throw runtime_error("RSMovieName: set number must not be empty");
+ if (partsCache_->partNumber_.empty())
+ throw runtime_error("RSMovieName: part number must not be empty");
+ }
diff --git a/src/files.cmake b/src/files.cmake
new file mode 100644
index 0000000..9f8e0a3
--- /dev/null
+++ b/src/files.cmake
@@ -0,0 +1,143 @@
+
+set(pbcopper_H
+
+ # -------
+ # global
+ # -------
+
+ ${pbcopper_IncludeDir}/pbcopper/Config.h
+ ${CMAKE_BINARY_DIR}/generated/pbcopper/utility/Version.h
+
+ # -------
+ # cli
+ # -------
+
+ ${pbcopper_IncludeDir}/pbcopper/cli/CLI.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/HelpPrinter.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/Interface.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/Option.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/Parser.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/PositionalArg.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/Results.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/SingleDashMode.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/VersionPrinter.h
+
+ ${pbcopper_IncludeDir}/pbcopper/cli/internal/Option-inl.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/internal/Results-inl.h
+
+ # ------------------
+ # cli/toolcontract
+ # ------------------
+
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/Config.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/Driver.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/InputFileType.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/OutputFileType.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/JsonPrinter.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/ResolvedToolContract.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/ResourceType.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/Task.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/TaskType.h
+
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/internal/Config-inl.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/internal/Driver-inl.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/internal/InputFileType-inl.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/internal/OutputFileType-inl.h
+ ${pbcopper_IncludeDir}/pbcopper/cli/toolcontract/internal/Task-inl.h
+
+ # -------
+ # data
+ # -------
+
+ ${pbcopper_IncludeDir}/pbcopper/data/CCSTag.h
+ ${pbcopper_IncludeDir}/pbcopper/data/Interval.h
+ ${pbcopper_IncludeDir}/pbcopper/data/MovieName.h
+ ${pbcopper_IncludeDir}/pbcopper/data/Position.h
+ ${pbcopper_IncludeDir}/pbcopper/data/ReadName.h
+ ${pbcopper_IncludeDir}/pbcopper/data/RSMovieName.h
+ ${pbcopper_IncludeDir}/pbcopper/data/RSReadName.h
+ ${pbcopper_IncludeDir}/pbcopper/data/Zmw.h
+
+ ${pbcopper_IncludeDir}/pbcopper/data/internal/Interval-inl.h
+ ${pbcopper_IncludeDir}/pbcopper/data/internal/MovieName-inl.h
+ ${pbcopper_IncludeDir}/pbcopper/data/internal/ReadNameBase.h
+ ${pbcopper_IncludeDir}/pbcopper/data/internal/ReadNameBase-inl.h
+ ${pbcopper_IncludeDir}/pbcopper/data/internal/RSMovieName-inl.h
+
+ # -------
+ # JSON
+ # -------
+
+ ${pbcopper_IncludeDir}/pbcopper/json/JSON.h
+
+ ${pbcopper_IncludeDir}/pbcopper/json/internal/json.hpp
+
+ # -------
+ # logging
+ # -------
+
+ ${pbcopper_IncludeDir}/pbcopper/logging/Logging.h
+ ${pbcopper_IncludeDir}/pbcopper/logging/internal/Logging-inl.h
+
+ # -------
+ # stream
+ # -------
+
+ ${pbcopper_IncludeDir}/pbcopper/stream/Stream.h
+
+ # -------
+ # utility
+ # -------
+
+ ${pbcopper_IncludeDir}/pbcopper/utility/CallbackTimer.h
+ ${pbcopper_IncludeDir}/pbcopper/utility/EnumClassHash.h
+ ${pbcopper_IncludeDir}/pbcopper/utility/Stopwatch.h
+ ${pbcopper_IncludeDir}/pbcopper/utility/StringUtils.h
+ ${pbcopper_IncludeDir}/pbcopper/utility/SystemInfo.h
+
+ ${pbcopper_IncludeDir}/pbcopper/utility/internal/CallbackTimer-inl.h
+ ${pbcopper_IncludeDir}/pbcopper/utility/internal/Stopwatch-inl.h
+ ${pbcopper_IncludeDir}/pbcopper/utility/internal/StringUtils-inl.h
+ ${pbcopper_IncludeDir}/pbcopper/utility/internal/SystemInfo-inl.h
+)
+
+set(pbcopper_CPP
+
+ # -------
+ # cli
+ # -------
+
+ ${pbcopper_SourceDir}/cli/CLI.cpp
+ ${pbcopper_SourceDir}/cli/HelpPrinter.cpp
+ ${pbcopper_SourceDir}/cli/Interface.cpp
+ ${pbcopper_SourceDir}/cli/Option.cpp
+ ${pbcopper_SourceDir}/cli/Parser.cpp
+ ${pbcopper_SourceDir}/cli/Results.cpp
+ ${pbcopper_SourceDir}/cli/VersionPrinter.cpp
+
+ # ------------------
+ # cli/toolcontract
+ # ------------------
+
+ ${pbcopper_SourceDir}/cli/toolcontract/JsonPrinter.cpp
+ ${pbcopper_SourceDir}/cli/toolcontract/ResolvedToolContract.cpp
+
+ # -------
+ # data
+ # -------
+
+ ${pbcopper_SourceDir}/data/MovieName.cpp
+ ${pbcopper_SourceDir}/data/RSMovieName.cpp
+
+ # ---------
+ # logging
+ # ---------
+
+ ${pbcopper_SourceDir}/logging/Logging.cpp
+
+ # ---------
+ # utility
+ # ---------
+
+ ${pbcopper_SourceDir}/utility/CallbackTimer.cpp
+)
diff --git a/src/logging/Logging.cpp b/src/logging/Logging.cpp
new file mode 100644
index 0000000..30aa544
--- /dev/null
+++ b/src/logging/Logging.cpp
@@ -0,0 +1,235 @@
+#include "pbcopper/logging/Logging.h"
+
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+#include <csignal>
+#include <ctime>
+using namespace PacBio;
+using namespace PacBio::Logging;
+
+namespace PacBio {
+namespace Logging {
+namespace internal {
+
+const char* LogLevelRepr(LogLevel level)
+{
+ // by specification these are all of length 10
+ switch (level) {
+ case LogLevel::TRACE: return "TRACE ";
+ case LogLevel::DEBUG: return "DEBUG ";
+ case LogLevel::INFO: return "INFO ";
+ case LogLevel::NOTICE: return "NOTICE ";
+ case LogLevel::WARN: return "WARN ";
+ case LogLevel::ERROR: return "ERROR ";
+ case LogLevel::CRITICAL: return "CRITICAL ";
+ case LogLevel::FATAL: return "FATAL ";
+ default: return "OTHER ";
+ }
+}
+
+LogLevel LogLevelFromString(const std::string& level)
+{
+ if (level == "TRACE") return LogLevel::TRACE;
+ if (level == "DEBUG") return LogLevel::DEBUG;
+ if (level == "INFO") return LogLevel::INFO;
+ if (level == "NOTICE") return LogLevel::NOTICE;
+ if (level == "ERROR") return LogLevel::ERROR;
+ if (level == "CRITICAL") return LogLevel::CRITICAL;
+ if (level == "FATAL") return LogLevel::FATAL;
+ if (level == "WARN" || level == "WARNING")
+ return LogLevel::WARN;
+
+ throw std::invalid_argument("invalid log level");
+}
+
+} // namespace internal
+
+void InstallSignalHandlers(Logger& logger)
+{
+ using std::raise;
+ using std::signal;
+
+ static Logger& logger_ = logger;
+
+ // catch in-flight exceptions on terminate
+ std::set_terminate([]() {
+ if (auto eptr = std::current_exception()) {
+ try {
+ std::rethrow_exception(eptr);
+ } catch (const std::exception& e) {
+ PBLOGGER_FATAL(logger_) << "caught exception: \"" << e.what() << '"';
+ } catch (...) {
+ PBLOGGER_FATAL(logger_) << "caught unknown exception type";
+ }
+ }
+ // call the SIGABRT handler (below)
+ std::abort();
+ });
+
+ // register signal handlers that log and then re-raise as normal
+
+ signal(SIGABRT, [](int) {
+ {
+ PBLOGGER_FATAL(logger_) << "caught SIGABRT";
+ }
+ logger_.~Logger();
+ signal(SIGABRT, SIG_DFL);
+ raise(SIGABRT);
+ });
+ signal(SIGINT, [](int) {
+ {
+ PBLOGGER_FATAL(logger_) << "caught SIGINT";
+ }
+ logger_.~Logger();
+ signal(SIGINT, SIG_DFL);
+ raise(SIGINT);
+ });
+ signal(SIGSEGV, [](int) {
+ {
+ PBLOGGER_FATAL(logger_) << "caught SIGSEGV";
+ }
+ logger_.~Logger();
+ signal(SIGSEGV, SIG_DFL);
+ raise(SIGSEGV);
+ });
+ signal(SIGTERM, [](int) {
+ {
+ PBLOGGER_FATAL(logger_) << "caught SIGTERM";
+ }
+ logger_.~Logger();
+ signal(SIGTERM, SIG_DFL);
+ raise(SIGTERM);
+ });
+}
+
+} // namespace Logging
+} // namespace PacBio
+
+LogLevel::LogLevel(const std::string& value)
+ : value_{ internal::LogLevelFromString(value) }
+{ }
+
+Logger::~Logger(void)
+{
+ if (!writer_.joinable())
+ throw std::runtime_error("this logger is already dead!");
+
+ // place a terminal sentinel for MessageWriter to know it's done
+ {
+ std::lock_guard<std::mutex> g(m_);
+ queue_.emplace(std::unique_ptr<LogLevelStream>());
+ }
+ pushed_.notify_all();
+
+ // wait for everything to be flushed
+ {
+ std::unique_lock<std::mutex> lk(m_);
+ popped_.wait(lk, [this]() { return queue_.empty(); });
+ // endl implicitly flushes, so no need to call os_.flush() here
+ }
+
+ // join writer thread
+ writer_.join();
+}
+
+Logger& Logger::operator<<(std::unique_ptr<LogLevelStream>&& ptr)
+{
+ if (!writer_.joinable())
+ throw std::runtime_error("this logger is dead!");
+ {
+ std::lock_guard<std::mutex> g(m_);
+ queue_.emplace(std::forward<std::unique_ptr<LogLevelStream>>(ptr));
+ }
+ pushed_.notify_all();
+ return *this;
+}
+
+Logger& Logger::Default(Logger* logger)
+{
+ static std::unique_ptr<Logger> logger_(new Logger(std::cerr));
+ if (logger) logger_.reset(logger);
+ return *logger_;
+}
+
+void Logger::MessageWriter(void)
+{
+ while (true) {
+ std::unique_ptr<LogLevelStream> ptr;
+
+ // wait on messages to arrive in the queue_, and pop them off
+ {
+ std::unique_lock<std::mutex> lk(m_);
+ pushed_.wait(lk, [&ptr, this]() {
+ if (queue_.empty())
+ return false;
+ ptr = std::move(queue_.front());
+ queue_.pop();
+ return true;
+ });
+ }
+
+ // if we've reached the null terminator, notify flush and stop
+ if (!ptr) {
+ popped_.notify_all();
+ break;
+ }
+
+ // otherwise, push the message onto os_
+ const LogLevel level = std::get<0>(*ptr);
+ if (cfg_.find(level) != cfg_.end()) {
+ for (const auto& os : cfg_.at(level))
+ os.get() << std::get<1>(*ptr).str() << std::endl;
+ }
+
+ // and notify flush we delivered a message to os_,
+ popped_.notify_all();
+ }
+}
+
+LogMessage::LogMessage(const char* file,
+ const char* function,
+ unsigned int line,
+ const LogLevel level,
+ Logger& logger)
+ : logger_(logger)
+{
+ using std::chrono::duration_cast;
+ using std::chrono::milliseconds;
+ using std::chrono::seconds;
+ using std::chrono::system_clock;
+
+ if (!logger_.Handles(level))
+ return;
+
+ ptr_.reset(new Logger::LogLevelStream(std::piecewise_construct,
+ std::forward_as_tuple(level),
+ std::forward_as_tuple()));
+
+ static const char* delim = " -|- ";
+
+ // get the time, separated into seconds and milliseconds
+ const auto now = system_clock::now();
+ const auto secs = duration_cast<seconds>(now.time_since_epoch());
+ const auto time = system_clock::to_time_t(system_clock::time_point(secs));
+ const auto msec = duration_cast<milliseconds>(now.time_since_epoch() - secs).count();
+
+ // format the time and print out the log header to the ostringstream
+ // TODO(lhepler) make this std::put_time when we move to gcc-5
+ char buf[20];
+ std::strftime(buf, 20, "%Y%m%d %T.", std::gmtime(&time));
+
+ std::get<1>(*ptr_) << ">|> " << buf << std::setfill('0') << std::setw(3)
+ << std::to_string(msec) << delim << internal::LogLevelRepr(level) << delim
+ << function
+#ifndef NDEBUG
+ << " at " << file << ':' << line
+#endif
+ << delim << std::hex << std::showbase << std::this_thread::get_id()
+ << std::noshowbase << std::dec << "||" << delim;
+
+#ifdef NDEBUG
+ UNUSED(file);
+ UNUSED(line);
+#endif
+}
diff --git a/src/utility/CallbackTimer.cpp b/src/utility/CallbackTimer.cpp
new file mode 100644
index 0000000..181e03b
--- /dev/null
+++ b/src/utility/CallbackTimer.cpp
@@ -0,0 +1,138 @@
+
+#include "pbcopper/utility/CallbackTimer.h"
+
+using namespace PacBio;
+using namespace PacBio::Utility;
+
+namespace PacBio {
+namespace Utility {
+
+// Implementation inspired from:
+// http://codereview.stackexchange.com/questions/40473/portable-periodic-one-shot-timer-implementation
+
+namespace internal {
+
+typedef std::chrono::steady_clock CallbackTimerClock;
+typedef std::chrono::time_point<CallbackTimerClock> CallbackTimerTimePoint;
+typedef std::chrono::milliseconds CallbackTimerDuration;
+typedef std::unique_lock<std::mutex> CallbackTimerMutexLocker;
+
+CallbackTimer::JobId CallbackTimerPrivate::ScheduleImpl(CallbackTimerJob&& item)
+{
+ CallbackTimerMutexLocker lock(sync);
+ item.id = nextId++;
+ auto iter = activeJobs.emplace(item.id, std::move(item));
+ queue.insert(iter.first->second);
+ wakeUp.notify_all();
+ return item.id;
+}
+
+bool CallbackTimerPrivate::Cancel(const CallbackTimer::JobId id)
+{
+ CallbackTimerMutexLocker lock(sync);
+ auto i = activeJobs.find(id);
+ if (i == activeJobs.end())
+ return false;
+ else if (i->second.running)
+ {
+ // A callback is in progress for this Instance,
+ // so flag it for deletion in the worker
+ i->second.running = false;
+ }
+ else
+ {
+ queue.erase(std::ref(i->second));
+ activeJobs.erase(i);
+ }
+
+ wakeUp.notify_all();
+ return true;
+}
+
+// this is our main thread worker, processing the job queue & calling the
+// callback functions
+//
+void CallbackTimerPrivate::Run(void)
+{
+ CallbackTimerMutexLocker lock(sync);
+ while (!done)
+ {
+ if (queue.empty())
+ {
+ // Wait (forever) for work
+ wakeUp.wait(lock);
+ }
+ else
+ {
+ auto firstJob = queue.begin();
+ CallbackTimerJob& instance = *firstJob;
+ auto now = CallbackTimerClock::now();
+ if (now >= instance.next)
+ {
+ queue.erase(firstJob);
+
+ // Mark it as running to handle racing destroy
+ instance.running = true;
+
+ // Call the handler
+ lock.unlock();
+ instance.handler();
+ lock.lock();
+
+ if (done)
+ {
+ break;
+ }
+ else if (!instance.running)
+ {
+ // Running was set to false, destroy was called
+ // for this Instance while the callback was in progress
+ // (this thread was not holding the lock during the callback)
+ activeJobs.erase(instance.id);
+ }
+ else
+ {
+ instance.running = false;
+
+ // If it is periodic, schedule a new one
+ if (instance.period.count() > 0)
+ {
+ instance.next = instance.next + instance.period;
+ queue.insert(instance);
+ } else {
+ activeJobs.erase(instance.id);
+ }
+ }
+ } else {
+ // Wait until the timer is ready or a timer creation notifies
+ wakeUp.wait_until(lock, instance.next);
+ }
+ }
+ }
+}
+
+// shared timer for single-requests
+static std::unique_ptr<CallbackTimer> singleShotTimer = nullptr;
+
+// mutex for protecting its initialization
+static std::mutex singleShotSync;
+
+} // namespace internal
+} // namespace Utility
+} // namespace PacBio
+
+void CallbackTimer::SingleShot(uint64_t when, const HandlerFn &handler)
+{
+ internal::CallbackTimerMutexLocker lock(internal::singleShotSync);
+ if (!internal::singleShotTimer)
+ internal::singleShotTimer.reset(new CallbackTimer);
+ internal::singleShotTimer->Schedule(when, 0, handler);
+}
+
+void CallbackTimer::SingleShot(uint64_t when, HandlerFn &&handler)
+{
+ internal::CallbackTimerMutexLocker lock(internal::singleShotSync);
+ if (!internal::singleShotTimer)
+ internal::singleShotTimer.reset(new CallbackTimer);
+ internal::singleShotTimer->Schedule(when, 0, std::move(handler));
+}
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
new file mode 100644
index 0000000..d55de6f
--- /dev/null
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,64 @@
+
+# GTest dependency
+find_package(Threads REQUIRED)
+
+# add pbcopper, pbcopper test, & GoogleTest include dirs
+include_directories(
+ ${pbcopper_INCLUDE_DIRS}
+ ${pbcopper_TestsDir}/include
+ ${pbcopper_ThirdPartyDir}/googletest
+)
+
+# grab unit test source files
+include(files.cmake)
+set(SOURCES
+ ${pbcopperTest_H}
+ ${pbcopperTest_CPP}
+)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${pbcopper_CXX_FLAGS}")
+
+# define unit test exe
+add_definitions(-DPBCOPPER_TESTING)
+add_executable(test_pbcopper EXCLUDE_FROM_ALL ${SOURCES})
+set_target_properties(test_pbcopper
+ PROPERTIES
+ RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin
+)
+target_link_libraries(test_pbcopper
+ ${pbcopper_LIBRARIES}
+ ${CMAKE_THREAD_LIBS_INIT}
+)
+
+# add unit tests exe to CTest framework
+add_test(
+ NAME PbcopperUnitTests
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin
+ COMMAND test_pbcopper
+)
+
+# add 'make check' for easy 'build & run tests'
+set(verbose_ctest_command ctest -VV)
+add_custom_target(check COMMAND ${verbose_ctest_command})
+add_dependencies(check
+ # list all explicitly to get re-compile on any changes to lib or tests
+ test_pbcopper
+ pbcopper
+)
+
+# add 'make check-quiet' for 'make check' w/ simple pass/fail summary
+add_custom_target(check-quiet COMMAND ${CMAKE_CTEST_COMMAND})
+add_dependencies(check-quiet
+ # list all explicitly to get re-compile on any changes to lib or tests
+ test_pbcopper
+ pbcopper
+)
+
+# add 'make check-xunit' for 'make check' w/ XUnit output (on Bamboo)
+add_custom_target(check-xunit
+ COMMAND test_pbcopper --gtest_output=xml:${CMAKE_BINARY_DIR}/pbcopper-unit.xml
+)
+add_dependencies(check-xunit
+ # list all explicitly to get re-compile on any changes to lib or tests
+ test_pbcopper
+ pbcopper
+)
diff --git a/tests/files.cmake b/tests/files.cmake
new file mode 100644
index 0000000..d4a7a3e
--- /dev/null
+++ b/tests/files.cmake
@@ -0,0 +1,44 @@
+# test case headers
+set( pbcopperTest_H
+
+ ${pbcopper_TestsDir}/include/OStreamRedirector.h
+)
+
+# test case source files
+set( pbcopperTest_CPP
+
+ # GoogleTest
+ ${pbcopper_ThirdPartyDir}/googletest/gmock-gtest-all.cc
+ ${pbcopper_ThirdPartyDir}/googletest/gmock-gtest-main.cc
+
+ # cli
+ ${pbcopper_TestsDir}/src/cli/test_CLI.cpp
+ ${pbcopper_TestsDir}/src/cli/test_HelpPrinter.cpp
+ ${pbcopper_TestsDir}/src/cli/test_Interface.cpp
+ ${pbcopper_TestsDir}/src/cli/test_Option.cpp
+ ${pbcopper_TestsDir}/src/cli/test_ResolvedToolContract.cpp
+ ${pbcopper_TestsDir}/src/cli/test_Results.cpp
+ ${pbcopper_TestsDir}/src/cli/test_ToolContractJsonPrinter.cpp
+ ${pbcopper_TestsDir}/src/cli/test_VersionPrinter.cpp
+
+ # data
+ ${pbcopper_TestsDir}/src/data/test_Interval.cpp
+ ${pbcopper_TestsDir}/src/data/test_MovieName.cpp
+ ${pbcopper_TestsDir}/src/data/test_ReadName.cpp
+ ${pbcopper_TestsDir}/src/data/test_RSMovieName.cpp
+ ${pbcopper_TestsDir}/src/data/test_RSReadName.cpp
+
+ # JSON
+ ${pbcopper_TestsDir}/src/json/test_JSON.cpp
+
+ # logging
+ ${pbcopper_TestsDir}/src/logging/test_Logging.cpp
+
+ # stream
+ ${pbcopper_TestsDir}/src/stream/test_Stream.cpp
+
+ # utility
+ ${pbcopper_TestsDir}/src/utility/test_CallbackTimer.cpp
+ ${pbcopper_TestsDir}/src/utility/test_Stopwatch.cpp
+ ${pbcopper_TestsDir}/src/utility/test_SystemInfo.cpp
+)
diff --git a/tests/include/OStreamRedirector.h b/tests/include/OStreamRedirector.h
new file mode 100644
index 0000000..942f7a1
--- /dev/null
+++ b/tests/include/OStreamRedirector.h
@@ -0,0 +1,51 @@
+#ifndef PBCOPPER_TESTS_OSTREAMREDIRECTOR_H
+#define PBCOPPER_TESTS_OSTREAMREDIRECTOR_H
+
+#include <iostream>
+
+namespace tests {
+
+//
+// Redirects specified stream into some newBuffer, restoring the normal stream
+// on destruction
+//
+struct OStreamRedirect
+{
+public:
+ OStreamRedirect(std::ostream& o,
+ std::streambuf* newBuffer)
+ : s_(o)
+ , oldBuffer_(o.rdbuf())
+ { o.rdbuf(newBuffer); }
+
+ virtual ~OStreamRedirect(void)
+ { s_.rdbuf(oldBuffer_); }
+
+private:
+ std::ostream& s_;
+ std::streambuf* oldBuffer_;
+};
+
+// Convenience OStreamRedirect for std::cout
+//
+struct CoutRedirect : public OStreamRedirect
+{
+public:
+ CoutRedirect(std::streambuf* newBuffer)
+ : OStreamRedirect(std::cout, newBuffer)
+ { }
+};
+
+// Convenience OStreamRedirect for std::cerr
+//
+struct CerrRedirect : public OStreamRedirect
+{
+public:
+ CerrRedirect(std::streambuf* newBuffer)
+ : OStreamRedirect(std::cerr, newBuffer)
+ { }
+};
+
+} // namespace tests
+
+#endif // PBCOPPER_TESTS_OSTREAMREDIRECTOR_H
diff --git a/tests/src/cli/test_CLI.cpp b/tests/src/cli/test_CLI.cpp
new file mode 100644
index 0000000..98a3e69
--- /dev/null
+++ b/tests/src/cli/test_CLI.cpp
@@ -0,0 +1,433 @@
+
+#include "OStreamRedirector.h"
+
+#include <pbcopper/cli/CLI.h>
+#include <pbcopper/json/JSON.h>
+#include <gtest/gtest.h>
+#include <fstream>
+#include <iostream>
+#include <vector>
+#include <cstdio>
+
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace PacBio::JSON;
+using namespace std;
+
+namespace PacBio {
+namespace CLI {
+namespace tests {
+
+static string appName(void)
+{
+ static const string appName = "frobber";
+ return appName;
+}
+
+static PacBio::CLI::Interface makeInterface(void)
+{
+ Interface i {
+ "frobber",
+ "Frobb your files in a most delightful, nobbly way",
+ "3.14"
+ };
+ i.AddHelpOption(); // use built-in help option
+ i.AddLogLevelOption(); // use built-in logLevel option
+ i.AddVersionOption(); // use built-in version option
+
+ i.AddOptions({
+ {"target_dir", {"t", "target-dir"}, "Copy all source files into <DIR>.", Option::StringType("my/default/dir")},
+ {"force", {"f", "force"}, "Overwrite things."},
+ {"progress", {"p"}, "Show progress during copy."},
+ {"dry_run", {"n", "no-op"}, "Dry run. Report actions that would be taken but do not perform them"},
+ {"timeout", {"timeout"}, "Abort execution after <INT> milliseconds.", Option::IntType(5000)}
+ });
+
+ i.AddPositionalArguments({
+ {"source", "Source file to copy.", "FILE" },
+ {"dest", "Destination directory.", "FILE" }
+ });
+
+ return i;
+}
+
+static PacBio::CLI::Interface makeToolContractEnabledInterface(void)
+{
+ using namespace ToolContract;
+
+ // yields <PREFIX>.pbsmrtpipe_task_options.<ID>
+ // if not set, PREFIX=ApplicationName from Interface
+ //
+ ToolContract::Task tcTask("frobber_task"); // if empty, pulss ApplicationName
+ tcTask.Description("task-specific description"); // if empty, pulls ApplicationDescription
+ tcTask.NumProcessors(4); // max_nproc if not provided
+ tcTask.SetDistributed(true);
+ tcTask.Type(TaskType::STANDARD);
+
+ tcTask.Options({
+
+ //
+ // ID display name
+ //
+ {"progress", "Show Progress"},
+ {"force", "Force Overwrite"},
+ {"timeout", "Timeout"}
+ });
+ tcTask.InputFileTypes({
+ { "ID", "title", "description", "type" },
+ { "ID", "title", "description", "type" }
+ });
+ tcTask.OutputFileTypes({
+ { "ID", "title", "description", "type", "defaultName" },
+ { "ID", "title", "description", "type", "defaultName" }
+ });
+ tcTask.ResourceTypes({
+ ResourceType::TMP_DIR,
+ ResourceType::TMP_FILE,
+ ResourceType::TMP_FILE
+ });
+
+ ToolContract::Config config{tcTask};
+ config.Version("0.1"); // if empty, pulls ApplicationVersion
+
+ auto interface = makeInterface();
+ interface.EnableToolContract(config);
+ return interface;
+}
+
+struct MyAppSettings
+{
+ bool force_;
+ bool showProgress_;
+ string targetDir_;
+ int timeout_;
+ string source_;
+ string dest_;
+ vector<string> extras_;
+};
+
+static int mainAppEntry(const MyAppSettings& settings)
+{
+ // doing testing checks here, but this is where application would get
+ // rocking with its (probably already-existing) 'settings' object
+ // filled out with desired parameters
+ //
+ EXPECT_TRUE(settings.force_);
+ EXPECT_FALSE(settings.showProgress_);
+ EXPECT_EQ(string("/path/to/dir/"), settings.targetDir_);
+ EXPECT_EQ(42, settings.timeout_);
+ EXPECT_EQ(string("requiredIn"), settings.source_);
+ EXPECT_EQ(string("requiredOut"), settings.dest_);
+ return EXIT_SUCCESS;
+}
+
+static int appRunner(const PacBio::CLI::Results& args)
+{
+ // pull CLI results (whether user-supplied OR resolved tool contract) &
+ // convert to the 'settings' object that most applications use for this
+ // kind of thing
+ //
+ MyAppSettings s;
+ s.force_ = args["force"];
+ s.showProgress_ = args["progress"];
+ s.targetDir_ = args["target_dir"];
+ s.timeout_ = args["timeout"];
+
+ EXPECT_EQ(PacBio::Logging::LogLevel::DEBUG, args.LogLevel());
+
+ const vector<string> positionalArgs = args.PositionalArguments();
+ EXPECT_EQ(2, positionalArgs.size());
+ s.source_ = positionalArgs.at(0);
+ s.dest_ = positionalArgs.at(1);
+ return mainAppEntry(s);
+}
+
+static int inputCommandLineChecker(const PacBio::CLI::Results& results)
+{
+ const string expectedCommandLine =
+ {
+ "frobber -f --timeout=42 --target-dir /path/to/dir/ --logLevel=DEBUG requiredIn requiredOut"
+ };
+ EXPECT_EQ(expectedCommandLine, results.InputCommandLine());
+ return EXIT_SUCCESS;
+}
+
+struct RtcGenerator
+{
+public:
+ RtcGenerator(const std::string& fn);
+ ~RtcGenerator(void);
+private:
+ std::string fn_;
+};
+
+} // namespace tests
+} // namespace CLI
+} // namespace PacBio
+
+TEST(CLI_Runner, emits_tool_contract_when_requested_from_command_line)
+{
+ // check cout output
+ const auto expectedText = R"({
+ "driver": {
+ "env": {},
+ "exe": "frobber --resolved-tool-contract",
+ "serialization": "json"
+ },
+ "tool_contract": {
+ "_comment": "Created by v0.0.1",
+ "description": "Frobb your files in a most delightful, nobbly way",
+ "input_types": [
+ {
+ "description": "description",
+ "file_type_id": "type",
+ "id": "ID",
+ "title": "title"
+ },
+ {
+ "description": "description",
+ "file_type_id": "type",
+ "id": "ID",
+ "title": "title"
+ }
+ ],
+ "is_distributed": true,
+ "name": "frobber",
+ "nproc": 4,
+ "output_types": [
+ {
+ "default_name": "defaultName",
+ "description": "description",
+ "file_type_id": "type",
+ "id": "ID",
+ "title": "title"
+ },
+ {
+ "default_name": "defaultName",
+ "description": "description",
+ "file_type_id": "type",
+ "id": "ID",
+ "title": "title"
+ }
+ ],
+ "resource_types": [
+ "$tmpdir",
+ "$tmpfile",
+ "$tmpfile"
+ ],
+ "schema_options": [
+ {
+ "$schema": "http://json-schema.org/draft-04/schema#",
+ "pb_option": {
+ "default": false,
+ "description": "Overwrite things.",
+ "name": "Force Overwrite",
+ "option_id": "frobber.task_options.force",
+ "type": "boolean"
+ },
+ "properties": {
+ "frobber.task_options.force": {
+ "default": false,
+ "description": "Overwrite things.",
+ "title": "Force Overwrite",
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "frobber.task_options.force"
+ ],
+ "title": "JSON Schema for frobber.task_options.force",
+ "type": "object"
+ },
+ {
+ "$schema": "http://json-schema.org/draft-04/schema#",
+ "pb_option": {
+ "default": false,
+ "description": "Show progress during copy.",
+ "name": "Show Progress",
+ "option_id": "frobber.task_options.progress",
+ "type": "boolean"
+ },
+ "properties": {
+ "frobber.task_options.progress": {
+ "default": false,
+ "description": "Show progress during copy.",
+ "title": "Show Progress",
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "frobber.task_options.progress"
+ ],
+ "title": "JSON Schema for frobber.task_options.progress",
+ "type": "object"
+ },
+ {
+ "$schema": "http://json-schema.org/draft-04/schema#",
+ "pb_option": {
+ "default": 5000,
+ "description": "Abort execution after <INT> milliseconds.",
+ "name": "Timeout",
+ "option_id": "frobber.task_options.timeout",
+ "type": "integer"
+ },
+ "properties": {
+ "frobber.task_options.timeout": {
+ "default": 5000,
+ "description": "Abort execution after <INT> milliseconds.",
+ "title": "Timeout",
+ "type": "integer"
+ }
+ },
+ "required": [
+ "frobber.task_options.timeout"
+ ],
+ "title": "JSON Schema for frobber.task_options.timeout",
+ "type": "object"
+ }
+ ],
+ "task_type": "pbsmrtpipe.task_types.standard",
+ "tool_contract_id": "frobber_task"
+ },
+ "tool_contract_id": "frobber_task",
+ "version": "3.14"
+})";
+
+ // redirect cout to our catcher
+ std::stringstream s;
+ ::tests::CoutRedirect redirect(s.rdbuf());
+ (void)redirect;
+
+ // set up tool contract emitted from main CLI entry
+ const vector<string> args =
+ {
+ PacBio::CLI::tests::appName(),
+ "--emit-tool-contract"
+ };
+ PacBio::CLI::Run(args,
+ PacBio::CLI::tests::makeToolContractEnabledInterface(),
+ &PacBio::CLI::tests::appRunner);
+ EXPECT_EQ(expectedText, s.str());
+}
+
+TEST(CLI_Runner, runs_application_from_vector_of_args)
+{
+ const vector<string> args =
+ {
+ PacBio::CLI::tests::appName(),
+ "-f",
+ "--timeout=42",
+ "--target-dir", "/path/to/dir/",
+ "--logLevel=DEBUG",
+ "requiredIn",
+ "requiredOut"
+ };
+ PacBio::CLI::Run(args,
+ PacBio::CLI::tests::makeInterface(),
+ &PacBio::CLI::tests::appRunner);
+}
+
+TEST(CLI_Runner, runs_application_from_C_style_args)
+{
+ SCOPED_TRACE("run from normal args - raw C char*, a la application main()");
+
+ static const int argc = 7;
+ char* argv[argc+1];
+ argv[0] = const_cast<char*>("frobber");
+ argv[1] = const_cast<char*>("-f");
+ argv[2] = const_cast<char*>("--timeout=42");
+ argv[3] = const_cast<char*>("--target-dir=/path/to/dir/");
+ argv[4] = const_cast<char*>("--logLevel=DEBUG");
+ argv[5] = const_cast<char*>("requiredIn");
+ argv[6] = const_cast<char*>("requiredOut");
+ argv[7] = nullptr;
+
+ PacBio::CLI::Run(argc, argv,
+ PacBio::CLI::tests::makeInterface(),
+ &PacBio::CLI::tests::appRunner);
+}
+
+TEST(CLI_Runner, can_retrieve_input_commandline)
+{
+ SCOPED_TRACE("checking input command line");
+ const vector<string> args =
+ {
+ PacBio::CLI::tests::appName(),
+ "-f",
+ "--timeout=42",
+ "--target-dir", "/path/to/dir/",
+ "--logLevel=DEBUG",
+ "requiredIn",
+ "requiredOut"
+ };
+ PacBio::CLI::Run(args,
+ PacBio::CLI::tests::makeInterface(),
+ &PacBio::CLI::tests::inputCommandLineChecker);
+}
+
+TEST(CLI_Runner, runs_application_from_resolved_tool_contract)
+{
+ SCOPED_TRACE("run from RTC args");
+
+ const string& rtcFn = "/tmp/pbcopper.cli.runner.resolved-tool-contract.json";
+ PacBio::CLI::tests::RtcGenerator rtc(rtcFn);
+ (void)rtc;
+
+ const vector<string> args =
+ {
+ PacBio::CLI::tests::appName(),
+ "--resolved-tool-contract",
+ rtcFn
+ };
+ PacBio::CLI::Run(args,
+ PacBio::CLI::tests::makeToolContractEnabledInterface(),
+ &PacBio::CLI::tests::appRunner);
+}
+
+namespace PacBio {
+namespace CLI {
+namespace tests {
+
+RtcGenerator::RtcGenerator(const std::string& fn)
+ : fn_(fn)
+{
+ auto text = R"(
+{
+ "driver": {
+ "env": {},
+ "exe": "frobber --resolved-tool-contract",
+ "serialization": "json"
+ },
+ "resolved_tool_contract": {
+ "input_files": [
+ "requiredIn"
+ ],
+ "nproc": 1,
+ "options": {
+ "frobber.task_options.force": true,
+ "frobber.task_options.timeout": 42,
+ "frobber.task_options.target_dir": "/path/to/dir/"
+ },
+ "output_files": [
+ "requiredOut"
+ ],
+ "resources": [],
+ "is_distributed": false,
+ "task_type": "pbsmrtpipe.task_types.standard",
+ "tool_contract_id": "frobber_task",
+ "log_level": "DEBUG"
+ }
+})";
+
+ std::ofstream out(fn);
+ EXPECT_TRUE(static_cast<bool>(out));
+ out << text;
+}
+
+RtcGenerator::~RtcGenerator(void)
+{ ::remove(fn_.c_str()); }
+
+} // namespace tests
+} // namespace CLI
+} // namespace PacBio
+
diff --git a/tests/src/cli/test_HelpPrinter.cpp b/tests/src/cli/test_HelpPrinter.cpp
new file mode 100644
index 0000000..43a5171
--- /dev/null
+++ b/tests/src/cli/test_HelpPrinter.cpp
@@ -0,0 +1,59 @@
+#include <pbcopper/cli/HelpPrinter.h>
+
+#include <pbcopper/cli/Interface.h>
+#include <gtest/gtest.h>
+#include <vector>
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace std;
+
+TEST(CLI_HelpPrinter, prints_expected_help_output)
+{
+ Interface i {
+ "frobber",
+ "Frobb your files in a most delightful, nobbly way",
+ "3.14"
+ };
+
+ // common built-ins - ON by default ?
+ i.AddHelpOption();
+ i.AddVerboseOption();
+ i.AddVersionOption();
+ i.AddOptions({
+ {"progress", {"p"}, "Show progress during copy."},
+ {"force", {"f", "force"}, "Overwrite things." },
+ {"target_dir", {"t", "target-dir"}, "Copy all source files into <DIR>.", Option::StringType("my/default/dir")},
+ {"timeout", {"timeout"}, "Abort execution after <INT> milliseconds.", Option::IntType(5000)},
+ {"modelPath", {"M", "modelPath"}, "Path to a model file.", Option::StringType("")} // empty default string should be omitted from help
+ });
+ i.AddPositionalArguments({
+ {"source", "Source file to copy."},
+ {"dest", "Destination directory."},
+ {"extras", "Extra stuff to pass in here, optionally.", "[extras...]"}
+ });
+
+ const string expectedText = {
+ "Usage: frobber [options] source dest [extras...]\n"
+ "Frobb your files in a most delightful, nobbly way\n"
+ "\n"
+ "Options: \n"
+ " -h,--help Output this help.\n"
+ " -v,--verbose Use verbose output.\n"
+ " --version Output version info.\n"
+ " -p Show progress during copy.\n"
+ " -f,--force Overwrite things.\n"
+ " -t,--target-dir Copy all source files into <DIR>. [\"my/default/dir\"]\n"
+ " --timeout Abort execution after <INT> milliseconds. [5000]\n"
+ " -M,--modelPath Path to a model file.\n"
+ "\n"
+ "Arguments: \n"
+ " source Source file to copy.\n"
+ " dest Destination directory.\n"
+ " extras Extra stuff to pass in here, optionally.\n"
+ "\n"
+ };
+
+ stringstream s;
+ HelpPrinter::Print(i, s);
+ EXPECT_EQ(expectedText, s.str());
+}
diff --git a/tests/src/cli/test_Interface.cpp b/tests/src/cli/test_Interface.cpp
new file mode 100644
index 0000000..55b9b39
--- /dev/null
+++ b/tests/src/cli/test_Interface.cpp
@@ -0,0 +1,195 @@
+
+#include <pbcopper/cli/Interface.h>
+#include <gtest/gtest.h>
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace std;
+
+namespace PacBio {
+namespace CLI {
+namespace tests {
+
+static inline string AppName(void)
+{
+ static const string appName = "frobber";
+ return appName;
+}
+
+static inline string AppDescription(void)
+{
+ static const string appDesc = "does the frobbing";
+ return appDesc;
+}
+
+static inline string AppVersion(void)
+{
+ static const string appVersion = "3.14";
+ return appVersion;
+}
+
+static bool HasOption(const Interface& i, const string& name)
+{
+ const auto options = i.RegisteredOptions();
+ for (auto&& option : options) {
+ const auto aliases = option.Names();
+ for (auto&& alias : aliases) {
+ if (alias == name)
+ return true;
+ }
+ }
+ return false;
+}
+
+} // namespace tests
+} // namespace CLI
+} // namespace PacBio
+
+TEST(CLI_Interface, can_be_constructed_from_name_only)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ EXPECT_EQ(tests::AppName(), cl.ApplicationName());
+ EXPECT_TRUE(cl.ApplicationDescription().empty());
+ EXPECT_TRUE(cl.ApplicationVersion().empty());
+}
+
+TEST(CLI_Interface, can_be_constructed_from_name_and_description)
+{
+ PacBio::CLI::Interface cl{ tests::AppName(), tests::AppDescription() };
+ EXPECT_EQ(tests::AppName(), cl.ApplicationName());
+ EXPECT_EQ(tests::AppDescription(), cl.ApplicationDescription());
+ EXPECT_TRUE(cl.ApplicationVersion().empty());
+}
+
+TEST(CLI_Interface, can_be_constructed_from_name_description_and_version)
+{
+ PacBio::CLI::Interface cl{ tests::AppName(), tests::AppDescription(), tests::AppVersion() };
+ EXPECT_EQ(tests::AppName(), cl.ApplicationName());
+ EXPECT_EQ(tests::AppDescription(), cl.ApplicationDescription());
+ EXPECT_EQ(tests::AppVersion(), cl.ApplicationVersion());
+}
+
+TEST(CLI_Interface, construction_with_empty_name_throws)
+{
+ EXPECT_THROW(PacBio::CLI::Interface{""}, std::runtime_error);
+}
+
+TEST(CLI_Interface, add_single_option_with_a_single_alias)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ cl.AddOption({"opt_id","o", "write output"});//, "outFile", "default"});
+
+ const auto registered = cl.RegisteredOptions();
+ EXPECT_EQ(1, registered.size());
+ EXPECT_EQ(vector<string>({"o"}), registered.at(0).Names());
+}
+
+TEST(CLI_Interface, add_single_option_with_multiple_aliases)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ cl.AddOption({"opt_id", {"o", "output"}, "write output"});//, "outFile", "default"});
+
+ const auto registered = cl.RegisteredOptions();
+ EXPECT_EQ(1, registered.size());
+ EXPECT_EQ(vector<string>({"o", "output"}), registered.at(0).Names());
+}
+
+TEST(CLI_Interface, add_multiple_options_one_at_a_time)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ cl.AddOption({"opt_id", {"o", "output"}, "write output"});//, "outFile", "defaultOut"});
+ cl.AddOption({"opt_id2", {"i", "input"}, "write input"});//, "inFile", "defaultIn"});
+
+ const auto registered = cl.RegisteredOptions();
+ EXPECT_EQ(2, registered.size());
+ EXPECT_EQ(vector<string>({"o", "output"}), registered.at(0).Names());
+ EXPECT_EQ(vector<string>({"i", "input"}), registered.at(1).Names());
+}
+
+TEST(CLI_Interface, add_multple_options_as_batch)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ cl.AddOptions({
+ {"opt_id", {"o", "output"}, "write output"},//, "outFile", "defaultOut"},
+ {"opt_id2", {"i", "input"}, "write input"} //, "inFile", "defaultIn"}
+ });
+
+ const auto registered = cl.RegisteredOptions();
+ EXPECT_EQ(2, registered.size());
+ EXPECT_EQ(vector<string>({"o", "output"}), registered.at(0).Names());
+ EXPECT_EQ(vector<string>({"i", "input"}), registered.at(1).Names());
+}
+
+TEST(CLI_Interface, add_single_positional_arg)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ cl.AddPositionalArgument({"source", "Source file to copy."});
+
+ const auto registered = cl.RegisteredPositionalArgs();
+ EXPECT_EQ(1, registered.size());
+ EXPECT_EQ(string{"source"}, registered.at(0).name_);
+}
+
+TEST(CLI_Interface, add_multiple_positional_args_one_at_a_time)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ cl.AddPositionalArgument({"source", "Source file to copy."});
+ cl.AddPositionalArgument({"dest", "Target destination"});
+
+ const auto registered = cl.RegisteredPositionalArgs();
+ EXPECT_EQ(2, registered.size());
+ EXPECT_EQ(string{"source"}, registered.at(0).name_);
+ EXPECT_EQ(string{"dest"}, registered.at(1).name_);
+}
+
+TEST(CLI_Interface, add_multiple_positional_args_as_batch)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ cl.AddPositionalArguments({
+ {"source", "Source file to copy."},
+ {"dest", "Target destination"}
+ });
+
+ const auto registered = cl.RegisteredPositionalArgs();
+ EXPECT_EQ(2, registered.size());
+ EXPECT_EQ(string{"source"}, registered.at(0).name_);
+ EXPECT_EQ(string{"dest"}, registered.at(1).name_);
+}
+
+TEST(CLI_Interface, does_not_have_help_option_by_default)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ EXPECT_FALSE(tests::HasOption(cl, "help"));
+}
+
+TEST(CLI_Interface, has_help_option_if_requested)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ cl.AddHelpOption();
+ EXPECT_TRUE(tests::HasOption(cl, "help"));
+}
+
+TEST(CLI_Interface, does_not_have_verbose_option_by_default)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ EXPECT_FALSE(tests::HasOption(cl, "verbose"));
+}
+
+TEST(CLI_Interface, has_verbose_option_if_requested)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ cl.AddVerboseOption();
+ EXPECT_TRUE(tests::HasOption(cl, "verbose"));
+}
+
+TEST(CLI_Interface, does_not_have_version_option_by_default)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ EXPECT_FALSE(tests::HasOption(cl, "version"));
+}
+
+TEST(CLI_Interface, has_version_option_if_requested)
+{
+ PacBio::CLI::Interface cl{ tests::AppName() };
+ cl.AddVersionOption();
+ EXPECT_TRUE(tests::HasOption(cl, "version"));
+}
diff --git a/tests/src/cli/test_Option.cpp b/tests/src/cli/test_Option.cpp
new file mode 100644
index 0000000..c8750f8
--- /dev/null
+++ b/tests/src/cli/test_Option.cpp
@@ -0,0 +1,162 @@
+
+#include <pbcopper/cli/Option.h>
+#include <gtest/gtest.h>
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace std;
+
+TEST(CLI_Option, minimal_ctor_single_alias)
+{
+ Option opt{"opt_id", "o", ""};
+ EXPECT_EQ(string("opt_id"), opt.Id());
+ EXPECT_EQ(vector<string>{"o"}, opt.Names());
+ EXPECT_FALSE(opt.DefaultValue());
+ EXPECT_TRUE(opt.Description().empty());
+// EXPECT_TRUE(opt.ValueName().empty());
+// EXPECT_FALSE(opt.IsHidden());
+}
+
+TEST(CLI_Option, can_be_constructed_from_name_list_only)
+{
+ Option opt{"opt_id", {"o", "output"}, "" };
+ EXPECT_EQ(string("opt_id"), opt.Id());
+ const vector<string> expected{"o", "output"};
+ EXPECT_EQ(expected, opt.Names());
+ EXPECT_FALSE(opt.DefaultValue());
+ EXPECT_TRUE(opt.Description().empty());
+// EXPECT_TRUE(opt.ValueName().empty());
+// EXPECT_FALSE(opt.IsHidden());
+}
+
+TEST(CLI_Option, can_be_constructed_from_name_and_extra_info)
+{
+ Option opt{"opt_id", "o", "write data to <file>", Option::StringType("default.txt") };
+ EXPECT_EQ(string("opt_id"), opt.Id());
+ EXPECT_EQ(vector<string>{"o"}, opt.Names());
+ EXPECT_EQ(string{"default.txt"}, opt.DefaultValue());
+ EXPECT_EQ(string{ "write data to <file>"}, opt.Description());
+// EXPECT_FALSE(opt.IsHidden());
+}
+
+TEST(CLI_Option, can_be_constructed_from_name_list_and_extra_info)
+{
+ Option opt{"opt_id", {"o", "output"}, "write data to <file>", Option::StringType("default.txt") };
+ const vector<string> expected{"o", "output"};
+ EXPECT_EQ(expected, opt.Names());
+ EXPECT_EQ(string{"default.txt"}, opt.DefaultValue());
+ EXPECT_EQ(string{ "write data to <file>"}, opt.Description());
+// EXPECT_EQ(string{"file"}, opt.ValueName());
+}
+
+TEST(CLI_Option, rejects_empty_id)
+{
+ EXPECT_THROW(Option("", "name", "descr"), std::runtime_error);
+ EXPECT_THROW(Option("", vector<string>{"name"}, "descr"), std::runtime_error);
+}
+
+TEST(CLI_Option, rejects_empty_names)
+{
+ EXPECT_THROW(Option("opt_id", "", "descrip"), std::runtime_error);
+ EXPECT_THROW(Option("opt_id", vector<string>{}, "descr"), std::runtime_error);
+}
+
+TEST(CLI_Option, rejects_names_beginning_with_dash)
+{
+ EXPECT_THROW(Option("opt_id", "-o", "desc"), std::runtime_error);
+ EXPECT_THROW(Option("opt_id", {"o", "-b"}, ""), std::runtime_error);
+}
+
+TEST(CLI_Option, rejects_names_beginning_with_slash)
+{
+ EXPECT_THROW(Option("opt_id", "/A", ""), std::runtime_error);
+ EXPECT_THROW(Option("opt_id", {"o", "/X"}, ""), std::runtime_error);
+}
+
+TEST(CLI_Option, rejects_names_containing_equal)
+{
+ EXPECT_THROW(Option("opt_id", "foo=bar", ""), std::runtime_error);
+ EXPECT_THROW(Option("opt_id", {"o", "foo=bar"}, "" ), std::runtime_error);
+}
+
+TEST(CLI_Option, can_be_copy_constructed)
+{
+ Option original{"opt_id", "o", "write data to <file>", Option::StringType("default.txt")};
+ Option copy(original);
+
+ EXPECT_EQ(original.Names(), copy.Names());
+ EXPECT_EQ(original.DefaultValue(), copy.DefaultValue());
+ EXPECT_EQ(original.Description(), copy.Description());
+// EXPECT_EQ(original.ValueName(), copy.ValueName());
+// EXPECT_EQ(original.IsHidden(), copy.IsHidden());
+}
+
+TEST(CLI_Option, can_be_copy_assigned)
+{
+ Option original{"opt_id", "o", "write data to <file>", Option::StringType("default.txt")};
+ Option copy("opt_id2", "dummy", "");
+ copy = original;
+
+ EXPECT_EQ(original.Names(), copy.Names());
+ EXPECT_EQ(original.DefaultValue(), copy.DefaultValue());
+ EXPECT_EQ(original.Description(), copy.Description());
+// EXPECT_EQ(original.ValueName(), copy.ValueName());
+// EXPECT_EQ(original.IsHidden(), copy.IsHidden());
+}
+
+TEST(CLI_Option, can_be_move_constructed)
+{
+ Option original{"opt_id", "o", "write data to <file>", Option::StringType("default.txt")};
+ Option destination(std::move(original));
+
+ // ensure new option matches original's values (we can't touch original now)
+ EXPECT_EQ(vector<string>{"o"}, destination.Names());
+ EXPECT_EQ(string{"default.txt"}, destination.DefaultValue());
+ EXPECT_EQ(string{ "write data to <file>"}, destination.Description());
+// EXPECT_EQ(string{"file"}, destination.ValueName());
+// EXPECT_FALSE(destination.IsHidden());
+}
+
+TEST(CLI_Option, can_be_move_assigned)
+{
+ Option original{"opt_id", "o", "write data to <file>", Option::StringType("default.txt")};
+ Option destination("opt_id2", "dummy", "");
+ destination = std::move(original);
+
+ // ensure new option matches original's values (we can't touch original now)
+ EXPECT_EQ(vector<string>{"o"}, destination.Names());
+ EXPECT_EQ(string{"default.txt"}, destination.DefaultValue());
+ EXPECT_EQ(string{ "write data to <file>"}, destination.Description());
+// EXPECT_EQ(string{"file"}, destination.ValueName());
+// EXPECT_FALSE(destination.IsHidden());
+}
+
+TEST(CLI_Option, expected_defaults)
+{
+ // help
+ const auto help = Option::DefaultHelpOption();
+ EXPECT_EQ("help", help.Id());
+ EXPECT_EQ(vector<string>({"h", "help"}), help.Names());
+ EXPECT_EQ("Output this help.", help.Description());
+ EXPECT_FALSE(help.DefaultValue());
+
+ // log level
+ const auto logLevel = Option::DefaultLogLevelOption();
+ EXPECT_EQ("log_level", logLevel.Id());
+ EXPECT_EQ(vector<string>({"log-level", "logLevel"}), logLevel.Names());
+ EXPECT_EQ("Set log level.", logLevel.Description());
+ EXPECT_EQ("INFO", logLevel.DefaultValue());
+
+ // verbose
+ const auto verbose = Option::DefaultVerboseOption();
+ EXPECT_EQ("verbose", verbose.Id());
+ EXPECT_EQ(vector<string>({"v", "verbose"}), verbose.Names());
+ EXPECT_EQ("Use verbose output.", verbose.Description());
+ EXPECT_FALSE(verbose.DefaultValue());
+
+ // version
+ const auto version = Option::DefaultVersionOption();
+ EXPECT_EQ("version", version.Id());
+ EXPECT_EQ(vector<string>({"version"}), version.Names());
+ EXPECT_EQ("Output version info.", version.Description());
+ EXPECT_FALSE(version.DefaultValue());
+}
diff --git a/tests/src/cli/test_ResolvedToolContract.cpp b/tests/src/cli/test_ResolvedToolContract.cpp
new file mode 100644
index 0000000..dceedae
--- /dev/null
+++ b/tests/src/cli/test_ResolvedToolContract.cpp
@@ -0,0 +1,164 @@
+#include <pbcopper/cli/toolcontract/ResolvedToolContract.h>
+#include <gtest/gtest.h>
+
+#include <sstream>
+#include <string>
+
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace PacBio::CLI::ToolContract;
+using namespace std;
+
+TEST(CLI_ResolvedToolContract, read_basic_RTC)
+{
+ auto text = R"(
+{
+ "driver": {
+ "env": {},
+ "exe": "python -m pbcommand.cli.example.dev_app --resolved-tool-contract "
+ },
+ "resolved_tool_contract": {
+ "input_files": [],
+ "nproc": 4,
+ "options": {
+ "pbcommand.task_options.max_nlines": 27
+ },
+ "output_files": [],
+ "resources": [],
+ "is_distributed": false,
+ "task_type": "pbsmrtpipe.task_types.standard",
+ "tool_contract_id": "frobber.tools.dev_app",
+ "log_level": "WARN"
+ }
+}
+ )";
+
+ stringstream input;
+ input << text;
+
+ Interface interface {
+ "frobber",
+ "Frobb your files in a most delightful, nobbly way",
+ "3.14"
+ };
+ interface.AddOptions({
+ {"max_nlines", {"n"}, "Max Number of lines to Copy", Option::IntType(10)}
+ });
+
+ const string id = "frobber.tasks.dev_txt_app";
+ ToolContract::Task tcTask(id);
+ tcTask.Options({
+ { "max_nlines", "Max Lines" }
+ });
+
+ ToolContract::Config tcConfig(tcTask);
+ interface.EnableToolContract(tcConfig);
+
+ ToolContract::ResolvedToolContract rtc(interface);
+ const Results results = rtc.Parse(input);
+
+ const int maxNLines = results["max_nlines"];
+ EXPECT_EQ(27, maxNLines);
+ EXPECT_EQ(PacBio::Logging::LogLevel::WARN, results.LogLevel());
+ EXPECT_EQ(4, results.NumProcessors());
+}
+
+TEST(CLI_ResolvedToolContract, map_files_to_options)
+{
+ auto text = R"(
+{
+ "driver": {
+ "env": {},
+ "exe": "python -m pbcommand.cli.example.dev_app --resolved-tool-contract "
+ },
+ "resolved_tool_contract": {
+ "input_files": [
+ "/path/to/subreads_file.txt"
+ ],
+ "nproc": 2,
+ "options": {
+ "pbcommand.task_options.min_length": 25,
+ "pbcommand.task_options.max_length": 500
+ },
+ "output_files": [
+ "/path/to/output_file.txt",
+ "/path/to/junk_file.txt",
+ "/path/to/report_file.txt",
+ "/path/to/json_file.txt"
+
+ ],
+ "resources": [],
+ "is_distributed": false,
+ "task_type": "pbsmrtpipe.task_types.standard",
+ "tool_contract_id": "frobber.tools.dev_app",
+ "log_level": "WARN"
+ }
+}
+ )";
+
+ stringstream input;
+ input << text;
+
+ Interface interface {
+ "frobber",
+ "Frobb your files in a most delightful, nobbly way",
+ "3.14"
+ };
+ interface.AddOptions({
+ {"min_length", {"minLength"}, "Minimum length.", Option::IntType(10)},
+ {"max_length", {"maxLength"}, "Maximum length.", Option::IntType(1000)},
+ {"output_file", {"resultFile"}, "Output file.", Option::StringType("")},
+ {"junk_file", {"junkFile"}, "Junk file.", Option::StringType("")},
+ {"report_file", {"reportFile"}, "Report file.", Option::StringType("")},
+ {"json_file", {"jsonFile"}, "JSON file.", Option::StringType("")},
+ });
+
+ const string id = "frobber.tasks.dev_txt_app";
+ ToolContract::Task tcTask(id);
+ tcTask.Options({
+ { "min_length", "Minimum Length" },
+ { "max_length", "Maximum Length" },
+ });
+ tcTask.InputFileTypes({
+ { "input_file", "Input File", "Generic Txt file", "PacBio.FileTypes.txt" }
+ });
+ tcTask.OutputFileTypes({
+ { "output_file", "Output File", "Output file.", "PacBio.FileTypes.txt", "output" },
+ { "junk_file", "Junk File", "Junk file.", "PacBio.FileTypes.txt", "junk" },
+ { "report_file", "Report File", "Report file.", "PacBio.FileTypes.txt", "report" },
+ { "json_file", "JSON File", "JSON file.", "PacBio.FileTypes.txt", "json" }
+ });
+ tcTask.OutputFilesToOptions({
+ { 0, "output_file" },
+ { 1, "junk_file" },
+ { 2, "report_file" },
+ { 3, "json_file" },
+ });
+
+ ToolContract::Config tcConfig(tcTask);
+ interface.EnableToolContract(tcConfig);
+
+ ToolContract::ResolvedToolContract rtc(interface);
+ const Results results = rtc.Parse(input);
+
+ const int minLength = results["min_length"];
+ const int maxLength = results["max_length"];
+ const string outputFile = results["output_file"];
+ const string reportFile = results["report_file"];
+ const string junkFile = results["junk_file"];
+ const string jsonFile = results["json_file"];
+
+ const auto positionalArgs = results.PositionalArguments();
+ EXPECT_EQ(1, positionalArgs.size());
+ const string inputFile = positionalArgs.at(0);
+
+ EXPECT_EQ(25, minLength);
+ EXPECT_EQ(500, maxLength);
+ EXPECT_EQ("/path/to/output_file.txt", outputFile);
+ EXPECT_EQ("/path/to/report_file.txt", reportFile);
+ EXPECT_EQ("/path/to/junk_file.txt", junkFile);
+ EXPECT_EQ("/path/to/json_file.txt", jsonFile);
+ EXPECT_EQ("/path/to/subreads_file.txt", inputFile);
+
+ EXPECT_EQ(2, results.NumProcessors());
+}
diff --git a/tests/src/cli/test_Results.cpp b/tests/src/cli/test_Results.cpp
new file mode 100644
index 0000000..0ccb931
--- /dev/null
+++ b/tests/src/cli/test_Results.cpp
@@ -0,0 +1,74 @@
+
+#include <pbcopper/cli/Results.h>
+#include <gtest/gtest.h>
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace std;
+
+namespace PacBio {
+namespace CLI {
+namespace tests {
+
+static PacBio::CLI::Interface makeInterface(void)
+{
+ Interface i {
+ "frobber",
+ "Frobb your files in a most delightful, nobbly way",
+ "3.14"
+ };
+
+ // common built-ins - ON by default ?
+ i.AddHelpOption();
+ i.AddVerboseOption();
+ i.AddVersionOption();
+
+ i.AddOptions({
+ {"progress", "p", "Show progress during copy."},
+ {"force", {"f", "force"}, "Overwrite things." },
+ {"target_dir", {"t", "target-dir"}, "Copy all source files into <DIR>.", Option::StringType("my/default/dir")},
+ {"timeout", "timeout", "Abort execution after <INT> milliseconds.", Option::IntType(5000)}
+ });
+ i.AddPositionalArguments({
+ {"source", "Source file to copy."},
+ {"dest", "Destination directory."},
+ {"extras", "Extra stuff to pass in here, optionally.", "[extras...]"}
+ });
+
+ return i;
+}
+
+} // namespace tests
+} // namespace CLI
+} // namespace PacBio
+
+TEST(CLI_Results, option_default_values_respected)
+{
+ Results r{ tests::makeInterface() };
+ EXPECT_FALSE(r["force"]);
+ EXPECT_FALSE(r["timeout"].empty()); // has a default
+ EXPECT_TRUE(r.PositionalArguments().empty());
+}
+
+TEST(CLI_Results, add_observed_option_value)
+{
+ Results r{ tests::makeInterface() };
+ r.RegisterOptionValue("timeout", "42");
+ EXPECT_EQ(string("42"), r["timeout"]);
+}
+
+TEST(CLI_Results, adding_positional_args)
+{
+ Results r{ tests::makeInterface() };
+ r.RegisterPositionalArg("source_file")
+ .RegisterPositionalArg("dest_file");
+
+ // lookup by index
+ const auto& resultPositionalArgs = r.PositionalArguments();
+ EXPECT_EQ(2, resultPositionalArgs.size());
+ EXPECT_EQ(string("source_file"), resultPositionalArgs.at(0));
+ EXPECT_EQ(string("dest_file"), resultPositionalArgs.at(1));
+
+// // lookup by name (order-independent at this point)
+// EXPECT_EQ(string("dest_file"), r.PositionalArgument("dest"));
+// EXPECT_EQ(string("source_file"), r.PositionalArgument("source"));
+}
diff --git a/tests/src/cli/test_ToolContractJsonPrinter.cpp b/tests/src/cli/test_ToolContractJsonPrinter.cpp
new file mode 100644
index 0000000..1581c3c
--- /dev/null
+++ b/tests/src/cli/test_ToolContractJsonPrinter.cpp
@@ -0,0 +1,229 @@
+#include <pbcopper/cli/toolcontract/JsonPrinter.h>
+#include <pbcopper/cli/Interface.h>
+#include <gtest/gtest.h>
+
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace PacBio::CLI::ToolContract;
+using namespace std;
+
+static string MakeToolContractText(const string nProc)
+{
+ // we're testing in the compact form of JSON output - there's already enough
+ // quote-escaping white noise, without having newlines in the mix as well
+ //
+
+ const string header =
+ {
+ "{"
+ "\"driver\":{"
+ "\"env\":{},"
+ "\"exe\":\"frobber --resolved-tool-contract\","
+ "\"serialization\":\"json\""
+ "},"
+ "\"tool_contract\":{"
+ "\"_comment\":\"Created by v0.0.1\","
+ "\"description\":\"Frobb your files in a most delightful, nobbly way\","
+ "\"input_types\":["
+ "{"
+ "\"description\":\"Generic Txt file\","
+ "\"file_type_id\":\"PacBio.FileTypes.txt\","
+ "\"id\":\"txt_in\","
+ "\"title\":\"Txt file\""
+ "}"
+ "],"
+ "\"is_distributed\":true,"
+ "\"name\":\"frobber\","
+ "\"nproc\":"
+ };
+
+ const string footer =
+ {","
+ "\"output_types\":["
+ "{"
+ "\"default_name\":\"output\","
+ "\"description\":\"Generic Output Txt file\","
+ "\"file_type_id\":\"PacBio.FileTypes.txt\","
+ "\"id\":\"txt_out\","
+ "\"title\":\"Txt outfile\""
+ "}"
+ "],"
+ "\"resource_types\":["
+ "\"$tmpfile\","
+ "\"$tmpfile\","
+ "\"$tmpdir\""
+ "],"
+ "\"schema_options\":["
+ "{"
+ "\"$schema\":\"http://json-schema.org/draft-04/schema#\","
+ "\"pb_option\":{"
+ "\"default\":10,"
+ "\"description\":\"Max Number of lines to Copy\","
+ "\"name\":\"Max lines\","
+ "\"option_id\":\"frobber.task_options.max_nlines\","
+ "\"type\":\"integer\""
+ "},"
+ "\"properties\":{"
+ "\"frobber.task_options.max_nlines\":{"
+ "\"default\":10,"
+ "\"description\":\"Max Number of lines to Copy\","
+ "\"title\":\"Max lines\","
+ "\"type\":\"integer\""
+ "}"
+ "},"
+ "\"required\":["
+ "\"frobber.task_options.max_nlines\""
+ "],"
+ "\"title\":\"JSON Schema for frobber.task_options.max_nlines\","
+ "\"type\":\"object\""
+ "}"
+ "],"
+ "\"task_type\":\"pbsmrtpipe.task_types.standard\","
+ "\"tool_contract_id\":\"frobber.tasks.dev_txt_app\""
+ "},"
+ "\"tool_contract_id\":\"frobber.tasks.dev_txt_app\","
+ "\"version\":\"3.14\""
+ "}"
+ };
+ return header + nProc + footer;
+}
+
+TEST(CLI_ToolContractJsonPrinter, prints_expected_output)
+{
+ const string expectedText = MakeToolContractText("1");
+
+ // --------------------------------------------
+ // setup interface & tool contract config
+ // --------------------------------------------
+
+ Interface i {
+ "frobber",
+ "Frobb your files in a most delightful, nobbly way",
+ "3.14"
+ };
+ i.AddOptions({
+ {"max_nlines", "n", "Max Number of lines to Copy", Option::IntType(10)}
+ });
+
+ const string id = "frobber.tasks.dev_txt_app";
+ ToolContract::Task tcTask(id);
+ tcTask.InputFileTypes({
+ { "txt_in", "Txt file", "Generic Txt file", "PacBio.FileTypes.txt" }
+ });
+ tcTask.OutputFileTypes({
+ { "txt_out", "Txt outfile", "Generic Output Txt file", "PacBio.FileTypes.txt", "output" }
+ });
+ tcTask.ResourceTypes({
+ ResourceType::TMP_FILE,
+ ResourceType::TMP_FILE,
+ ResourceType::TMP_DIR
+ });
+ tcTask.Options({
+ { "max_nlines","Max lines" }
+ });
+
+ ToolContract::Config tcConfig(tcTask);
+ i.EnableToolContract(tcConfig);
+
+ // --------------------------------------------
+ // test tool contract output
+ // --------------------------------------------
+
+ stringstream s;
+ ToolContract::JsonPrinter::Print(i, s, -1);
+ EXPECT_EQ(expectedText, s.str());
+}
+
+TEST(CLI_ToolContractJsonPrinter, prints_expected_output_with_explicit_nproc)
+{
+ const string expectedText = MakeToolContractText("4");
+
+ // --------------------------------------------
+ // setup interface & tool contract config
+ // --------------------------------------------
+
+ Interface i {
+ "frobber",
+ "Frobb your files in a most delightful, nobbly way",
+ "3.14"
+ };
+ i.AddOptions({
+ {"max_nlines", "n", "Max Number of lines to Copy", Option::IntType(10)}
+ });
+
+ const string id = "frobber.tasks.dev_txt_app";
+ ToolContract::Task tcTask(id);
+ tcTask.InputFileTypes({
+ { "txt_in", "Txt file", "Generic Txt file", "PacBio.FileTypes.txt" }
+ });
+ tcTask.OutputFileTypes({
+ { "txt_out", "Txt outfile", "Generic Output Txt file", "PacBio.FileTypes.txt", "output" }
+ });
+ tcTask.ResourceTypes({
+ ResourceType::TMP_FILE,
+ ResourceType::TMP_FILE,
+ ResourceType::TMP_DIR
+ });
+ tcTask.Options({
+ { "max_nlines","Max lines" }
+ });
+ tcTask.NumProcessors(4);
+
+ ToolContract::Config tcConfig(tcTask);
+ i.EnableToolContract(tcConfig);
+
+ // --------------------------------------------
+ // test tool contract output
+ // --------------------------------------------
+
+ stringstream s;
+ ToolContract::JsonPrinter::Print(i, s, -1);
+ EXPECT_EQ(expectedText, s.str());
+}
+
+TEST(CLI_ToolContractJsonPrinter, prints_expected_output_with_max_nproc)
+{
+ const string expectedText = MakeToolContractText("\"$max_nproc\"");
+
+ // --------------------------------------------
+ // setup interface & tool contract config
+ // --------------------------------------------
+
+ Interface i {
+ "frobber",
+ "Frobb your files in a most delightful, nobbly way",
+ "3.14"
+ };
+ i.AddOptions({
+ {"max_nlines", "n", "Max Number of lines to Copy", Option::IntType(10)}
+ });
+
+ const string id = "frobber.tasks.dev_txt_app";
+ ToolContract::Task tcTask(id);
+ tcTask.InputFileTypes({
+ { "txt_in", "Txt file", "Generic Txt file", "PacBio.FileTypes.txt" }
+ });
+ tcTask.OutputFileTypes({
+ { "txt_out", "Txt outfile", "Generic Output Txt file", "PacBio.FileTypes.txt", "output" }
+ });
+ tcTask.ResourceTypes({
+ ResourceType::TMP_FILE,
+ ResourceType::TMP_FILE,
+ ResourceType::TMP_DIR
+ });
+ tcTask.Options({
+ { "max_nlines","Max lines" }
+ });
+ tcTask.NumProcessors(Task::MAX_NPROC);
+
+ ToolContract::Config tcConfig(tcTask);
+ i.EnableToolContract(tcConfig);
+
+ // --------------------------------------------
+ // test tool contract output
+ // --------------------------------------------
+
+ stringstream s;
+ ToolContract::JsonPrinter::Print(i, s, -1);
+ EXPECT_EQ(expectedText, s.str());
+}
diff --git a/tests/src/cli/test_VersionPrinter.cpp b/tests/src/cli/test_VersionPrinter.cpp
new file mode 100644
index 0000000..84b44f5
--- /dev/null
+++ b/tests/src/cli/test_VersionPrinter.cpp
@@ -0,0 +1,19 @@
+#include <pbcopper/cli/VersionPrinter.h>
+
+#include <pbcopper/cli/Interface.h>
+#include <gtest/gtest.h>
+#include <sstream>
+#include <string>
+using namespace PacBio;
+using namespace PacBio::CLI;
+using namespace std;
+
+TEST(CLI_VersionPrinter, prints_expected_version_output)
+{
+ const Interface interface{ "myApp", "does the things", "3.14" };
+ const string expectedText = "myApp 3.14\n";
+
+ stringstream s;
+ VersionPrinter::Print(interface, s);
+ EXPECT_EQ(expectedText, s.str());
+}
diff --git a/tests/src/data/test_Interval.cpp b/tests/src/data/test_Interval.cpp
new file mode 100644
index 0000000..9e2f410
--- /dev/null
+++ b/tests/src/data/test_Interval.cpp
@@ -0,0 +1,199 @@
+
+#include <pbcopper/data/Interval.h>
+#include <pbcopper/data/Position.h>
+#include <gtest/gtest.h>
+using namespace PacBio;
+using namespace PacBio::Data;
+using namespace std;
+
+TEST(Data_Interval, default_interval_contains_zeroes)
+{
+ Interval<Position> empty;
+ EXPECT_EQ(0, empty.Start());
+ EXPECT_EQ(0, empty.End());
+}
+
+TEST(Data_Interval, construction_with_explicit_start_and_end_retained)
+{
+ Interval<Position> normal(5, 8);
+ EXPECT_EQ(5, normal.Start());
+ EXPECT_EQ(8, normal.End());
+}
+
+TEST(Data_Interval, construction_without_explict_endpoint_yields_endpoint_of_start_plus_one)
+{
+ Interval<Position> singleton(4);
+ EXPECT_EQ(4, singleton.Start());
+ EXPECT_EQ(5, singleton.End());
+}
+
+TEST(Data_Interval, self_equals_self)
+{
+ Interval<Position> empty;
+ Interval<Position> singleton(4);
+ Interval<Position> normal(5, 8);
+
+ EXPECT_TRUE(empty == empty);
+ EXPECT_TRUE(singleton == singleton);
+ EXPECT_TRUE(normal == normal);
+}
+
+TEST(Data_Interval, intervals_with_same_endpoints_are_equal)
+{
+ Interval<Position> empty;
+ Interval<Position> sameAsEmpty;
+ Interval<Position> singleton(4);
+ Interval<Position> sameAsSingleton(4,5);
+ Interval<Position> normal(5, 8);
+ Interval<Position> sameAsNormal(5, 8);
+
+ EXPECT_TRUE(empty == sameAsEmpty);
+ EXPECT_TRUE(singleton == sameAsSingleton);
+ EXPECT_TRUE(normal == sameAsNormal);
+}
+
+TEST(Data_Interval, intervals_with_different_endpoints_are_not_equal)
+{
+ Interval<Position> empty;
+ Interval<Position> singleton(4);
+ Interval<Position> normal(5, 8);
+ Interval<Position> different(20, 40);
+
+ EXPECT_FALSE(empty == singleton);
+ EXPECT_FALSE(empty == normal);
+ EXPECT_FALSE(empty == different);
+ EXPECT_FALSE(singleton == normal);
+ EXPECT_FALSE(normal == different);
+}
+
+TEST(Data_Interval, can_be_copy_constructed)
+{
+ Interval<Position> original(5, 8);
+ Interval<Position> copy(original);
+ EXPECT_TRUE(original == copy);
+}
+
+TEST(Data_Interval, can_be_copy_assigned)
+{
+ Interval<Position> original(5, 8);
+ Interval<Position> copy = original;
+ EXPECT_TRUE(original == copy);
+}
+
+TEST(Data_Interval, modification_of_copy_does_not_affect_original)
+{
+ Interval<Position> original(5, 8);
+ Interval<Position> copy(original);
+ copy.Start(2);
+ copy.End(10);
+
+ EXPECT_FALSE(original == copy);
+ EXPECT_EQ(2, copy.Start());
+ EXPECT_EQ(10, copy.End());
+}
+
+TEST(Data_Interval, self_covers_and_is_covered_by_self)
+{
+ Interval<Position> interval(2, 4);
+ EXPECT_TRUE(interval.Covers(interval));
+ EXPECT_TRUE(interval.CoveredBy(interval));
+}
+
+TEST(Data_Interval, covers_and_coveredby_are_reciprocal)
+{
+ Interval<Position> inner(3, 5);
+ Interval<Position> outer(1, 7);
+
+ EXPECT_TRUE(inner.CoveredBy(outer)); // a.coveredBy(b)
+ EXPECT_TRUE(outer.Covers(inner)); // thus b.covers(a)
+
+ EXPECT_FALSE(inner == outer); // if a != b
+ EXPECT_FALSE(inner.Covers(outer)); // then !a.covers(b)
+}
+
+TEST(Data_Interval, completely_disjoint_intervals_do_not_cover_each_other)
+{
+ Interval<Position> left(3, 5);
+ Interval<Position> right(6, 8);
+
+ EXPECT_FALSE(left.Covers(right));
+ EXPECT_FALSE(right.Covers(left));
+ EXPECT_FALSE(left.CoveredBy(right));
+ EXPECT_FALSE(right.CoveredBy(left));
+}
+
+TEST(Data_Interval, no_coverage_when_left_stop_same_as_right_start)
+{
+ Interval<Position> left(3, 5);
+ Interval<Position> right(5, 8);
+
+ EXPECT_FALSE(left.Covers(right));
+ EXPECT_FALSE(left.CoveredBy(right));
+}
+
+TEST(Data_Interval, coverage_when_endpoints_are_same_and_inner_start_contained_by_outer)
+{
+ Interval<Position> inner(6, 8);
+ Interval<Position> outer(5, 8);
+
+ EXPECT_TRUE(outer.Covers(inner));
+ EXPECT_TRUE(inner.CoveredBy(outer));
+}
+
+TEST(Data_Interval, calculates_proper_intersection)
+{
+ Interval<Position> interval1(2, 4);
+ Interval<Position> interval2(3, 5);
+ Interval<Position> interval3(6, 8);
+ Interval<Position> interval4(1, 7);
+ Interval<Position> interval5(5, 8);
+
+ EXPECT_TRUE(interval1.Intersects(interval1)); // self-intersection: a.intersects(a)
+
+ EXPECT_TRUE(interval1.Intersects(interval2)); // if a.intersects(b)
+ EXPECT_TRUE(interval2.Intersects(interval1)); // then b.intersects(a)
+
+ EXPECT_TRUE(interval4.Covers(interval1)); // if b.covers(a),
+ EXPECT_TRUE(interval1.Intersects(interval4)); // then a.intersects(b)
+ EXPECT_TRUE(interval4.Intersects(interval1)); // and b.intersects(a)
+
+ EXPECT_FALSE(interval2.Intersects(interval3)); // b.start > a.stop (obvious disjoint)
+ EXPECT_FALSE(interval2.Intersects(interval5)); // b.start == a.stop (intervals are right open, so disjoint)
+}
+
+TEST(Data_Interval, acceptable_endpoints_are_valid)
+{
+ Interval<Position> zeroStartInterval(0,1);
+ Interval<Position> nonZeroStartInterval(4,5);
+
+ EXPECT_TRUE(zeroStartInterval.IsValid());
+ EXPECT_TRUE(nonZeroStartInterval.IsValid());
+}
+
+TEST(Data_Interval, nonsensical_endpoints_are_invalid)
+{
+ Interval<Position> defaultConstructedInterval;
+ Interval<Position> zeroEmptyValue(0,0);
+ Interval<Position> nonZeroEmptyInterval(4,4);
+ Interval<Position> badOrderingInterval(5,4);
+
+ EXPECT_FALSE(defaultConstructedInterval.IsValid());
+ EXPECT_FALSE(zeroEmptyValue.IsValid());
+ EXPECT_FALSE(nonZeroEmptyInterval.IsValid());
+ EXPECT_FALSE(badOrderingInterval.IsValid());
+}
+
+TEST(Data_Interval, calculates_proper_length)
+{
+ Interval<Position> interval1(2, 4);
+ Interval<Position> interval2(3, 5);
+ Interval<Position> interval3(6, 8);
+ Interval<Position> interval4(1, 7);
+ Interval<Position> interval5(5, 8);
+
+ EXPECT_EQ(2, interval1.Length());
+ EXPECT_EQ(2, interval2.Length());
+ EXPECT_EQ(2, interval3.Length());
+ EXPECT_EQ(6, interval4.Length());
+ EXPECT_EQ(3, interval5.Length());
+}
diff --git a/tests/src/data/test_MovieName.cpp b/tests/src/data/test_MovieName.cpp
new file mode 100644
index 0000000..64d5dec
--- /dev/null
+++ b/tests/src/data/test_MovieName.cpp
@@ -0,0 +1,153 @@
+
+#include <pbcopper/data/MovieName.h>
+#include <gtest/gtest.h>
+#include <sstream>
+using namespace PacBio;
+using namespace PacBio::Data;
+using namespace std;
+
+namespace PacBio {
+namespace Data {
+namespace tests {
+
+auto makeMovieName = [](void)
+{
+ return MovieName{ "m54001_160623_195125" };
+};
+
+} // namespace tests
+} // namespace Data
+} // namespace PacBio
+
+TEST(Data_MovieName, construct_from_lvalue_string)
+{
+ EXPECT_NO_THROW(
+ {
+ const string input = "m54001_160623_195125";
+ const MovieName m(input);
+ EXPECT_EQ("160623_195125", m.RunStartTime());
+ EXPECT_EQ("54001", m.InstrumentName());
+ });
+}
+
+TEST(Data_MovieName, construct_from_rvalue_string)
+{
+ EXPECT_NO_THROW(
+ {
+ const MovieName m("m54001_160623_195125");
+ EXPECT_EQ("160623_195125", m.RunStartTime());
+ EXPECT_EQ("54001", m.InstrumentName());
+ });
+}
+
+TEST(Data_MovieName, construct_from_name_parts)
+{
+ EXPECT_NO_THROW(
+ {
+ const MovieName m("54001", "160623_195125");
+ EXPECT_EQ("160623_195125", m.RunStartTime());
+ EXPECT_EQ("54001", m.InstrumentName());
+ });
+}
+
+TEST(Data_MovieName, copy_constructor)
+{
+ const MovieName m("m54001_160623_195125");
+ EXPECT_EQ("160623_195125", m.RunStartTime());
+ EXPECT_EQ("54001", m.InstrumentName());
+
+ const MovieName m2(m);
+ EXPECT_EQ("160623_195125", m2.RunStartTime());
+ EXPECT_EQ("54001", m2.InstrumentName());
+}
+
+TEST(Data_MovieName, copy_assign)
+{
+ const MovieName m("m54001_160623_195125");
+ EXPECT_EQ("160623_195125", m.RunStartTime());
+ EXPECT_EQ("54001", m.InstrumentName());
+
+ MovieName m2("mDummy_Dummy_Dummy");
+ m2 = m;
+
+ EXPECT_EQ("160623_195125", m2.RunStartTime());
+ EXPECT_EQ("54001", m2.InstrumentName());
+}
+
+TEST(Data_MovieName, move_constructor)
+{
+ const MovieName m(tests::makeMovieName());
+ EXPECT_EQ("160623_195125", m.RunStartTime());
+ EXPECT_EQ("54001", m.InstrumentName());
+}
+
+TEST(Data_MovieName, move_assign)
+{
+ MovieName m2("mDummy_Dummy_Dummy");
+ m2 = tests::makeMovieName();
+
+ EXPECT_EQ("160623_195125", m2.RunStartTime());
+ EXPECT_EQ("54001", m2.InstrumentName());
+}
+
+TEST(Data_MovieName, constructed_from_name_prints_same_name)
+{
+ const string expected = "m54001_160623_195125";
+
+ const MovieName m(expected);
+ EXPECT_EQ(expected, m.ToStdString());
+}
+
+TEST(Data_MovieName, constructed_from_name_parts_prints_expected_combination)
+{
+ const string expected = "m54001_160623_195125";
+
+ const MovieName m("54001", "160623_195125");
+ EXPECT_EQ(expected, m.ToStdString());
+}
+
+TEST(Data_MovieName, compares_equal_if_printed_names_equal)
+{
+ const MovieName m("m54001_160623_195125");
+ const MovieName m2("m54001_160623_195125");
+ const MovieName m3("m10000_160623_195125");
+
+ EXPECT_TRUE(m == m2);
+ EXPECT_FALSE(m != m2);
+
+ EXPECT_FALSE(m == m3);
+ EXPECT_TRUE(m != m3);
+}
+
+TEST(Data_MovieName, constructed_from_name_prints_expected_value_to_output_operator)
+{
+ const string expected = "m54001_160623_195125";
+
+ const MovieName m(expected);
+ stringstream s;
+ s << m;
+
+ EXPECT_EQ(expected, s.str());
+}
+
+TEST(Data_MovieName, constructed_from_name_parts_prints_expected_value_to_output_operator)
+{
+ const string expected = "m54001_160623_195125";
+
+ const MovieName m("54001", "160623_195125");
+ stringstream s;
+ s << m;
+
+ EXPECT_EQ(expected, s.str());
+}
+
+TEST(Data_MovieName, constructed_properly_from_input_operator)
+{
+ const string name = "m54001_160623_195125";
+ stringstream s(name);
+ MovieName m;
+ s >> m;
+
+ EXPECT_EQ("160623_195125", m.RunStartTime());
+ EXPECT_EQ("54001", m.InstrumentName());
+}
diff --git a/tests/src/data/test_RSMovieName.cpp b/tests/src/data/test_RSMovieName.cpp
new file mode 100644
index 0000000..b491a74
--- /dev/null
+++ b/tests/src/data/test_RSMovieName.cpp
@@ -0,0 +1,217 @@
+
+#include <pbcopper/data/RSMovieName.h>
+#include <gtest/gtest.h>
+#include <sstream>
+using namespace PacBio;
+using namespace PacBio::Data;
+using namespace std;
+
+namespace PacBio {
+namespace Data {
+namespace tests {
+
+auto makeRSMovieName = [](void)
+{
+ return RSMovieName{ "m140415_143853_42175_c100635972550000001823121909121417_s1_p0" };
+};
+
+} // namespace tests
+} // namespace Data
+} // namespace PacBio
+
+TEST(Data_RSMovieName, construct_from_lvalue_string)
+{
+ EXPECT_NO_THROW(
+ {
+ const string input = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0";
+ const RSMovieName m(input);
+ EXPECT_EQ("140415_143853", m.RunStartTime());
+ EXPECT_EQ("42175", m.InstrumentSerialNumber());
+ EXPECT_EQ("c100635972550000001823121909121417", m.SMRTCellBarcode());
+ EXPECT_EQ("s1", m.SetNumber());
+ EXPECT_EQ("p0", m.PartNumber());
+ EXPECT_FALSE(m.IsReagentExpired());
+ });
+}
+
+TEST(Data_RSMovieName, construct_from_rvalue_string)
+{
+ EXPECT_NO_THROW(
+ {
+ const RSMovieName m("m140415_143853_42175_c100635972550000001823121909121417_s1_p0");
+ EXPECT_EQ("140415_143853", m.RunStartTime());
+ EXPECT_EQ("42175", m.InstrumentSerialNumber());
+ EXPECT_EQ("c100635972550000001823121909121417", m.SMRTCellBarcode());
+ EXPECT_EQ("s1", m.SetNumber());
+ EXPECT_EQ("p0", m.PartNumber());
+ EXPECT_FALSE(m.IsReagentExpired());
+ });
+}
+
+TEST(Data_RSMovieName, construct_from_name_parts)
+{
+ EXPECT_NO_THROW(
+ {
+ const RSMovieName m("140415_143853",
+ "42175",
+ "c100635972550000001823121909121417",
+ "s1",
+ "p0");
+ EXPECT_EQ("140415_143853", m.RunStartTime());
+ EXPECT_EQ("42175", m.InstrumentSerialNumber());
+ EXPECT_EQ("c100635972550000001823121909121417", m.SMRTCellBarcode());
+ EXPECT_EQ("s1", m.SetNumber());
+ EXPECT_EQ("p0", m.PartNumber());
+ EXPECT_FALSE(m.IsReagentExpired());
+ });
+}
+
+TEST(Data_RSMovieName, copy_constructor)
+{
+ const RSMovieName m("m140415_143853_42175_c100635972550000001823121909121417_s1_p0");
+ EXPECT_EQ("140415_143853", m.RunStartTime());
+ EXPECT_EQ("42175", m.InstrumentSerialNumber());
+ EXPECT_EQ("c100635972550000001823121909121417", m.SMRTCellBarcode());
+ EXPECT_EQ("s1", m.SetNumber());
+ EXPECT_EQ("p0", m.PartNumber());
+ EXPECT_FALSE(m.IsReagentExpired());
+
+ const RSMovieName m2(m);
+ EXPECT_EQ("140415_143853", m2.RunStartTime());
+ EXPECT_EQ("42175", m2.InstrumentSerialNumber());
+ EXPECT_EQ("c100635972550000001823121909121417", m2.SMRTCellBarcode());
+ EXPECT_EQ("s1", m2.SetNumber());
+ EXPECT_EQ("p0", m2.PartNumber());
+ EXPECT_FALSE(m2.IsReagentExpired());
+}
+
+TEST(Data_RSMovieName, copy_assign)
+{
+ const RSMovieName m("m140415_143853_42175_c100635972550000001823121909121417_s1_p0");
+ EXPECT_EQ("140415_143853", m.RunStartTime());
+ EXPECT_EQ("42175", m.InstrumentSerialNumber());
+ EXPECT_EQ("c100635972550000001823121909121417", m.SMRTCellBarcode());
+ EXPECT_EQ("s1", m.SetNumber());
+ EXPECT_EQ("p0", m.PartNumber());
+ EXPECT_FALSE(m.IsReagentExpired());
+
+ RSMovieName m2("mDummy_Dummy_Dummy_Dummy_Dummy_Dummy");
+ m2 = m;
+
+ EXPECT_EQ("140415_143853", m2.RunStartTime());
+ EXPECT_EQ("42175", m2.InstrumentSerialNumber());
+ EXPECT_EQ("c100635972550000001823121909121417", m2.SMRTCellBarcode());
+ EXPECT_EQ("s1", m2.SetNumber());
+ EXPECT_EQ("p0", m2.PartNumber());
+ EXPECT_FALSE(m2.IsReagentExpired());
+}
+
+TEST(Data_RSMovieName, move_constructor)
+{
+ const RSMovieName m(tests::makeRSMovieName());
+ EXPECT_EQ("140415_143853", m.RunStartTime());
+ EXPECT_EQ("42175", m.InstrumentSerialNumber());
+ EXPECT_EQ("c100635972550000001823121909121417", m.SMRTCellBarcode());
+ EXPECT_EQ("s1", m.SetNumber());
+ EXPECT_EQ("p0", m.PartNumber());
+ EXPECT_FALSE(m.IsReagentExpired());
+}
+
+TEST(Data_RSMovieName, move_assign)
+{
+ RSMovieName m2("mDummy_Dummy_Dummy_Dummy_Dummy_Dummy");
+ m2 = tests::makeRSMovieName();
+
+ EXPECT_EQ("140415_143853", m2.RunStartTime());
+ EXPECT_EQ("42175", m2.InstrumentSerialNumber());
+ EXPECT_EQ("c100635972550000001823121909121417", m2.SMRTCellBarcode());
+ EXPECT_EQ("s1", m2.SetNumber());
+ EXPECT_EQ("p0", m2.PartNumber());
+ EXPECT_FALSE(m2.IsReagentExpired());
+}
+
+TEST(Data_RSMovieName, expired_reagent_character_recognized)
+{
+ { // not expired
+ const RSMovieName m("m140415_143853_42175_c100635972550000001823121909121417_s1_p0");
+ EXPECT_FALSE(m.IsReagentExpired());
+ }
+ { // expired
+ const RSMovieName m("m140415_143853_42175_c100635972550000001823121909121417_s1_X0");
+ EXPECT_TRUE(m.IsReagentExpired());
+ }
+}
+
+TEST(Data_RSMovieName, constructed_from_name_prints_same_name)
+{
+ const string expected = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0";
+
+ const RSMovieName m(expected);
+ EXPECT_EQ(expected, m.ToStdString());
+}
+
+TEST(Data_RSMovieName, constructed_from_name_parts_prints_expected_combination)
+{
+ const string expected = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0";
+
+ const RSMovieName m("140415_143853",
+ "42175",
+ "c100635972550000001823121909121417",
+ "s1",
+ "p0");
+ EXPECT_EQ(expected, m.ToStdString());
+}
+
+TEST(Data_RSMovieName, compares_equal_if_printed_names_equal)
+{
+ const RSMovieName m("m140415_143853_42175_c100635972550000001823121909121417_s1_p0");
+ const RSMovieName m2("m140415_143853_42175_c100635972550000001823121909121417_s1_p0");
+ const RSMovieName m3("m140415_143853_42175_c100635972550000001823121909121417_s1_p1");
+
+ EXPECT_TRUE(m == m2);
+ EXPECT_FALSE(m != m2);
+
+ EXPECT_FALSE(m == m3);
+ EXPECT_TRUE(m != m3);
+}
+
+TEST(Data_RSMovieName, constructed_from_name_prints_expected_value_to_output_operator)
+{
+ const string expected = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0";
+
+ const RSMovieName m(expected);
+ stringstream s;
+ s << m;
+
+ EXPECT_EQ(expected, s.str());
+}
+
+TEST(Data_RSMovieName, constructed_from_name_parts_prints_expected_value_to_output_operator)
+{
+ const string expected = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0";
+
+ const RSMovieName m("140415_143853",
+ "42175",
+ "c100635972550000001823121909121417",
+ "s1",
+ "p0");
+ stringstream s;
+ s << m;
+
+ EXPECT_EQ(expected, s.str());
+}
+
+TEST(Data_RSMovieName, constructed_properly_from_input_operator)
+{
+ const string name = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0";
+ stringstream s(name);
+ RSMovieName m;
+ s >> m;
+
+ EXPECT_EQ("140415_143853", m.RunStartTime());
+ EXPECT_EQ("42175", m.InstrumentSerialNumber());
+ EXPECT_EQ("c100635972550000001823121909121417", m.SMRTCellBarcode());
+ EXPECT_EQ("s1", m.SetNumber());
+ EXPECT_EQ("p0", m.PartNumber());
+ EXPECT_FALSE(m.IsReagentExpired());
+}
diff --git a/tests/src/data/test_RSReadName.cpp b/tests/src/data/test_RSReadName.cpp
new file mode 100644
index 0000000..bc86a98
--- /dev/null
+++ b/tests/src/data/test_RSReadName.cpp
@@ -0,0 +1,188 @@
+
+#include <pbcopper/data/RSReadName.h>
+#include <gtest/gtest.h>
+using namespace PacBio;
+using namespace PacBio::Data;
+using namespace std;
+
+TEST(Data_RSReadName, read_name_from_string)
+{
+ const string movieName = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0";
+ const Zmw zmw = 553;
+ const Position queryStart = 3100;
+ const Position queryEnd = 11230;
+ const Interval<Position> queryInterval{ queryStart, queryEnd };
+
+ const RSReadName readName("m140415_143853_42175_c100635972550000001823121909121417_s1_p0/553/3100_11230");
+
+ EXPECT_EQ(movieName, readName.MovieName().ToStdString());
+ EXPECT_EQ(zmw, readName.Zmw());
+
+ EXPECT_EQ(queryInterval, readName.QueryInterval());
+ EXPECT_EQ(queryInterval.Start(), readName.QueryStart());
+ EXPECT_EQ(queryInterval.End(), readName.QueryEnd());
+
+ EXPECT_FALSE(readName.IsCCS());
+}
+
+TEST(Data_RSReadName, ccs_read_name_from_string)
+{
+ const string movieName = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0";
+ const Zmw zmw = 553;
+ const Position queryStart = 3100;
+ const Position queryEnd = 11230;
+ const Interval<Position> queryInterval{ queryStart, queryEnd };
+
+ const RSReadName readName("m140415_143853_42175_c100635972550000001823121909121417_s1_p0/553/ccs");
+
+ EXPECT_EQ(movieName, readName.MovieName().ToStdString());
+ EXPECT_EQ(zmw, readName.Zmw());
+
+ EXPECT_TRUE(readName.IsCCS());
+
+ EXPECT_THROW(readName.QueryEnd(), std::runtime_error);
+ EXPECT_THROW(readName.QueryInterval(), std::runtime_error);
+ EXPECT_THROW(readName.QueryStart(), std::runtime_error);
+}
+
+TEST(Data_RSReadName, read_name_from_parts_with_query_interval)
+{
+ const string movieName = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0";
+ const Zmw zmw = 553;
+ const Position queryStart = 3100;
+ const Position queryEnd = 11230;
+ const Interval<Position> queryInterval{ queryStart, queryEnd };
+
+ const RSReadName readName{ RSMovieName{movieName}, zmw, queryInterval };
+
+ EXPECT_EQ(movieName, readName.MovieName().ToStdString());
+ EXPECT_EQ(zmw, readName.Zmw());
+
+ EXPECT_EQ(queryInterval, readName.QueryInterval());
+ EXPECT_EQ(queryInterval.Start(), readName.QueryStart());
+ EXPECT_EQ(queryInterval.End(), readName.QueryEnd());
+
+ EXPECT_FALSE(readName.IsCCS());
+}
+
+TEST(Data_RSReadName, read_name_from_parts_with_query_positions)
+{
+ const string movieName = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0";
+ const Zmw zmw = 553;
+ const Position queryStart = 3100;
+ const Position queryEnd = 11230;
+ const Interval<Position> queryInterval{ queryStart, queryEnd };
+
+ const RSReadName readName{ RSMovieName{movieName}, zmw, queryStart, queryEnd };
+
+ EXPECT_EQ(movieName, readName.MovieName().ToStdString());
+ EXPECT_EQ(zmw, readName.Zmw());
+
+ EXPECT_EQ(queryInterval, readName.QueryInterval());
+ EXPECT_EQ(queryInterval.Start(), readName.QueryStart());
+ EXPECT_EQ(queryInterval.End(), readName.QueryEnd());
+
+ EXPECT_FALSE(readName.IsCCS());
+}
+
+TEST(Data_RSReadName, ccs_read_name_from_parts)
+{
+ const string movieName = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0";
+ const Zmw zmw = 553;
+ const Position queryStart = 3100;
+ const Position queryEnd = 11230;
+ const Interval<Position> queryInterval{ queryStart, queryEnd };
+
+ const RSReadName readName{ RSMovieName{movieName}, zmw, CCSTag() };
+
+ EXPECT_EQ(movieName, readName.MovieName().ToStdString());
+ EXPECT_EQ(zmw, readName.Zmw());
+
+ EXPECT_TRUE(readName.IsCCS());
+
+ EXPECT_THROW(readName.QueryEnd(), std::runtime_error);
+ EXPECT_THROW(readName.QueryInterval(), std::runtime_error);
+ EXPECT_THROW(readName.QueryStart(), std::runtime_error);
+}
+
+
+TEST(Data_RSReadName, compares_equal_if_printed_names_equal)
+{
+ const RSReadName r("m140415_143853_42175_c100635972550000001823121909121417_s1_p0/553/3100_11230");
+ const RSReadName r2("m140415_143853_42175_c100635972550000001823121909121417_s1_p0/553/3100_11230");
+ const RSReadName r3("m140415_143853_42175_c100635972550000001823121909121417_s1_p0/553/ccs");
+ const RSReadName r4("m140415_143853_42175_c100635972550000001823121909121417_s1_p0/222/3100_11230");
+
+ EXPECT_TRUE(r == r2);
+ EXPECT_FALSE(r == r3);
+ EXPECT_FALSE(r == r4);
+
+ EXPECT_FALSE(r != r2);
+ EXPECT_TRUE(r != r3);
+ EXPECT_TRUE(r != r4);
+}
+
+TEST(Data_RSReadName, constructed_from_name_prints_expected_value_to_output_operator)
+{
+ const string name = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0/553/3100_11230";
+
+ const RSReadName r(name);
+ stringstream s;
+ s << r;
+ EXPECT_EQ(name, s.str());
+}
+
+TEST(Data_RSReadName, constructed_from_name_parts_prints_expected_value_to_output_operator)
+{
+ const string name = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0/553/3100_11230";
+
+ const RSReadName r{ RSMovieName{"m140415_143853_42175_c100635972550000001823121909121417_s1_p0"},
+ 553,
+ Interval<Position>{3100, 11230} };
+
+ stringstream s;
+ s << r;
+ EXPECT_EQ(name, s.str());
+}
+
+TEST(Data_RSReadName, constructed_from_ccs_name_parts_prints_expected_value_to_output_operator)
+{
+ const string ccs = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0/553/ccs";
+
+ const RSReadName r{ RSMovieName{"m140415_143853_42175_c100635972550000001823121909121417_s1_p0"},
+ 553,
+ CCSTag() };
+
+ stringstream s;
+ s << r;
+ EXPECT_EQ(ccs, s.str());
+}
+
+TEST(Data_RSReadName, constructed_properly_from_input_operator)
+{
+ const string name = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0/553/3100_11230";
+
+ stringstream s(name);
+ RSReadName r;
+ s >> r;
+
+ EXPECT_EQ("m140415_143853_42175_c100635972550000001823121909121417_s1_p0", r.MovieName().ToStdString());
+ EXPECT_EQ(553, r.Zmw());
+ EXPECT_EQ(3100, r.QueryStart());
+ EXPECT_EQ(11230, r.QueryEnd());
+ EXPECT_FALSE(r.IsCCS());
+}
+
+TEST(Data_RSReadName, ccs_constructed_properly_from_input_operator)
+{
+ const string ccs = "m140415_143853_42175_c100635972550000001823121909121417_s1_p0/553/ccs";
+
+ stringstream s(ccs);
+ RSReadName r;
+ s >> r;
+
+ EXPECT_EQ("m140415_143853_42175_c100635972550000001823121909121417_s1_p0", r.MovieName().ToStdString());
+ EXPECT_EQ(553, r.Zmw());
+ EXPECT_TRUE(r.IsCCS());
+}
+
diff --git a/tests/src/data/test_ReadName.cpp b/tests/src/data/test_ReadName.cpp
new file mode 100644
index 0000000..200a716
--- /dev/null
+++ b/tests/src/data/test_ReadName.cpp
@@ -0,0 +1,187 @@
+
+#include <pbcopper/data/ReadName.h>
+#include <gtest/gtest.h>
+using namespace PacBio;
+using namespace PacBio::Data;
+using namespace std;
+
+TEST(Data_ReadName, read_name_from_string)
+{
+ const string movieName = "m54001_160623_195125";
+ const Zmw zmw = 553;
+ const Position queryStart = 3100;
+ const Position queryEnd = 11230;
+ const Interval<Position> queryInterval{ queryStart, queryEnd };
+
+ const ReadName readName("m54001_160623_195125/553/3100_11230");
+
+ EXPECT_EQ(movieName, readName.MovieName().ToStdString());
+ EXPECT_EQ(zmw, readName.Zmw());
+
+ EXPECT_EQ(queryInterval, readName.QueryInterval());
+ EXPECT_EQ(queryInterval.Start(), readName.QueryStart());
+ EXPECT_EQ(queryInterval.End(), readName.QueryEnd());
+
+ EXPECT_FALSE(readName.IsCCS());
+}
+
+TEST(Data_ReadName, ccs_read_name_from_string)
+{
+ const string movieName = "m54001_160623_195125";
+ const Zmw zmw = 553;
+ const Position queryStart = 3100;
+ const Position queryEnd = 11230;
+ const Interval<Position> queryInterval{ queryStart, queryEnd };
+
+ const ReadName readName("m54001_160623_195125/553/ccs");
+
+ EXPECT_EQ(movieName, readName.MovieName().ToStdString());
+ EXPECT_EQ(zmw, readName.Zmw());
+
+ EXPECT_TRUE(readName.IsCCS());
+
+ EXPECT_THROW(readName.QueryEnd(), std::runtime_error);
+ EXPECT_THROW(readName.QueryInterval(), std::runtime_error);
+ EXPECT_THROW(readName.QueryStart(), std::runtime_error);
+}
+
+TEST(Data_ReadName, read_name_from_parts_with_query_interval)
+{
+ const string movieName = "m54001_160623_195125";
+ const Zmw zmw = 553;
+ const Position queryStart = 3100;
+ const Position queryEnd = 11230;
+ const Interval<Position> queryInterval{ queryStart, queryEnd };
+
+ const ReadName readName{ MovieName{movieName}, zmw, queryInterval };
+
+ EXPECT_EQ(movieName, readName.MovieName().ToStdString());
+ EXPECT_EQ(zmw, readName.Zmw());
+
+ EXPECT_EQ(queryInterval, readName.QueryInterval());
+ EXPECT_EQ(queryInterval.Start(), readName.QueryStart());
+ EXPECT_EQ(queryInterval.End(), readName.QueryEnd());
+
+ EXPECT_FALSE(readName.IsCCS());
+}
+
+TEST(Data_ReadName, read_name_from_parts_with_query_positions)
+{
+ const string movieName = "m54001_160623_195125";
+ const Zmw zmw = 553;
+ const Position queryStart = 3100;
+ const Position queryEnd = 11230;
+ const Interval<Position> queryInterval{ queryStart, queryEnd };
+
+ const ReadName readName{ MovieName{movieName}, zmw, queryStart, queryEnd };
+
+ EXPECT_EQ(movieName, readName.MovieName().ToStdString());
+ EXPECT_EQ(zmw, readName.Zmw());
+
+ EXPECT_EQ(queryInterval, readName.QueryInterval());
+ EXPECT_EQ(queryInterval.Start(), readName.QueryStart());
+ EXPECT_EQ(queryInterval.End(), readName.QueryEnd());
+
+ EXPECT_FALSE(readName.IsCCS());
+}
+
+TEST(Data_ReadName, ccs_read_name_from_parts)
+{
+ const string movieName = "m54001_160623_195125";
+ const Zmw zmw = 553;
+ const Position queryStart = 3100;
+ const Position queryEnd = 11230;
+ const Interval<Position> queryInterval{ queryStart, queryEnd };
+
+ const ReadName readName{ MovieName{movieName}, zmw, CCSTag() };
+
+ EXPECT_EQ(movieName, readName.MovieName().ToStdString());
+ EXPECT_EQ(zmw, readName.Zmw());
+
+ EXPECT_TRUE(readName.IsCCS());
+
+ EXPECT_THROW(readName.QueryEnd(), std::runtime_error);
+ EXPECT_THROW(readName.QueryInterval(), std::runtime_error);
+ EXPECT_THROW(readName.QueryStart(), std::runtime_error);
+}
+
+
+TEST(Data_ReadName, compares_equal_if_printed_names_equal)
+{
+ const ReadName r("m54001_160623_195125/553/3100_11230");
+ const ReadName r2("m54001_160623_195125/553/3100_11230");
+ const ReadName r3("m54001_160623_195125/553/ccs");
+ const ReadName r4("m54001_160623_195125/222/3100_11230");
+
+ EXPECT_TRUE(r == r2);
+ EXPECT_FALSE(r == r3);
+ EXPECT_FALSE(r == r4);
+
+ EXPECT_FALSE(r != r2);
+ EXPECT_TRUE(r != r3);
+ EXPECT_TRUE(r != r4);
+}
+
+TEST(Data_ReadName, constructed_from_name_prints_expected_value_to_output_operator)
+{
+ const string name = "m54001_160623_195125/553/3100_11230";
+
+ const ReadName r(name);
+ stringstream s;
+ s << r;
+ EXPECT_EQ(name, s.str());
+}
+
+TEST(Data_ReadName, constructed_from_name_parts_prints_expected_value_to_output_operator)
+{
+ const string name = "m54001_160623_195125/553/3100_11230";
+
+ const ReadName r{ MovieName{"m54001_160623_195125"},
+ 553,
+ Interval<Position>{3100, 11230} };
+
+ stringstream s;
+ s << r;
+ EXPECT_EQ(name, s.str());
+}
+
+TEST(Data_ReadName, constructed_from_ccs_name_parts_prints_expected_value_to_output_operator)
+{
+ const string ccs = "m54001_160623_195125/553/ccs";
+
+ const ReadName r{ MovieName{"m54001_160623_195125"},
+ 553,
+ CCSTag() };
+
+ stringstream s;
+ s << r;
+ EXPECT_EQ(ccs, s.str());
+}
+
+TEST(Data_ReadName, constructed_properly_from_input_operator)
+{
+ const string name = "m54001_160623_195125/553/3100_11230";
+
+ stringstream s(name);
+ ReadName r;
+ s >> r;
+
+ EXPECT_EQ("m54001_160623_195125", r.MovieName().ToStdString());
+ EXPECT_EQ(553, r.Zmw());
+ EXPECT_EQ(3100, r.QueryStart());
+ EXPECT_EQ(11230, r.QueryEnd());
+ EXPECT_FALSE(r.IsCCS());
+}
+
+TEST(Data_ReadName, ccs_constructed_properly_from_input_operator)
+{
+ const string ccs = "m54001_160623_195125/553/ccs";
+
+ stringstream s(ccs);
+ ReadName r;
+ s >> r;
+
+ EXPECT_EQ("m54001_160623_195125", r.MovieName().ToStdString());
+ EXPECT_EQ(553, r.Zmw());
+ EXPECT_TRUE(r.IsCCS());
+}
diff --git a/tests/src/json/test_JSON.cpp b/tests/src/json/test_JSON.cpp
new file mode 100644
index 0000000..8d3d90d
--- /dev/null
+++ b/tests/src/json/test_JSON.cpp
@@ -0,0 +1,15 @@
+#include <pbcopper/json/JSON.h>
+#include <gtest/gtest.h>
+using namespace PacBio;
+using namespace PacBio::JSON;
+using namespace std;
+
+TEST(JSON_Json, default_constructed_object_is_null)
+{
+ Json j;
+ EXPECT_TRUE(j.is_null());
+}
+
+// nlohmann tests are __massive__ . Probably no need to check all here, but come
+// back and test the main features we use
+
diff --git a/tests/src/logging/test_Logging.cpp b/tests/src/logging/test_Logging.cpp
new file mode 100644
index 0000000..e7171fa
--- /dev/null
+++ b/tests/src/logging/test_Logging.cpp
@@ -0,0 +1,60 @@
+
+#include <pbcopper/logging/Logging.h>
+#include <boost/algorithm/string/predicate.hpp>
+#include <gtest/gtest.h>
+#include <sstream>
+#include <string>
+using namespace PacBio;
+using namespace PacBio::Logging;
+using namespace std;
+
+//
+// NOTE: We need to scope the Loggers used here and invoke the macros that take
+// an explicit logger (rather than the convenience, default
+// singleton-logger macros). Essentially, the message queue is not
+// guaranteed to be processed until the logger goes out of scope. That's
+// usually at program exit, and no problem for production applications...
+// but we need finer control for testing here.
+//
+
+static const string infoMsg = "*** Application INFO ***";
+static const string noticeMsg = "*** Application NOTE ***";
+static const string warnMsg = "*** Application WARNING ***";
+
+
+TEST(Logging_Logger, info_message_logged_to_stream)
+{
+ stringstream s;
+ {
+ Logger logger(s, LogLevel::INFO);
+ PBLOGGER_INFO(logger) << infoMsg;
+ }
+ EXPECT_TRUE(s.str().find(infoMsg) != string::npos);
+}
+
+TEST(Logging_Logger, custom_logging_sinks_receive_expected_messages)
+{
+ // specify custom output destinations by log level... and also 'tee' one
+ // log level stream (warning) into separate ostreams
+
+ stringstream info;
+ stringstream notice;
+ stringstream warn, warn2;
+ map<LogLevel, OStreams> logConfig =
+ {
+ {LogLevel::INFO, {info}},
+ {LogLevel::NOTICE, {notice}},
+ {LogLevel::WARN, {warn, warn2}}
+ };
+
+ {
+ Logger logger(logConfig);
+ PBLOGGER_INFO(logger) << infoMsg;
+ PBLOGGER_NOTICE(logger) << noticeMsg;
+ PBLOGGER_WARN(logger) << warnMsg;
+ }
+ EXPECT_TRUE(info.str().find(infoMsg) != string::npos);
+ EXPECT_TRUE(notice.str().find(noticeMsg) != string::npos);
+ EXPECT_TRUE(warn.str().find(warnMsg) != string::npos);
+ EXPECT_TRUE(warn2.str().find(warnMsg) != string::npos);
+}
diff --git a/tests/src/stream/test_Stream.cpp b/tests/src/stream/test_Stream.cpp
new file mode 100644
index 0000000..7fc2372
--- /dev/null
+++ b/tests/src/stream/test_Stream.cpp
@@ -0,0 +1,319 @@
+
+#include "OStreamRedirector.h"
+#include <pbcopper/stream/Stream.h>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <cctype>
+#include <cmath>
+using namespace PacBio;
+using namespace PacBio::Stream;
+
+Source<char> stringInput = [](Sink<char> s)
+{
+ const std::string original = { "Test String " };
+ for (auto e : original)
+ s(static_cast<char>(e));
+};
+
+Source<char> newlinedStringInput = [](Sink<char> s)
+{
+ const std::string original = {"Some\nfile\nwith\nnewlines\n"};
+ for (auto e : original)
+ s(static_cast<char>(e));
+};
+
+Source<std::string> stringListInput = [](Sink<std::string> s)
+{
+ const std::vector<std::string> input = { "string1", "string2", "foo", "bar" };
+ for (auto e : input)
+ s(e);
+};
+
+Sink<char> consoleOutput = [](char c)
+{
+ std::cerr << c;
+};
+
+Sink<std::string> consoleStringOutput = [](std::string s)
+{
+ std::cerr << s;
+};
+
+Sink<std::string> newlinedStringOutput = [](std::string s)
+{
+ consoleStringOutput(s);
+ std::cerr << std::endl;
+};
+
+Transform<char, char> toAllCaps = [](Sink<char> si, char c)
+{
+ si(toupper(c));
+};
+
+Transform<char, std::string> getLines = [](Sink<std::string> si, char c)
+{
+ static std::string current;
+ Sink<char> collectChar = [&](char c)
+ {
+ current.push_back(c);
+ };
+
+ if (c == '\n')
+ {
+ si(current);
+ current.clear();
+ }
+ else
+ collectChar(c);
+};
+
+Transform<char, std::string> getWords = [](Sink<std::string> si, char c)
+{
+ static std::string current;
+ Sink<char> collectChar = [&](char c)
+ {
+ current.push_back(c);
+ };
+
+ if (c == ' ')
+ {
+ si(current);
+ current.clear();
+ }
+ else
+ collectChar(c);
+};
+
+Transform<std::string, char> wordToChars = [](Sink<char> si, std::string s)
+{
+ for (auto e : s)
+ si(static_cast<char>(e));
+ si(' ');
+};
+
+// connect source -> sink
+// connect source -> transform -> sink // same type
+// connect source -> transform -> sink // different type
+// connect source -> transform -> transform -> sink // same types
+// connect source -> transform -> transform -> sink // differing types
+// connect source -> transform -> transform -> sink // use named sub-streams
+
+TEST(Stream_Stream, input_to_console)
+{
+ std::stringstream s;
+ tests::CerrRedirect redirect(s.rdbuf());
+
+ stringInput >> consoleOutput;
+
+ EXPECT_EQ("Test String ", s.str());
+}
+
+TEST(Stream_Stream, char_input_to_all_caps)
+{
+ std::stringstream s;
+ tests::CerrRedirect redirect(s.rdbuf());
+
+ stringInput >> toAllCaps >> consoleOutput;
+
+ EXPECT_EQ("TEST STRING ", s.str());
+}
+
+TEST(Stream_Stream, stringlist_to_chars)
+{
+ std::stringstream s;
+ tests::CerrRedirect redirect(s.rdbuf());
+
+ stringListInput >> wordToChars >> consoleOutput;
+
+ EXPECT_EQ("string1 string2 foo bar ", s.str());
+}
+
+TEST(Stream_Stream, char_input_split_into_words_and_printed_to_console)
+{
+ std::stringstream s;
+ tests::CerrRedirect redirect(s.rdbuf());
+
+ stringInput >> getWords >> newlinedStringOutput;
+
+ EXPECT_EQ("Test\nString\n", s.str());
+}
+
+TEST(Stream_Stream, newlined_input_printed_to_console)
+{
+ std::stringstream s;
+ tests::CerrRedirect redirect(s.rdbuf());
+
+ newlinedStringInput >> getLines >> newlinedStringOutput;
+
+ EXPECT_EQ("Some\nfile\nwith\nnewlines\n", s.str());
+}
+
+TEST(Stream_Stream, composing_transform_chains)
+{
+ std::stringstream s;
+ tests::CerrRedirect redirect(s.rdbuf());
+
+ newlinedStringInput >> getLines >> wordToChars >> consoleOutput;
+
+ EXPECT_EQ("Some file with newlines ", s.str());
+}
+
+TEST(Stream_Stream, composing_named_transform_chains)
+{
+ std::stringstream s;
+ tests::CerrRedirect redirect(s.rdbuf());
+
+ Source<std::string> inputLines = newlinedStringInput >> getLines;
+ Sink<std::string> wordOutput = wordToChars >> consoleOutput;
+ inputLines >> wordOutput;
+
+ EXPECT_EQ("Some file with newlines ", s.str());
+}
+
+Source<int> intList = [](Sink<int> out)
+{
+ const std::vector<int> ints = { 1, 2, 3, 4, 5 };
+ for (auto i : ints)
+ out(i);
+};
+
+
+Sink<int> intConsoleOutput = [](int i)
+{
+ std::cerr << i;
+};
+
+Sink<int> spacedIntConsoleOutput = [](int i)
+{
+ intConsoleOutput(i);
+ std::cerr << " ";
+};
+
+Sink<double> doubleConsoleOutput = [](double d)
+{
+ std::cerr << d;
+};
+
+Sink<double> spacedDoubleConsoleOutput = [](double d)
+{
+ doubleConsoleOutput(d);
+ std::cerr << " ";
+};
+
+Transform<int, int> tripled = [](Sink<int> out, int i)
+{
+ out(i*3);
+};
+
+Transform<int, double> squareRoot = [](Sink<double> out, int i)
+{
+ out( sqrt(i) );
+};
+
+Transform<double, std::string> addCookies = [](Sink<std::string> out, double d)
+{
+ const std::string result = std::to_string(d) + "cookies";
+ out(result);
+};
+
+struct MyClass
+{
+ static void Increment(const Sink<int>& out, const int& i)
+ {
+ out(i + 1);
+ }
+};
+
+TEST(Stream_Stream, arithmetic_stream_to_console)
+{
+ std::stringstream s;
+ tests::CerrRedirect redirect(s.rdbuf());
+
+ intList >> spacedIntConsoleOutput;
+
+ EXPECT_EQ("1 2 3 4 5 ", s.str());
+}
+
+TEST(Stream_Stream, arithmetic_transformed_stream_to_console)
+{
+ std::stringstream s;
+ tests::CerrRedirect redirect(s.rdbuf());
+
+ intList >> tripled
+ >> spacedIntConsoleOutput;
+
+ EXPECT_EQ("3 6 9 12 15 ", s.str());
+}
+
+TEST(Stream_Stream, arithmetic_transformed_to_different_type_stream_to_console)
+{
+ std::stringstream s;
+ tests::CerrRedirect redirect(s.rdbuf());
+
+ intList >> tripled
+ >> squareRoot
+ >> spacedDoubleConsoleOutput;
+
+ EXPECT_EQ("1.73205 2.44949 3 3.4641 3.87298 ", s.str());
+}
+
+TEST(Stream_Stream, append_text_to_arithmetic_stream)
+{
+ std::stringstream s;
+ tests::CerrRedirect redirect(s.rdbuf());
+
+ intList >> tripled
+ >> squareRoot
+ >> addCookies
+ >> newlinedStringOutput;
+
+ EXPECT_EQ("1.732051cookies\n"
+ "2.449490cookies\n"
+ "3.000000cookies\n"
+ "3.464102cookies\n"
+ "3.872983cookies\n", s.str());
+}
+
+TEST(Stream_Stream, append_text_to_arithmetic_stream_then_modify)
+{
+ std::stringstream s;
+ tests::CerrRedirect redirect(s.rdbuf());
+
+ intList >> tripled // x * 3
+ >> squareRoot // sqrt(x)
+ >> addCookies // string result = to_string(x) + "cookies"
+ >> wordToChars // converts strings to chars
+ >> toAllCaps // toupper(c)
+ >> getWords // chars back to strings, split on delim = ' '
+ >> newlinedStringOutput; // cerr << s << endl
+
+ EXPECT_EQ("1.732051COOKIES\n"
+ "2.449490COOKIES\n"
+ "3.000000COOKIES\n"
+ "3.464102COOKIES\n"
+ "3.872983COOKIES\n", s.str());
+}
+
+TEST(Stream_Stream, stream_works_with_static_public_member_function)
+{
+ std::stringstream s;
+ tests::CerrRedirect redirect(s.rdbuf());
+
+ intList >> Transform<int,int>(&MyClass::Increment)
+ >> tripled // x * 3
+ >> squareRoot // sqrt(x)
+ >> addCookies // string result = to_string(x) + "cookies"
+ >> wordToChars // converts strings to chars
+ >> toAllCaps // toupper(c)
+ >> getWords // chars back to strings, split on delim = ' '
+ >> newlinedStringOutput; // cerr << s << endl
+
+ EXPECT_EQ("2.449490COOKIES\n"
+ "3.000000COOKIES\n"
+ "3.464102COOKIES\n"
+ "3.872983COOKIES\n"
+ "4.242641COOKIES\n", s.str());
+}
+
diff --git a/tests/src/utility/test_CallbackTimer.cpp b/tests/src/utility/test_CallbackTimer.cpp
new file mode 100644
index 0000000..251ca9f
--- /dev/null
+++ b/tests/src/utility/test_CallbackTimer.cpp
@@ -0,0 +1,97 @@
+
+#include <pbcopper/utility/CallbackTimer.h>
+#include <gtest/gtest.h>
+#include <thread>
+
+using namespace PacBio;
+using namespace PacBio::Utility;
+
+namespace tests {
+
+class CallbackCounter
+{
+public:
+ CallbackCounter(void) : hits_(0) { }
+ uint32_t Count(void) const { return hits_; }
+ void Ping(void) { ++hits_; }
+
+private:
+ uint32_t hits_;
+};
+
+CallbackCounter freeFunctionCounter;
+
+void tst_callback(void)
+{ freeFunctionCounter.Ping(); }
+
+auto ping = [](tests::CallbackCounter& counter)
+{
+ counter.Ping();
+};
+
+} // namespace tests
+
+TEST(Utility_CallbackTimer, scheduled_callbacks_fired_as_expected)
+{
+ //
+ // NOTE: This test case does allow for some wiggle in execution
+ // timing, due to inherent fuzziness in timing such precision without
+ // a lot of extra low-level work.
+ //
+
+ CallbackTimer t;
+ tests::CallbackCounter counterA;
+ tests::CallbackCounter counterB;
+ tests::CallbackCounter counterC;
+ tests::CallbackCounter counterSS;
+
+ // Timer fires once on lambda, 2ms from now
+ const auto a = t.Schedule(2, 0, [&](){ tests::ping(counterA); });
+ EXPECT_TRUE(t.IsActive(a));
+
+ // Timer fires every 1ms on lambda, starting 2ms from now
+ const auto b = t.Schedule(2, 1, [&]() { tests::ping(counterB); });
+ EXPECT_TRUE(t.IsActive(b));
+
+ // Timer fires every 1ms on lambda, starting now
+ const auto c = t.Schedule(0, 1, [&]() { tests::ping(counterC); });
+ EXPECT_TRUE(t.IsActive(c));
+
+ // Timer firest once on free function, 2ms from now
+ auto ff = t.Schedule(2, 0, &tests::tst_callback);
+ EXPECT_TRUE(t.IsActive(ff));
+
+ // explicit "single shot" lambda, 2ms from now
+ CallbackTimer::SingleShot(2, [&]() { tests::ping(counterSS); });
+
+ // sleep a bit to let periodic timers fire
+ std::this_thread::sleep_for(std::chrono::milliseconds(10));
+ EXPECT_EQ(1, counterA.Count()); // effectively single-shot
+ EXPECT_LE(7, counterB.Count()); // >= 7 triggers since scheduling
+ EXPECT_LE(9, counterC.Count()); // >= 9 triggers since schedling
+ EXPECT_EQ(1, counterSS.Count()); // explicit single-shot
+ EXPECT_EQ(1, tests::freeFunctionCounter.Count()); // effectively single-shot
+
+ // single-shot callbacks only called once
+ EXPECT_EQ(1, counterA.Count());
+ EXPECT_EQ(1, counterSS.Count());
+ EXPECT_EQ(1, tests::freeFunctionCounter.Count());
+}
+
+TEST(Utility_CallbackTimer, canceled_callbacks_not_called)
+{
+ CallbackTimer t;
+ tests::CallbackCounter counterC;
+ const auto c = t.Schedule(0, 1, [&]() { tests::ping(counterC); });
+ EXPECT_TRUE(t.IsActive(c));
+ t.Cancel(c);
+ EXPECT_FALSE(t.IsActive(c));
+
+ // sleep a bit to give callback on counterC a chance to fire, it would have
+ // fired ~5x if cancel failed... give an extra firing 'wiggle room' for
+ // test harness
+ const auto preSleepCallbackHitCount = counterC.Count();
+ std::this_thread::sleep_for(std::chrono::milliseconds(5));
+ EXPECT_LE(preSleepCallbackHitCount, counterC.Count());
+ EXPECT_GE(preSleepCallbackHitCount+1, counterC.Count());
+}
diff --git a/tests/src/utility/test_Stopwatch.cpp b/tests/src/utility/test_Stopwatch.cpp
new file mode 100644
index 0000000..5183beb
--- /dev/null
+++ b/tests/src/utility/test_Stopwatch.cpp
@@ -0,0 +1,67 @@
+
+
+#include <pbcopper/utility/Stopwatch.h>
+#include <gtest/gtest.h>
+#include <thread>
+
+using namespace PacBio;
+using namespace PacBio::Utility;
+
+//
+// using float compares and 'fuzzy' compares to allow for inherent wiggle room
+// in system execution
+//
+
+TEST(Utility_Stopwatch, determines_elapsed_time_in_milliseconds)
+{
+ Stopwatch s;
+ std::this_thread::sleep_for(std::chrono::milliseconds(3));
+ auto elapsed = s.ElapsedMilliseconds();
+ ASSERT_FLOAT_EQ(3, elapsed);
+}
+
+TEST(Utility_Stopwatch, determines_elapsed_time_in_seconds)
+{
+ // seconds
+ Stopwatch s;
+ std::this_thread::sleep_for(std::chrono::milliseconds(3));
+ auto elapsed = s.ElapsedSeconds();
+ ASSERT_FLOAT_EQ(3/1000, elapsed);
+}
+
+TEST(Utility_Stopwatch, determines_elapsed_time_in_user_precision)
+{
+ //
+ // NOTE: from http://en.cppreference.com/w/cpp/thread/sleep_for :
+ //
+ // "Blocks the execution of the current thread for at least the specified
+ // sleep_duration. A steady clock is used to measure the duration. This
+ // function may block for longer than sleep_duration due to scheduling or
+ // resource contention delays."
+ //
+ // This means we know that we'll sleep here for at least 3ms, but can't
+ // really know **exactly** know how much longer. To have a reliable unit
+ // test, working at the microsecond-level of granularity, we'll have to give
+ // up checking for (even fuzzy) equality and check that we're in the right
+ // ballpark.
+ //
+ // Remember that we're _not_ testing std::chrono directly here, only that our
+ // Stopwatch provides the requested duration.
+ //
+
+ Stopwatch s;
+ std::this_thread::sleep_for(std::chrono::milliseconds(3));
+ auto elapsed = s.Elapsed<std::chrono::microseconds>();
+ ASSERT_LE(3000, elapsed);
+ ASSERT_LE(elapsed, 30000);
+}
+
+TEST(Utility_Stopwatch, determines_elapsed_time_since_reset)
+{
+ Stopwatch s;
+ std::this_thread::sleep_for(std::chrono::milliseconds(3));
+ s.Reset();
+ std::this_thread::sleep_for(std::chrono::milliseconds(3));
+ auto elapsed = s.ElapsedMilliseconds();
+ ASSERT_FLOAT_EQ(3, elapsed);
+}
diff --git a/tests/src/utility/test_SystemInfo.cpp b/tests/src/utility/test_SystemInfo.cpp
new file mode 100644
index 0000000..87208bb
--- /dev/null
+++ b/tests/src/utility/test_SystemInfo.cpp
@@ -0,0 +1,34 @@
+
+#include <pbcopper/utility/SystemInfo.h>
+#include <gtest/gtest.h>
+using namespace PacBio;
+using namespace PacBio::Utility;
+
+namespace PacBio {
+namespace Utility {
+namespace tests {
+
+// one sort of 'manual' endianness check - not used by the library
+static inline bool isLittleEndian(void)
+{
+ static const int i = 1;
+ static const char* const c = reinterpret_cast<const char* const>(&i);
+ return (*c == 1);
+}
+
+} // namespace tests
+} // namespace Utility
+} // namespace PacBio
+
+TEST(Utility_SystemInfo, proper_byte_order_detected)
+{
+ if (tests::isLittleEndian()) {
+ EXPECT_EQ(SystemInfo::LittleEndian, SystemInfo::ByteOrder());
+ EXPECT_TRUE(SystemInfo::IsLittleEndian());
+ EXPECT_FALSE(SystemInfo::IsBigEndian());
+ } else {
+ EXPECT_EQ(SystemInfo::BigEndian, SystemInfo::ByteOrder());
+ EXPECT_FALSE(SystemInfo::IsLittleEndian());
+ EXPECT_TRUE(SystemInfo::IsBigEndian());
+ }
+}
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-med/pbcopper.git
More information about the debian-med-commit
mailing list